Indentation only. No any functional changes.
diff --git a/isisd/dict.c b/isisd/dict.c
index 4c787ac..86206a3 100644
--- a/isisd/dict.c
+++ b/isisd/dict.c
@@ -14,7 +14,7 @@
* into proprietary software; there is no requirement for such software to
* contain a copyright notice related to this source.
*
- * $Id: dict.c,v 1.1 2003/12/23 08:09:47 jardin Exp $
+ * $Id: dict.c,v 1.2 2004/09/10 20:48:21 hasso Exp $
* $Name: $
*/
@@ -25,7 +25,8 @@
#include "dict.h"
#ifdef KAZLIB_RCSID
-static const char rcsid[] = "$Id: dict.c,v 1.1 2003/12/23 08:09:47 jardin Exp $";
+static const char rcsid[] =
+ "$Id: dict.c,v 1.2 2004/09/10 20:48:21 hasso Exp $";
#endif
/*
@@ -62,8 +63,8 @@
#define dict_nil(D) (&(D)->nilnode)
#define DICT_DEPTH_MAX 64
-static dnode_t *dnode_alloc(void *context);
-static void dnode_free(dnode_t *node, void *context);
+static dnode_t *dnode_alloc (void *context);
+static void dnode_free (dnode_t * node, void *context);
/*
* Perform a ``left rotation'' adjustment on the tree. The given node P and
@@ -72,28 +73,32 @@
* for P. The ordering of the keys within the tree is thus preserved.
*/
-static void rotate_left(dnode_t *upper)
+static void
+rotate_left (dnode_t * upper)
{
- dnode_t *lower, *lowleft, *upparent;
+ dnode_t *lower, *lowleft, *upparent;
- lower = upper->right;
- upper->right = lowleft = lower->left;
- lowleft->parent = upper;
+ lower = upper->right;
+ upper->right = lowleft = lower->left;
+ lowleft->parent = upper;
- lower->parent = upparent = upper->parent;
+ lower->parent = upparent = upper->parent;
- /* don't need to check for root node here because root->parent is
- the sentinel nil node, and root->parent->left points back to root */
+ /* don't need to check for root node here because root->parent is
+ the sentinel nil node, and root->parent->left points back to root */
- if (upper == upparent->left) {
- upparent->left = lower;
- } else {
- assert (upper == upparent->right);
- upparent->right = lower;
+ if (upper == upparent->left)
+ {
+ upparent->left = lower;
+ }
+ else
+ {
+ assert (upper == upparent->right);
+ upparent->right = lower;
}
- lower->left = upper;
- upper->parent = lower;
+ lower->left = upper;
+ upper->parent = lower;
}
/*
@@ -101,25 +106,29 @@
* the same procedure, but with left and right interchanged.
*/
-static void rotate_right(dnode_t *upper)
+static void
+rotate_right (dnode_t * upper)
{
- dnode_t *lower, *lowright, *upparent;
+ dnode_t *lower, *lowright, *upparent;
- lower = upper->left;
- upper->left = lowright = lower->right;
- lowright->parent = upper;
+ lower = upper->left;
+ upper->left = lowright = lower->right;
+ lowright->parent = upper;
- lower->parent = upparent = upper->parent;
+ lower->parent = upparent = upper->parent;
- if (upper == upparent->right) {
- upparent->right = lower;
- } else {
- assert (upper == upparent->left);
- upparent->left = lower;
+ if (upper == upparent->right)
+ {
+ upparent->right = lower;
+ }
+ else
+ {
+ assert (upper == upparent->left);
+ upparent->left = lower;
}
- lower->right = upper;
- upper->parent = lower;
+ lower->right = upper;
+ upper->parent = lower;
}
/*
@@ -127,13 +136,14 @@
* node and free everything under it. Used by dict_free().
*/
-static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil)
+static void
+free_nodes (dict_t * dict, dnode_t * node, dnode_t * nil)
{
- if (node == nil)
- return;
- free_nodes(dict, node->left, nil);
- free_nodes(dict, node->right, nil);
- dict->freenode(node, dict->context);
+ if (node == nil)
+ return;
+ free_nodes (dict, node->left, nil);
+ free_nodes (dict, node->right, nil);
+ dict->freenode (node, dict->context);
}
/*
@@ -145,26 +155,32 @@
* debugging purposes.
*/
-static int verify_bintree(dict_t *dict)
+static int
+verify_bintree (dict_t * dict)
{
- dnode_t *first, *next;
+ dnode_t *first, *next;
- first = dict_first(dict);
+ first = dict_first (dict);
- if (dict->dupes) {
- while (first && (next = dict_next(dict, first))) {
- if (dict->compare(first->key, next->key) > 0)
- return 0;
- first = next;
- }
- } else {
- while (first && (next = dict_next(dict, first))) {
- if (dict->compare(first->key, next->key) >= 0)
- return 0;
- first = next;
+ if (dict->dupes)
+ {
+ while (first && (next = dict_next (dict, first)))
+ {
+ if (dict->compare (first->key, next->key) > 0)
+ return 0;
+ first = next;
}
}
- return 1;
+ else
+ {
+ while (first && (next = dict_next (dict, first)))
+ {
+ if (dict->compare (first->key, next->key) >= 0)
+ return 0;
+ first = next;
+ }
+ }
+ return 1;
}
@@ -181,29 +197,32 @@
* subtree is not red-black.
*/
-static unsigned int verify_redblack(dnode_t *nil, dnode_t *root)
+static unsigned int
+verify_redblack (dnode_t * nil, dnode_t * root)
{
- unsigned height_left, height_right;
+ unsigned height_left, height_right;
- if (root != nil) {
- height_left = verify_redblack(nil, root->left);
- height_right = verify_redblack(nil, root->right);
- if (height_left == 0 || height_right == 0)
+ if (root != nil)
+ {
+ height_left = verify_redblack (nil, root->left);
+ height_right = verify_redblack (nil, root->right);
+ if (height_left == 0 || height_right == 0)
+ return 0;
+ if (height_left != height_right)
+ return 0;
+ if (root->color == dnode_red)
+ {
+ if (root->left->color != dnode_black)
return 0;
- if (height_left != height_right)
+ if (root->right->color != dnode_black)
return 0;
- if (root->color == dnode_red) {
- if (root->left->color != dnode_black)
- return 0;
- if (root->right->color != dnode_black)
- return 0;
- return height_left;
+ return height_left;
}
- if (root->color != dnode_black)
- return 0;
- return height_left + 1;
- }
- return 1;
+ if (root->color != dnode_black)
+ return 0;
+ return height_left + 1;
+ }
+ return 1;
}
/*
@@ -212,13 +231,14 @@
* detect a mismatch.
*/
-static dictcount_t verify_node_count(dnode_t *nil, dnode_t *root)
+static dictcount_t
+verify_node_count (dnode_t * nil, dnode_t * root)
{
- if (root == nil)
- return 0;
- else
- return 1 + verify_node_count(nil, root->left)
- + verify_node_count(nil, root->right);
+ if (root == nil)
+ return 0;
+ else
+ return 1 + verify_node_count (nil, root->left)
+ + verify_node_count (nil, root->right);
}
/*
@@ -228,54 +248,58 @@
* returns zero. It is intended for debugging purposes.
*/
-static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node)
+static int
+verify_dict_has_node (dnode_t * nil, dnode_t * root, dnode_t * node)
{
- if (root != nil) {
- return root == node
- || verify_dict_has_node(nil, root->left, node)
- || verify_dict_has_node(nil, root->right, node);
+ if (root != nil)
+ {
+ return root == node
+ || verify_dict_has_node (nil, root->left, node)
+ || verify_dict_has_node (nil, root->right, node);
}
- return 0;
+ return 0;
}
-
/*
* Dynamically allocate and initialize a dictionary object.
*/
-dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp)
+dict_t *
+dict_create (dictcount_t maxcount, dict_comp_t comp)
{
- dict_t *new = malloc(sizeof *new);
+ dict_t *new = malloc (sizeof *new);
- if (new) {
- new->compare = comp;
- new->allocnode = dnode_alloc;
- new->freenode = dnode_free;
- new->context = NULL;
- new->nodecount = 0;
- new->maxcount = maxcount;
- new->nilnode.left = &new->nilnode;
- new->nilnode.right = &new->nilnode;
- new->nilnode.parent = &new->nilnode;
- new->nilnode.color = dnode_black;
- new->dupes = 0;
+ if (new)
+ {
+ new->compare = comp;
+ new->allocnode = dnode_alloc;
+ new->freenode = dnode_free;
+ new->context = NULL;
+ new->nodecount = 0;
+ new->maxcount = maxcount;
+ new->nilnode.left = &new->nilnode;
+ new->nilnode.right = &new->nilnode;
+ new->nilnode.parent = &new->nilnode;
+ new->nilnode.color = dnode_black;
+ new->dupes = 0;
}
- return new;
+ return new;
}
/*
* Select a different set of node allocator routines.
*/
-void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
- dnode_free_t fr, void *context)
+void
+dict_set_allocator (dict_t * dict, dnode_alloc_t al,
+ dnode_free_t fr, void *context)
{
- assert (dict_count(dict) == 0);
- assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
+ assert (dict_count (dict) == 0);
+ assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
- dict->allocnode = al ? al : dnode_alloc;
- dict->freenode = fr ? fr : dnode_free;
- dict->context = context;
+ dict->allocnode = al ? al : dnode_alloc;
+ dict->freenode = fr ? fr : dnode_free;
+ dict->context = context;
}
/*
@@ -283,10 +307,11 @@
* from the tree before deleting it is required.
*/
-void dict_destroy(dict_t *dict)
+void
+dict_destroy (dict_t * dict)
{
- assert (dict_isempty(dict));
- free(dict);
+ assert (dict_isempty (dict));
+ free (dict);
}
/*
@@ -294,112 +319,117 @@
* installed free routine. The dictionary is emptied.
*/
-void dict_free_nodes(dict_t *dict)
+void
+dict_free_nodes (dict_t * dict)
{
- dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
- free_nodes(dict, root, nil);
- dict->nodecount = 0;
- dict->nilnode.left = &dict->nilnode;
- dict->nilnode.right = &dict->nilnode;
+ dnode_t *nil = dict_nil (dict), *root = dict_root (dict);
+ free_nodes (dict, root, nil);
+ dict->nodecount = 0;
+ dict->nilnode.left = &dict->nilnode;
+ dict->nilnode.right = &dict->nilnode;
}
/*
* Obsolescent function, equivalent to dict_free_nodes
*/
-void dict_free(dict_t *dict)
+void
+dict_free (dict_t * dict)
{
#ifdef KAZLIB_OBSOLESCENT_DEBUG
- assert ("call to obsolescent function dict_free()" && 0);
+ assert ("call to obsolescent function dict_free()" && 0);
#endif
- dict_free_nodes(dict);
+ dict_free_nodes (dict);
}
/*
* Initialize a user-supplied dictionary object.
*/
-dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp)
+dict_t *
+dict_init (dict_t * dict, dictcount_t maxcount, dict_comp_t comp)
{
- dict->compare = comp;
- dict->allocnode = dnode_alloc;
- dict->freenode = dnode_free;
- dict->context = NULL;
- dict->nodecount = 0;
- dict->maxcount = maxcount;
- dict->nilnode.left = &dict->nilnode;
- dict->nilnode.right = &dict->nilnode;
- dict->nilnode.parent = &dict->nilnode;
- dict->nilnode.color = dnode_black;
- dict->dupes = 0;
- return dict;
+ dict->compare = comp;
+ dict->allocnode = dnode_alloc;
+ dict->freenode = dnode_free;
+ dict->context = NULL;
+ dict->nodecount = 0;
+ dict->maxcount = maxcount;
+ dict->nilnode.left = &dict->nilnode;
+ dict->nilnode.right = &dict->nilnode;
+ dict->nilnode.parent = &dict->nilnode;
+ dict->nilnode.color = dnode_black;
+ dict->dupes = 0;
+ return dict;
}
/*
* Initialize a dictionary in the likeness of another dictionary
*/
-void dict_init_like(dict_t *dict, const dict_t *template)
+void
+dict_init_like (dict_t * dict, const dict_t * template)
{
- dict->compare = template->compare;
- dict->allocnode = template->allocnode;
- dict->freenode = template->freenode;
- dict->context = template->context;
- dict->nodecount = 0;
- dict->maxcount = template->maxcount;
- dict->nilnode.left = &dict->nilnode;
- dict->nilnode.right = &dict->nilnode;
- dict->nilnode.parent = &dict->nilnode;
- dict->nilnode.color = dnode_black;
- dict->dupes = template->dupes;
+ dict->compare = template->compare;
+ dict->allocnode = template->allocnode;
+ dict->freenode = template->freenode;
+ dict->context = template->context;
+ dict->nodecount = 0;
+ dict->maxcount = template->maxcount;
+ dict->nilnode.left = &dict->nilnode;
+ dict->nilnode.right = &dict->nilnode;
+ dict->nilnode.parent = &dict->nilnode;
+ dict->nilnode.color = dnode_black;
+ dict->dupes = template->dupes;
- assert (dict_similar(dict, template));
+ assert (dict_similar (dict, template));
}
/*
* Remove all nodes from the dictionary (without freeing them in any way).
*/
-static void dict_clear(dict_t *dict)
+static void
+dict_clear (dict_t * dict)
{
- dict->nodecount = 0;
- dict->nilnode.left = &dict->nilnode;
- dict->nilnode.right = &dict->nilnode;
- dict->nilnode.parent = &dict->nilnode;
- assert (dict->nilnode.color == dnode_black);
+ dict->nodecount = 0;
+ dict->nilnode.left = &dict->nilnode;
+ dict->nilnode.right = &dict->nilnode;
+ dict->nilnode.parent = &dict->nilnode;
+ assert (dict->nilnode.color == dnode_black);
}
-
/*
* Verify the integrity of the dictionary structure. This is provided for
* debugging purposes, and should be placed in assert statements. Just because
* this function succeeds doesn't mean that the tree is not corrupt. Certain
* corruptions in the tree may simply cause undefined behavior.
- */
+ */
-int dict_verify(dict_t *dict)
+int
+dict_verify (dict_t * dict)
{
- dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
+ dnode_t *nil = dict_nil (dict), *root = dict_root (dict);
- /* check that the sentinel node and root node are black */
- if (root->color != dnode_black)
- return 0;
- if (nil->color != dnode_black)
- return 0;
- if (nil->right != nil)
- return 0;
- /* nil->left is the root node; check that its parent pointer is nil */
- if (nil->left->parent != nil)
- return 0;
- /* perform a weak test that the tree is a binary search tree */
- if (!verify_bintree(dict))
- return 0;
- /* verify that the tree is a red-black tree */
- if (!verify_redblack(nil, root))
- return 0;
- if (verify_node_count(nil, root) != dict_count(dict))
- return 0;
- return 1;
+ /* check that the sentinel node and root node are black */
+ if (root->color != dnode_black)
+ return 0;
+ if (nil->color != dnode_black)
+ return 0;
+ if (nil->right != nil)
+ return 0;
+ /* nil->left is the root node; check that its parent pointer is nil */
+ if (nil->left->parent != nil)
+ return 0;
+ /* perform a weak test that the tree is a binary search tree */
+ if (!verify_bintree (dict))
+ return 0;
+ /* verify that the tree is a red-black tree */
+ if (!verify_redblack (nil, root))
+ return 0;
+ if (verify_node_count (nil, root) != dict_count (dict))
+ return 0;
+ return 1;
}
/*
@@ -407,24 +437,25 @@
* allocator functions, and same status as to whether duplicates are allowed.
*/
-int dict_similar(const dict_t *left, const dict_t *right)
+int
+dict_similar (const dict_t * left, const dict_t * right)
{
- if (left->compare != right->compare)
- return 0;
+ if (left->compare != right->compare)
+ return 0;
- if (left->allocnode != right->allocnode)
- return 0;
+ if (left->allocnode != right->allocnode)
+ return 0;
- if (left->freenode != right->freenode)
- return 0;
+ if (left->freenode != right->freenode)
+ return 0;
- if (left->context != right->context)
- return 0;
+ if (left->context != right->context)
+ return 0;
- if (left->dupes != right->dupes)
- return 0;
+ if (left->dupes != right->dupes)
+ return 0;
- return 1;
+ return 1;
}
/*
@@ -434,37 +465,45 @@
* located node is returned.
*/
-dnode_t *dict_lookup(dict_t *dict, const void *key)
+dnode_t *
+dict_lookup (dict_t * dict, const void *key)
{
- dnode_t *root = dict_root(dict);
- dnode_t *nil = dict_nil(dict);
- dnode_t *saved;
- int result;
+ dnode_t *root = dict_root (dict);
+ dnode_t *nil = dict_nil (dict);
+ dnode_t *saved;
+ int result;
- /* simple binary search adapted for trees that contain duplicate keys */
+ /* simple binary search adapted for trees that contain duplicate keys */
- while (root != nil) {
- result = dict->compare(key, root->key);
- if (result < 0)
- root = root->left;
- else if (result > 0)
- root = root->right;
- else {
- if (!dict->dupes) { /* no duplicates, return match */
- return root;
- } else { /* could be dupes, find leftmost one */
- do {
- saved = root;
- root = root->left;
- while (root != nil && dict->compare(key, root->key))
- root = root->right;
- } while (root != nil);
- return saved;
+ while (root != nil)
+ {
+ result = dict->compare (key, root->key);
+ if (result < 0)
+ root = root->left;
+ else if (result > 0)
+ root = root->right;
+ else
+ {
+ if (!dict->dupes)
+ { /* no duplicates, return match */
+ return root;
+ }
+ else
+ { /* could be dupes, find leftmost one */
+ do
+ {
+ saved = root;
+ root = root->left;
+ while (root != nil && dict->compare (key, root->key))
+ root = root->right;
+ }
+ while (root != nil);
+ return saved;
}
}
}
- return NULL;
+ return NULL;
}
/*
@@ -472,31 +511,41 @@
* greater than the given key. If there is no such node, return null.
*/
-dnode_t *dict_lower_bound(dict_t *dict, const void *key)
+dnode_t *
+dict_lower_bound (dict_t * dict, const void *key)
{
- dnode_t *root = dict_root(dict);
- dnode_t *nil = dict_nil(dict);
- dnode_t *tentative = 0;
+ dnode_t *root = dict_root (dict);
+ dnode_t *nil = dict_nil (dict);
+ dnode_t *tentative = 0;
- while (root != nil) {
- int result = dict->compare(key, root->key);
+ while (root != nil)
+ {
+ int result = dict->compare (key, root->key);
- if (result > 0) {
- root = root->right;
- } else if (result < 0) {
- tentative = root;
- root = root->left;
- } else {
- if (!dict->dupes) {
- return root;
- } else {
- tentative = root;
- root = root->left;
+ if (result > 0)
+ {
+ root = root->right;
+ }
+ else if (result < 0)
+ {
+ tentative = root;
+ root = root->left;
+ }
+ else
+ {
+ if (!dict->dupes)
+ {
+ return root;
}
- }
+ else
+ {
+ tentative = root;
+ root = root->left;
+ }
+ }
}
-
- return tentative;
+
+ return tentative;
}
/*
@@ -504,31 +553,41 @@
* lower than the given key. If there is no such node, return null.
*/
-dnode_t *dict_upper_bound(dict_t *dict, const void *key)
+dnode_t *
+dict_upper_bound (dict_t * dict, const void *key)
{
- dnode_t *root = dict_root(dict);
- dnode_t *nil = dict_nil(dict);
- dnode_t *tentative = 0;
+ dnode_t *root = dict_root (dict);
+ dnode_t *nil = dict_nil (dict);
+ dnode_t *tentative = 0;
- while (root != nil) {
- int result = dict->compare(key, root->key);
+ while (root != nil)
+ {
+ int result = dict->compare (key, root->key);
- if (result < 0) {
- root = root->left;
- } else if (result > 0) {
- tentative = root;
- root = root->right;
- } else {
- if (!dict->dupes) {
- return root;
- } else {
- tentative = root;
- root = root->right;
+ if (result < 0)
+ {
+ root = root->left;
+ }
+ else if (result > 0)
+ {
+ tentative = root;
+ root = root->right;
+ }
+ else
+ {
+ if (!dict->dupes)
+ {
+ return root;
}
- }
+ else
+ {
+ tentative = root;
+ root = root->right;
+ }
+ }
}
-
- return tentative;
+
+ return tentative;
}
/*
@@ -539,95 +598,109 @@
* function returns true).
*/
-void dict_insert(dict_t *dict, dnode_t *node, const void *key)
+void
+dict_insert (dict_t * dict, dnode_t * node, const void *key)
{
- dnode_t *where = dict_root(dict), *nil = dict_nil(dict);
- dnode_t *parent = nil, *uncle, *grandpa;
- int result = -1;
+ dnode_t *where = dict_root (dict), *nil = dict_nil (dict);
+ dnode_t *parent = nil, *uncle, *grandpa;
+ int result = -1;
- node->key = key;
+ node->key = key;
- assert (!dict_isfull(dict));
- assert (!dict_contains(dict, node));
- assert (!dnode_is_in_a_dict(node));
+ assert (!dict_isfull (dict));
+ assert (!dict_contains (dict, node));
+ assert (!dnode_is_in_a_dict (node));
- /* basic binary tree insert */
+ /* basic binary tree insert */
- while (where != nil) {
- parent = where;
- result = dict->compare(key, where->key);
- /* trap attempts at duplicate key insertion unless it's explicitly allowed */
- assert (dict->dupes || result != 0);
- if (result < 0)
- where = where->left;
- else
- where = where->right;
+ while (where != nil)
+ {
+ parent = where;
+ result = dict->compare (key, where->key);
+ /* trap attempts at duplicate key insertion unless it's explicitly allowed */
+ assert (dict->dupes || result != 0);
+ if (result < 0)
+ where = where->left;
+ else
+ where = where->right;
}
- assert (where == nil);
+ assert (where == nil);
- if (result < 0)
- parent->left = node;
- else
- parent->right = node;
+ if (result < 0)
+ parent->left = node;
+ else
+ parent->right = node;
- node->parent = parent;
- node->left = nil;
- node->right = nil;
+ node->parent = parent;
+ node->left = nil;
+ node->right = nil;
- dict->nodecount++;
+ dict->nodecount++;
- /* red black adjustments */
+ /* red black adjustments */
- node->color = dnode_red;
+ node->color = dnode_red;
- while (parent->color == dnode_red) {
- grandpa = parent->parent;
- if (parent == grandpa->left) {
- uncle = grandpa->right;
- if (uncle->color == dnode_red) { /* red parent, red uncle */
- parent->color = dnode_black;
- uncle->color = dnode_black;
- grandpa->color = dnode_red;
- node = grandpa;
- parent = grandpa->parent;
- } else { /* red parent, black uncle */
- if (node == parent->right) {
- rotate_left(parent);
- parent = node;
- assert (grandpa == parent->parent);
- /* rotation between parent and child preserves grandpa */
- }
- parent->color = dnode_black;
- grandpa->color = dnode_red;
- rotate_right(grandpa);
- break;
+ while (parent->color == dnode_red)
+ {
+ grandpa = parent->parent;
+ if (parent == grandpa->left)
+ {
+ uncle = grandpa->right;
+ if (uncle->color == dnode_red)
+ { /* red parent, red uncle */
+ parent->color = dnode_black;
+ uncle->color = dnode_black;
+ grandpa->color = dnode_red;
+ node = grandpa;
+ parent = grandpa->parent;
}
- } else { /* symmetric cases: parent == parent->parent->right */
- uncle = grandpa->left;
- if (uncle->color == dnode_red) {
- parent->color = dnode_black;
- uncle->color = dnode_black;
- grandpa->color = dnode_red;
- node = grandpa;
- parent = grandpa->parent;
- } else {
- if (node == parent->left) {
- rotate_right(parent);
- parent = node;
- assert (grandpa == parent->parent);
+ else
+ { /* red parent, black uncle */
+ if (node == parent->right)
+ {
+ rotate_left (parent);
+ parent = node;
+ assert (grandpa == parent->parent);
+ /* rotation between parent and child preserves grandpa */
}
- parent->color = dnode_black;
- grandpa->color = dnode_red;
- rotate_left(grandpa);
- break;
+ parent->color = dnode_black;
+ grandpa->color = dnode_red;
+ rotate_right (grandpa);
+ break;
+ }
+ }
+ else
+ { /* symmetric cases: parent == parent->parent->right */
+ uncle = grandpa->left;
+ if (uncle->color == dnode_red)
+ {
+ parent->color = dnode_black;
+ uncle->color = dnode_black;
+ grandpa->color = dnode_red;
+ node = grandpa;
+ parent = grandpa->parent;
+ }
+ else
+ {
+ if (node == parent->left)
+ {
+ rotate_right (parent);
+ parent = node;
+ assert (grandpa == parent->parent);
+ }
+ parent->color = dnode_black;
+ grandpa->color = dnode_red;
+ rotate_left (grandpa);
+ break;
}
}
}
- dict_root(dict)->color = dnode_black;
+ dict_root (dict)->color = dnode_black;
- assert (dict_verify(dict));
+ assert (dict_verify (dict));
}
/*
@@ -636,173 +709,201 @@
* deleted node is returned.
*/
-dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
+dnode_t *
+dict_delete (dict_t * dict, dnode_t * delete)
{
- dnode_t *nil = dict_nil(dict), *child, *delparent = delete->parent;
+ dnode_t *nil = dict_nil (dict), *child, *delparent = delete->parent;
- /* basic deletion */
+ /* basic deletion */
- assert (!dict_isempty(dict));
- assert (dict_contains(dict, delete));
+ assert (!dict_isempty (dict));
+ assert (dict_contains (dict, delete));
- /*
- * If the node being deleted has two children, then we replace it with its
- * successor (i.e. the leftmost node in the right subtree.) By doing this,
- * we avoid the traditional algorithm under which the successor's key and
- * value *only* move to the deleted node and the successor is spliced out
- * from the tree. We cannot use this approach because the user may hold
- * pointers to the successor, or nodes may be inextricably tied to some
- * other structures by way of embedding, etc. So we must splice out the
- * node we are given, not some other node, and must not move contents from
- * one node to another behind the user's back.
- */
+ /*
+ * If the node being deleted has two children, then we replace it with its
+ * successor (i.e. the leftmost node in the right subtree.) By doing this,
+ * we avoid the traditional algorithm under which the successor's key and
+ * value *only* move to the deleted node and the successor is spliced out
+ * from the tree. We cannot use this approach because the user may hold
+ * pointers to the successor, or nodes may be inextricably tied to some
+ * other structures by way of embedding, etc. So we must splice out the
+ * node we are given, not some other node, and must not move contents from
+ * one node to another behind the user's back.
+ */
- if (delete->left != nil && delete->right != nil) {
- dnode_t *next = dict_next(dict, delete);
- dnode_t *nextparent = next->parent;
- dnode_color_t nextcolor = next->color;
+ if (delete->left != nil && delete->right != nil)
+ {
+ dnode_t *next = dict_next (dict, delete);
+ dnode_t *nextparent = next->parent;
+ dnode_color_t nextcolor = next->color;
- assert (next != nil);
- assert (next->parent != nil);
- assert (next->left == nil);
+ assert (next != nil);
+ assert (next->parent != nil);
+ assert (next->left == nil);
- /*
- * First, splice out the successor from the tree completely, by
- * moving up its right child into its place.
- */
+ /*
+ * First, splice out the successor from the tree completely, by
+ * moving up its right child into its place.
+ */
- child = next->right;
- child->parent = nextparent;
+ child = next->right;
+ child->parent = nextparent;
- if (nextparent->left == next) {
- nextparent->left = child;
- } else {
- assert (nextparent->right == next);
- nextparent->right = child;
+ if (nextparent->left == next)
+ {
+ nextparent->left = child;
+ }
+ else
+ {
+ assert (nextparent->right == next);
+ nextparent->right = child;
}
- /*
- * Now that the successor has been extricated from the tree, install it
- * in place of the node that we want deleted.
- */
+ /*
+ * Now that the successor has been extricated from the tree, install it
+ * in place of the node that we want deleted.
+ */
- next->parent = delparent;
- next->left = delete->left;
- next->right = delete->right;
- next->left->parent = next;
- next->right->parent = next;
- next->color = delete->color;
- delete->color = nextcolor;
+ next->parent = delparent;
+ next->left = delete->left;
+ next->right = delete->right;
+ next->left->parent = next;
+ next->right->parent = next;
+ next->color = delete->color;
+ delete->color = nextcolor;
- if (delparent->left == delete) {
- delparent->left = next;
- } else {
- assert (delparent->right == delete);
- delparent->right = next;
+ if (delparent->left == delete)
+ {
+ delparent->left = next;
+ }
+ else
+ {
+ assert (delparent->right == delete);
+ delparent->right = next;
}
- } else {
- assert (delete != nil);
- assert (delete->left == nil || delete->right == nil);
+ }
+ else
+ {
+ assert (delete != nil);
+ assert (delete->left == nil || delete->right == nil);
- child = (delete->left != nil) ? delete->left : delete->right;
+ child = (delete->left != nil) ? delete->left : delete->right;
- child->parent = delparent = delete->parent;
+ child->parent = delparent = delete->parent;
- if (delete == delparent->left) {
- delparent->left = child;
- } else {
- assert (delete == delparent->right);
- delparent->right = child;
+ if (delete == delparent->left)
+ {
+ delparent->left = child;
+ }
+ else
+ {
+ assert (delete == delparent->right);
+ delparent->right = child;
}
}
- delete->parent = NULL;
- delete->right = NULL;
- delete->left = NULL;
+ delete->parent = NULL;
+ delete->right = NULL;
+ delete->left = NULL;
- dict->nodecount--;
+ dict->nodecount--;
- assert (verify_bintree(dict));
+ assert (verify_bintree (dict));
- /* red-black adjustments */
+ /* red-black adjustments */
- if (delete->color == dnode_black) {
- dnode_t *parent, *sister;
+ if (delete->color == dnode_black)
+ {
+ dnode_t *parent, *sister;
- dict_root(dict)->color = dnode_red;
+ dict_root (dict)->color = dnode_red;
- while (child->color == dnode_black) {
- parent = child->parent;
- if (child == parent->left) {
- sister = parent->right;
- assert (sister != nil);
- if (sister->color == dnode_red) {
- sister->color = dnode_black;
- parent->color = dnode_red;
- rotate_left(parent);
- sister = parent->right;
- assert (sister != nil);
+ while (child->color == dnode_black)
+ {
+ parent = child->parent;
+ if (child == parent->left)
+ {
+ sister = parent->right;
+ assert (sister != nil);
+ if (sister->color == dnode_red)
+ {
+ sister->color = dnode_black;
+ parent->color = dnode_red;
+ rotate_left (parent);
+ sister = parent->right;
+ assert (sister != nil);
}
- if (sister->left->color == dnode_black
- && sister->right->color == dnode_black) {
- sister->color = dnode_red;
- child = parent;
- } else {
- if (sister->right->color == dnode_black) {
- assert (sister->left->color == dnode_red);
- sister->left->color = dnode_black;
- sister->color = dnode_red;
- rotate_right(sister);
- sister = parent->right;
- assert (sister != nil);
+ if (sister->left->color == dnode_black
+ && sister->right->color == dnode_black)
+ {
+ sister->color = dnode_red;
+ child = parent;
+ }
+ else
+ {
+ if (sister->right->color == dnode_black)
+ {
+ assert (sister->left->color == dnode_red);
+ sister->left->color = dnode_black;
+ sister->color = dnode_red;
+ rotate_right (sister);
+ sister = parent->right;
+ assert (sister != nil);
}
- sister->color = parent->color;
- sister->right->color = dnode_black;
- parent->color = dnode_black;
- rotate_left(parent);
- break;
+ sister->color = parent->color;
+ sister->right->color = dnode_black;
+ parent->color = dnode_black;
+ rotate_left (parent);
+ break;
}
- } else { /* symmetric case: child == child->parent->right */
- assert (child == parent->right);
- sister = parent->left;
- assert (sister != nil);
- if (sister->color == dnode_red) {
- sister->color = dnode_black;
- parent->color = dnode_red;
- rotate_right(parent);
- sister = parent->left;
- assert (sister != nil);
+ }
+ else
+ { /* symmetric case: child == child->parent->right */
+ assert (child == parent->right);
+ sister = parent->left;
+ assert (sister != nil);
+ if (sister->color == dnode_red)
+ {
+ sister->color = dnode_black;
+ parent->color = dnode_red;
+ rotate_right (parent);
+ sister = parent->left;
+ assert (sister != nil);
}
- if (sister->right->color == dnode_black
- && sister->left->color == dnode_black) {
- sister->color = dnode_red;
- child = parent;
- } else {
- if (sister->left->color == dnode_black) {
- assert (sister->right->color == dnode_red);
- sister->right->color = dnode_black;
- sister->color = dnode_red;
- rotate_left(sister);
- sister = parent->left;
- assert (sister != nil);
+ if (sister->right->color == dnode_black
+ && sister->left->color == dnode_black)
+ {
+ sister->color = dnode_red;
+ child = parent;
+ }
+ else
+ {
+ if (sister->left->color == dnode_black)
+ {
+ assert (sister->right->color == dnode_red);
+ sister->right->color = dnode_black;
+ sister->color = dnode_red;
+ rotate_left (sister);
+ sister = parent->left;
+ assert (sister != nil);
}
- sister->color = parent->color;
- sister->left->color = dnode_black;
- parent->color = dnode_black;
- rotate_right(parent);
- break;
+ sister->color = parent->color;
+ sister->left->color = dnode_black;
+ parent->color = dnode_black;
+ rotate_right (parent);
+ break;
}
}
}
- child->color = dnode_black;
- dict_root(dict)->color = dnode_black;
+ child->color = dnode_black;
+ dict_root (dict)->color = dnode_black;
}
- assert (dict_verify(dict));
+ assert (dict_verify (dict));
- return delete;
+ return delete;
}
/*
@@ -810,22 +911,25 @@
* the data item.
*/
-int dict_alloc_insert(dict_t *dict, const void *key, void *data)
+int
+dict_alloc_insert (dict_t * dict, const void *key, void *data)
{
- dnode_t *node = dict->allocnode(dict->context);
+ dnode_t *node = dict->allocnode (dict->context);
- if (node) {
- dnode_init(node, data);
- dict_insert(dict, node, key);
- return 1;
+ if (node)
+ {
+ dnode_init (node, data);
+ dict_insert (dict, node, key);
+ return 1;
}
- return 0;
+ return 0;
}
-void dict_delete_free(dict_t *dict, dnode_t *node)
+void
+dict_delete_free (dict_t * dict, dnode_t * node)
{
- dict_delete(dict, node);
- dict->freenode(node, dict->context);
+ dict_delete (dict, node);
+ dict->freenode (node, dict->context);
}
/*
@@ -833,15 +937,16 @@
* (that is, dict_isempty(dict) returns 1) a null pointer is returned.
*/
-dnode_t *dict_first(dict_t *dict)
+dnode_t *
+dict_first (dict_t * dict)
{
- dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left;
+ dnode_t *nil = dict_nil (dict), *root = dict_root (dict), *left;
- if (root != nil)
- while ((left = root->left) != nil)
- root = left;
+ if (root != nil)
+ while ((left = root->left) != nil)
+ root = left;
- return (root == nil) ? NULL : root;
+ return (root == nil) ? NULL : root;
}
/*
@@ -849,15 +954,16 @@
* (that is, dict_isempty(dict) returns 1) a null pointer is returned.
*/
-dnode_t *dict_last(dict_t *dict)
+dnode_t *
+dict_last (dict_t * dict)
{
- dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right;
+ dnode_t *nil = dict_nil (dict), *root = dict_root (dict), *right;
- if (root != nil)
- while ((right = root->right) != nil)
- root = right;
+ if (root != nil)
+ while ((right = root->right) != nil)
+ root = right;
- return (root == nil) ? NULL : root;
+ return (root == nil) ? NULL : root;
}
/*
@@ -867,25 +973,28 @@
* the nil node.
*/
-dnode_t *dict_next(dict_t *dict, dnode_t *curr)
+dnode_t *
+dict_next (dict_t * dict, dnode_t * curr)
{
- dnode_t *nil = dict_nil(dict), *parent, *left;
+ dnode_t *nil = dict_nil (dict), *parent, *left;
- if (curr->right != nil) {
- curr = curr->right;
- while ((left = curr->left) != nil)
- curr = left;
- return curr;
+ if (curr->right != nil)
+ {
+ curr = curr->right;
+ while ((left = curr->left) != nil)
+ curr = left;
+ return curr;
}
- parent = curr->parent;
+ parent = curr->parent;
- while (parent != nil && curr == parent->right) {
- curr = parent;
- parent = curr->parent;
+ while (parent != nil && curr == parent->right)
+ {
+ curr = parent;
+ parent = curr->parent;
}
- return (parent == nil) ? NULL : parent;
+ return (parent == nil) ? NULL : parent;
}
/*
@@ -893,30 +1002,34 @@
* The nil sentinel node is returned if there is no predecessor.
*/
-dnode_t *dict_prev(dict_t *dict, dnode_t *curr)
+dnode_t *
+dict_prev (dict_t * dict, dnode_t * curr)
{
- dnode_t *nil = dict_nil(dict), *parent, *right;
+ dnode_t *nil = dict_nil (dict), *parent, *right;
- if (curr->left != nil) {
- curr = curr->left;
- while ((right = curr->right) != nil)
- curr = right;
- return curr;
+ if (curr->left != nil)
+ {
+ curr = curr->left;
+ while ((right = curr->right) != nil)
+ curr = right;
+ return curr;
}
- parent = curr->parent;
+ parent = curr->parent;
- while (parent != nil && curr == parent->left) {
- curr = parent;
- parent = curr->parent;
+ while (parent != nil && curr == parent->left)
+ {
+ curr = parent;
+ parent = curr->parent;
}
- return (parent == nil) ? NULL : parent;
+ return (parent == nil) ? NULL : parent;
}
-void dict_allow_dupes(dict_t *dict)
+void
+dict_allow_dupes (dict_t * dict)
{
- dict->dupes = 1;
+ dict->dupes = 1;
}
#undef dict_count
@@ -926,268 +1039,308 @@
#undef dnode_put
#undef dnode_getkey
-dictcount_t dict_count(dict_t *dict)
+dictcount_t
+dict_count (dict_t * dict)
{
- return dict->nodecount;
+ return dict->nodecount;
}
-int dict_isempty(dict_t *dict)
+int
+dict_isempty (dict_t * dict)
{
- return dict->nodecount == 0;
+ return dict->nodecount == 0;
}
-int dict_isfull(dict_t *dict)
+int
+dict_isfull (dict_t * dict)
{
- return dict->nodecount == dict->maxcount;
+ return dict->nodecount == dict->maxcount;
}
-int dict_contains(dict_t *dict, dnode_t *node)
+int
+dict_contains (dict_t * dict, dnode_t * node)
{
- return verify_dict_has_node(dict_nil(dict), dict_root(dict), node);
+ return verify_dict_has_node (dict_nil (dict), dict_root (dict), node);
}
-static dnode_t *dnode_alloc(void *context)
+static dnode_t *
+dnode_alloc (void *context)
{
- return malloc(sizeof *dnode_alloc(NULL));
+ return malloc (sizeof *dnode_alloc (NULL));
}
-static void dnode_free(dnode_t *node, void *context)
+static void
+dnode_free (dnode_t * node, void *context)
{
- free(node);
+ free (node);
}
-dnode_t *dnode_create(void *data)
+dnode_t *
+dnode_create (void *data)
{
- dnode_t *new = malloc(sizeof *new);
- if (new) {
- new->data = data;
- new->parent = NULL;
- new->left = NULL;
- new->right = NULL;
+ dnode_t *new = malloc (sizeof *new);
+ if (new)
+ {
+ new->data = data;
+ new->parent = NULL;
+ new->left = NULL;
+ new->right = NULL;
}
- return new;
+ return new;
}
-dnode_t *dnode_init(dnode_t *dnode, void *data)
+dnode_t *
+dnode_init (dnode_t * dnode, void *data)
{
- dnode->data = data;
- dnode->parent = NULL;
- dnode->left = NULL;
- dnode->right = NULL;
- return dnode;
+ dnode->data = data;
+ dnode->parent = NULL;
+ dnode->left = NULL;
+ dnode->right = NULL;
+ return dnode;
}
-void dnode_destroy(dnode_t *dnode)
+void
+dnode_destroy (dnode_t * dnode)
{
- assert (!dnode_is_in_a_dict(dnode));
- free(dnode);
+ assert (!dnode_is_in_a_dict (dnode));
+ free (dnode);
}
-void *dnode_get(dnode_t *dnode)
+void *
+dnode_get (dnode_t * dnode)
{
- return dnode->data;
+ return dnode->data;
}
-const void *dnode_getkey(dnode_t *dnode)
+const void *
+dnode_getkey (dnode_t * dnode)
{
- return dnode->key;
+ return dnode->key;
}
-void dnode_put(dnode_t *dnode, void *data)
+void
+dnode_put (dnode_t * dnode, void *data)
{
- dnode->data = data;
+ dnode->data = data;
}
-int dnode_is_in_a_dict(dnode_t *dnode)
+int
+dnode_is_in_a_dict (dnode_t * dnode)
{
- return (dnode->parent && dnode->left && dnode->right);
+ return (dnode->parent && dnode->left && dnode->right);
}
-void dict_process(dict_t *dict, void *context, dnode_process_t function)
+void
+dict_process (dict_t * dict, void *context, dnode_process_t function)
{
- dnode_t *node = dict_first(dict), *next;
+ dnode_t *node = dict_first (dict), *next;
- while (node != NULL) {
- /* check for callback function deleting */
- /* the next node from under us */
- assert (dict_contains(dict, node));
- next = dict_next(dict, node);
- function(dict, node, context);
- node = next;
+ while (node != NULL)
+ {
+ /* check for callback function deleting */
+ /* the next node from under us */
+ assert (dict_contains (dict, node));
+ next = dict_next (dict, node);
+ function (dict, node, context);
+ node = next;
}
}
-static void load_begin_internal(dict_load_t *load, dict_t *dict)
+static void
+load_begin_internal (dict_load_t * load, dict_t * dict)
{
- load->dictptr = dict;
- load->nilnode.left = &load->nilnode;
- load->nilnode.right = &load->nilnode;
+ load->dictptr = dict;
+ load->nilnode.left = &load->nilnode;
+ load->nilnode.right = &load->nilnode;
}
-void dict_load_begin(dict_load_t *load, dict_t *dict)
+void
+dict_load_begin (dict_load_t * load, dict_t * dict)
{
- assert (dict_isempty(dict));
- load_begin_internal(load, dict);
+ assert (dict_isempty (dict));
+ load_begin_internal (load, dict);
}
-void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key)
+void
+dict_load_next (dict_load_t * load, dnode_t * newnode, const void *key)
{
- dict_t *dict = load->dictptr;
- dnode_t *nil = &load->nilnode;
-
- assert (!dnode_is_in_a_dict(newnode));
- assert (dict->nodecount < dict->maxcount);
+ dict_t *dict = load->dictptr;
+ dnode_t *nil = &load->nilnode;
- #ifndef NDEBUG
- if (dict->nodecount > 0) {
- if (dict->dupes)
- assert (dict->compare(nil->left->key, key) <= 0);
- else
- assert (dict->compare(nil->left->key, key) < 0);
+ assert (!dnode_is_in_a_dict (newnode));
+ assert (dict->nodecount < dict->maxcount);
+
+#ifndef NDEBUG
+ if (dict->nodecount > 0)
+ {
+ if (dict->dupes)
+ assert (dict->compare (nil->left->key, key) <= 0);
+ else
+ assert (dict->compare (nil->left->key, key) < 0);
}
- #endif
+#endif
- newnode->key = key;
- nil->right->left = newnode;
- nil->right = newnode;
- newnode->left = nil;
- dict->nodecount++;
+ newnode->key = key;
+ nil->right->left = newnode;
+ nil->right = newnode;
+ newnode->left = nil;
+ dict->nodecount++;
}
-void dict_load_end(dict_load_t *load)
+void
+dict_load_end (dict_load_t * load)
{
- dict_t *dict = load->dictptr;
- dnode_t *tree[DICT_DEPTH_MAX] = { 0 };
- dnode_t *curr, *dictnil = dict_nil(dict), *loadnil = &load->nilnode, *next;
- dnode_t *complete = 0;
- dictcount_t fullcount = DICTCOUNT_T_MAX, nodecount = dict->nodecount;
- dictcount_t botrowcount;
- unsigned baselevel = 0, level = 0, i;
+ dict_t *dict = load->dictptr;
+ dnode_t *tree[DICT_DEPTH_MAX] = { 0 };
+ dnode_t *curr, *dictnil = dict_nil (dict), *loadnil = &load->nilnode, *next;
+ dnode_t *complete = 0;
+ dictcount_t fullcount = DICTCOUNT_T_MAX, nodecount = dict->nodecount;
+ dictcount_t botrowcount;
+ unsigned baselevel = 0, level = 0, i;
- assert (dnode_red == 0 && dnode_black == 1);
+ assert (dnode_red == 0 && dnode_black == 1);
- while (fullcount >= nodecount && fullcount)
- fullcount >>= 1;
+ while (fullcount >= nodecount && fullcount)
+ fullcount >>= 1;
- botrowcount = nodecount - fullcount;
+ botrowcount = nodecount - fullcount;
- for (curr = loadnil->left; curr != loadnil; curr = next) {
- next = curr->left;
+ for (curr = loadnil->left; curr != loadnil; curr = next)
+ {
+ next = curr->left;
- if (complete == NULL && botrowcount-- == 0) {
- assert (baselevel == 0);
- assert (level == 0);
- baselevel = level = 1;
- complete = tree[0];
+ if (complete == NULL && botrowcount-- == 0)
+ {
+ assert (baselevel == 0);
+ assert (level == 0);
+ baselevel = level = 1;
+ complete = tree[0];
- if (complete != 0) {
- tree[0] = 0;
- complete->right = dictnil;
- while (tree[level] != 0) {
- tree[level]->right = complete;
- complete->parent = tree[level];
- complete = tree[level];
- tree[level++] = 0;
+ if (complete != 0)
+ {
+ tree[0] = 0;
+ complete->right = dictnil;
+ while (tree[level] != 0)
+ {
+ tree[level]->right = complete;
+ complete->parent = tree[level];
+ complete = tree[level];
+ tree[level++] = 0;
}
}
}
- if (complete == NULL) {
- curr->left = dictnil;
- curr->right = dictnil;
- curr->color = level % 2;
- complete = curr;
+ if (complete == NULL)
+ {
+ curr->left = dictnil;
+ curr->right = dictnil;
+ curr->color = level % 2;
+ complete = curr;
- assert (level == baselevel);
- while (tree[level] != 0) {
- tree[level]->right = complete;
- complete->parent = tree[level];
- complete = tree[level];
- tree[level++] = 0;
+ assert (level == baselevel);
+ while (tree[level] != 0)
+ {
+ tree[level]->right = complete;
+ complete->parent = tree[level];
+ complete = tree[level];
+ tree[level++] = 0;
}
- } else {
- curr->left = complete;
- curr->color = (level + 1) % 2;
- complete->parent = curr;
- tree[level] = curr;
- complete = 0;
- level = baselevel;
+ }
+ else
+ {
+ curr->left = complete;
+ curr->color = (level + 1) % 2;
+ complete->parent = curr;
+ tree[level] = curr;
+ complete = 0;
+ level = baselevel;
}
}
- if (complete == NULL)
- complete = dictnil;
+ if (complete == NULL)
+ complete = dictnil;
- for (i = 0; i < DICT_DEPTH_MAX; i++) {
- if (tree[i] != 0) {
- tree[i]->right = complete;
- complete->parent = tree[i];
- complete = tree[i];
+ for (i = 0; i < DICT_DEPTH_MAX; i++)
+ {
+ if (tree[i] != 0)
+ {
+ tree[i]->right = complete;
+ complete->parent = tree[i];
+ complete = tree[i];
}
}
- dictnil->color = dnode_black;
- dictnil->right = dictnil;
- complete->parent = dictnil;
- complete->color = dnode_black;
- dict_root(dict) = complete;
+ dictnil->color = dnode_black;
+ dictnil->right = dictnil;
+ complete->parent = dictnil;
+ complete->color = dnode_black;
+ dict_root (dict) = complete;
- assert (dict_verify(dict));
+ assert (dict_verify (dict));
}
-void dict_merge(dict_t *dest, dict_t *source)
+void
+dict_merge (dict_t * dest, dict_t * source)
{
- dict_load_t load;
- dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);
+ dict_load_t load;
+ dnode_t *leftnode = dict_first (dest), *rightnode = dict_first (source);
- assert (dict_similar(dest, source));
+ assert (dict_similar (dest, source));
- if (source == dest)
- return;
+ if (source == dest)
+ return;
- dest->nodecount = 0;
- load_begin_internal(&load, dest);
+ dest->nodecount = 0;
+ load_begin_internal (&load, dest);
- for (;;) {
- if (leftnode != NULL && rightnode != NULL) {
- if (dest->compare(leftnode->key, rightnode->key) < 0)
- goto copyleft;
- else
- goto copyright;
- } else if (leftnode != NULL) {
+ for (;;)
+ {
+ if (leftnode != NULL && rightnode != NULL)
+ {
+ if (dest->compare (leftnode->key, rightnode->key) < 0)
goto copyleft;
- } else if (rightnode != NULL) {
+ else
goto copyright;
- } else {
- assert (leftnode == NULL && rightnode == NULL);
- break;
+ }
+ else if (leftnode != NULL)
+ {
+ goto copyleft;
+ }
+ else if (rightnode != NULL)
+ {
+ goto copyright;
+ }
+ else
+ {
+ assert (leftnode == NULL && rightnode == NULL);
+ break;
}
copyleft:
- {
- dnode_t *next = dict_next(dest, leftnode);
- #ifndef NDEBUG
- leftnode->left = NULL; /* suppress assertion in dict_load_next */
- #endif
- dict_load_next(&load, leftnode, leftnode->key);
- leftnode = next;
- continue;
- }
-
+ {
+ dnode_t *next = dict_next (dest, leftnode);
+#ifndef NDEBUG
+ leftnode->left = NULL; /* suppress assertion in dict_load_next */
+#endif
+ dict_load_next (&load, leftnode, leftnode->key);
+ leftnode = next;
+ continue;
+ }
+
copyright:
- {
- dnode_t *next = dict_next(source, rightnode);
- #ifndef NDEBUG
- rightnode->left = NULL;
- #endif
- dict_load_next(&load, rightnode, rightnode->key);
- rightnode = next;
- continue;
- }
+ {
+ dnode_t *next = dict_next (source, rightnode);
+#ifndef NDEBUG
+ rightnode->left = NULL;
+#endif
+ dict_load_next (&load, rightnode, rightnode->key);
+ rightnode = next;
+ continue;
+ }
}
- dict_clear(source);
- dict_load_end(&load);
+ dict_clear (source);
+ dict_load_end (&load);
}
#ifdef KAZLIB_TEST_MAIN
@@ -1199,298 +1352,329 @@
typedef char input_t[256];
-static int tokenize(char *string, ...)
+static int
+tokenize (char *string, ...)
{
- char **tokptr;
- va_list arglist;
- int tokcount = 0;
+ char **tokptr;
+ va_list arglist;
+ int tokcount = 0;
- va_start(arglist, string);
- tokptr = va_arg(arglist, char **);
- while (tokptr) {
- while (*string && isspace((unsigned char) *string))
- string++;
- if (!*string)
- break;
- *tokptr = string;
- while (*string && !isspace((unsigned char) *string))
- string++;
- tokptr = va_arg(arglist, char **);
- tokcount++;
- if (!*string)
- break;
- *string++ = 0;
+ va_start (arglist, string);
+ tokptr = va_arg (arglist, char **);
+ while (tokptr)
+ {
+ while (*string && isspace ((unsigned char) *string))
+ string++;
+ if (!*string)
+ break;
+ *tokptr = string;
+ while (*string && !isspace ((unsigned char) *string))
+ string++;
+ tokptr = va_arg (arglist, char **);
+ tokcount++;
+ if (!*string)
+ break;
+ *string++ = 0;
}
- va_end(arglist);
+ va_end (arglist);
- return tokcount;
+ return tokcount;
}
-static int comparef(const void *key1, const void *key2)
+static int
+comparef (const void *key1, const void *key2)
{
- return strcmp(key1, key2);
+ return strcmp (key1, key2);
}
-static char *dupstring(char *str)
+static char *
+dupstring (char *str)
{
- int sz = strlen(str) + 1;
- char *new = malloc(sz);
- if (new)
- memcpy(new, str, sz);
- return new;
+ int sz = strlen (str) + 1;
+ char *new = malloc (sz);
+ if (new)
+ memcpy (new, str, sz);
+ return new;
}
-static dnode_t *new_node(void *c)
+static dnode_t *
+new_node (void *c)
{
- static dnode_t few[5];
- static int count;
+ static dnode_t few[5];
+ static int count;
- if (count < 5)
- return few + count++;
+ if (count < 5)
+ return few + count++;
- return NULL;
+ return NULL;
}
-static void del_node(dnode_t *n, void *c)
+static void
+del_node (dnode_t * n, void *c)
{
}
static int prompt = 0;
-static void construct(dict_t *d)
+static void
+construct (dict_t * d)
{
- input_t in;
- int done = 0;
- dict_load_t dl;
- dnode_t *dn;
- char *tok1, *tok2, *val;
- const char *key;
- char *help =
- "p turn prompt on\n"
- "q finish construction\n"
- "a <key> <val> add new entry\n";
+ input_t in;
+ int done = 0;
+ dict_load_t dl;
+ dnode_t *dn;
+ char *tok1, *tok2, *val;
+ const char *key;
+ char *help =
+ "p turn prompt on\n"
+ "q finish construction\n"
+ "a <key> <val> add new entry\n";
- if (!dict_isempty(d))
- puts("warning: dictionary not empty!");
+ if (!dict_isempty (d))
+ puts ("warning: dictionary not empty!");
- dict_load_begin(&dl, d);
+ dict_load_begin (&dl, d);
- while (!done) {
- if (prompt)
- putchar('>');
- fflush(stdout);
+ while (!done)
+ {
+ if (prompt)
+ putchar ('>');
+ fflush (stdout);
- if (!fgets(in, sizeof(input_t), stdin))
- break;
+ if (!fgets (in, sizeof (input_t), stdin))
+ break;
- switch (in[0]) {
- case '?':
- puts(help);
- break;
- case 'p':
- prompt = 1;
- break;
- case 'q':
- done = 1;
- break;
- case 'a':
- if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
- puts("what?");
- break;
- }
- key = dupstring(tok1);
- val = dupstring(tok2);
- dn = dnode_create(val);
+ switch (in[0])
+ {
+ case '?':
+ puts (help);
+ break;
+ case 'p':
+ prompt = 1;
+ break;
+ case 'q':
+ done = 1;
+ break;
+ case 'a':
+ if (tokenize (in + 1, &tok1, &tok2, (char **) 0) != 2)
+ {
+ puts ("what?");
+ break;
+ }
+ key = dupstring (tok1);
+ val = dupstring (tok2);
+ dn = dnode_create (val);
- if (!key || !val || !dn) {
- puts("out of memory");
- free((void *) key);
- free(val);
- if (dn)
- dnode_destroy(dn);
- }
+ if (!key || !val || !dn)
+ {
+ puts ("out of memory");
+ free ((void *) key);
+ free (val);
+ if (dn)
+ dnode_destroy (dn);
+ }
- dict_load_next(&dl, dn, key);
- break;
- default:
- putchar('?');
- putchar('\n');
- break;
+ dict_load_next (&dl, dn, key);
+ break;
+ default:
+ putchar ('?');
+ putchar ('\n');
+ break;
}
}
- dict_load_end(&dl);
+ dict_load_end (&dl);
}
-int main(void)
+int
+main (void)
{
- input_t in;
- dict_t darray[10];
- dict_t *d = &darray[0];
- dnode_t *dn;
- int i;
- char *tok1, *tok2, *val;
- const char *key;
+ input_t in;
+ dict_t darray[10];
+ dict_t *d = &darray[0];
+ dnode_t *dn;
+ int i;
+ char *tok1, *tok2, *val;
+ const char *key;
- char *help =
- "a <key> <val> add value to dictionary\n"
- "d <key> delete value from dictionary\n"
- "l <key> lookup value in dictionary\n"
- "( <key> lookup lower bound\n"
- ") <key> lookup upper bound\n"
- "# <num> switch to alternate dictionary (0-9)\n"
- "j <num> <num> merge two dictionaries\n"
- "f free the whole dictionary\n"
- "k allow duplicate keys\n"
- "c show number of entries\n"
- "t dump whole dictionary in sort order\n"
- "m make dictionary out of sorted items\n"
- "p turn prompt on\n"
- "s switch to non-functioning allocator\n"
- "q quit";
+ char *help =
+ "a <key> <val> add value to dictionary\n"
+ "d <key> delete value from dictionary\n"
+ "l <key> lookup value in dictionary\n"
+ "( <key> lookup lower bound\n"
+ ") <key> lookup upper bound\n"
+ "# <num> switch to alternate dictionary (0-9)\n"
+ "j <num> <num> merge two dictionaries\n"
+ "f free the whole dictionary\n"
+ "k allow duplicate keys\n"
+ "c show number of entries\n"
+ "t dump whole dictionary in sort order\n"
+ "m make dictionary out of sorted items\n"
+ "p turn prompt on\n"
+ "s switch to non-functioning allocator\n"
+ "q quit";
- for (i = 0; i < sizeof darray / sizeof *darray; i++)
- dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
+ for (i = 0; i < sizeof darray / sizeof *darray; i++)
+ dict_init (&darray[i], DICTCOUNT_T_MAX, comparef);
- for (;;) {
- if (prompt)
- putchar('>');
- fflush(stdout);
+ for (;;)
+ {
+ if (prompt)
+ putchar ('>');
+ fflush (stdout);
- if (!fgets(in, sizeof(input_t), stdin))
- break;
+ if (!fgets (in, sizeof (input_t), stdin))
+ break;
- switch(in[0]) {
- case '?':
- puts(help);
- break;
- case 'a':
- if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
- puts("what?");
- break;
- }
- key = dupstring(tok1);
- val = dupstring(tok2);
+ switch (in[0])
+ {
+ case '?':
+ puts (help);
+ break;
+ case 'a':
+ if (tokenize (in + 1, &tok1, &tok2, (char **) 0) != 2)
+ {
+ puts ("what?");
+ break;
+ }
+ key = dupstring (tok1);
+ val = dupstring (tok2);
- if (!key || !val) {
- puts("out of memory");
- free((void *) key);
- free(val);
- }
+ if (!key || !val)
+ {
+ puts ("out of memory");
+ free ((void *) key);
+ free (val);
+ }
- if (!dict_alloc_insert(d, key, val)) {
- puts("dict_alloc_insert failed");
- free((void *) key);
- free(val);
- break;
- }
- break;
- case 'd':
- if (tokenize(in+1, &tok1, (char **) 0) != 1) {
- puts("what?");
- break;
- }
- dn = dict_lookup(d, tok1);
- if (!dn) {
- puts("dict_lookup failed");
- break;
- }
- val = dnode_get(dn);
- key = dnode_getkey(dn);
- dict_delete_free(d, dn);
+ if (!dict_alloc_insert (d, key, val))
+ {
+ puts ("dict_alloc_insert failed");
+ free ((void *) key);
+ free (val);
+ break;
+ }
+ break;
+ case 'd':
+ if (tokenize (in + 1, &tok1, (char **) 0) != 1)
+ {
+ puts ("what?");
+ break;
+ }
+ dn = dict_lookup (d, tok1);
+ if (!dn)
+ {
+ puts ("dict_lookup failed");
+ break;
+ }
+ val = dnode_get (dn);
+ key = dnode_getkey (dn);
+ dict_delete_free (d, dn);
- free(val);
- free((void *) key);
- break;
- case 'f':
- dict_free(d);
- break;
+ free (val);
+ free ((void *) key);
+ break;
+ case 'f':
+ dict_free (d);
+ break;
+ case 'l':
+ case '(':
+ case ')':
+ if (tokenize (in + 1, &tok1, (char **) 0) != 1)
+ {
+ puts ("what?");
+ break;
+ }
+ dn = 0;
+ switch (in[0])
+ {
case 'l':
+ dn = dict_lookup (d, tok1);
+ break;
case '(':
+ dn = dict_lower_bound (d, tok1);
+ break;
case ')':
- if (tokenize(in+1, &tok1, (char **) 0) != 1) {
- puts("what?");
- break;
+ dn = dict_upper_bound (d, tok1);
+ break;
+ }
+ if (!dn)
+ {
+ puts ("lookup failed");
+ break;
+ }
+ val = dnode_get (dn);
+ puts (val);
+ break;
+ case 'm':
+ construct (d);
+ break;
+ case 'k':
+ dict_allow_dupes (d);
+ break;
+ case 'c':
+ printf ("%lu\n", (unsigned long) dict_count (d));
+ break;
+ case 't':
+ for (dn = dict_first (d); dn; dn = dict_next (d, dn))
+ {
+ printf ("%s\t%s\n", (char *) dnode_getkey (dn),
+ (char *) dnode_get (dn));
+ }
+ break;
+ case 'q':
+ exit (0);
+ break;
+ case '\0':
+ break;
+ case 'p':
+ prompt = 1;
+ break;
+ case 's':
+ dict_set_allocator (d, new_node, del_node, NULL);
+ break;
+ case '#':
+ if (tokenize (in + 1, &tok1, (char **) 0) != 1)
+ {
+ puts ("what?");
+ break;
+ }
+ else
+ {
+ int dictnum = atoi (tok1);
+ if (dictnum < 0 || dictnum > 9)
+ {
+ puts ("invalid number");
+ break;
}
- dn = 0;
- switch (in[0]) {
- case 'l':
- dn = dict_lookup(d, tok1);
- break;
- case '(':
- dn = dict_lower_bound(d, tok1);
- break;
- case ')':
- dn = dict_upper_bound(d, tok1);
- break;
+ d = &darray[dictnum];
+ }
+ break;
+ case 'j':
+ if (tokenize (in + 1, &tok1, &tok2, (char **) 0) != 2)
+ {
+ puts ("what?");
+ break;
+ }
+ else
+ {
+ int dict1 = atoi (tok1), dict2 = atoi (tok2);
+ if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9)
+ {
+ puts ("invalid number");
+ break;
}
- if (!dn) {
- puts("lookup failed");
- break;
- }
- val = dnode_get(dn);
- puts(val);
- break;
- case 'm':
- construct(d);
- break;
- case 'k':
- dict_allow_dupes(d);
- break;
- case 'c':
- printf("%lu\n", (unsigned long) dict_count(d));
- break;
- case 't':
- for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
- printf("%s\t%s\n", (char *) dnode_getkey(dn),
- (char *) dnode_get(dn));
- }
- break;
- case 'q':
- exit(0);
- break;
- case '\0':
- break;
- case 'p':
- prompt = 1;
- break;
- case 's':
- dict_set_allocator(d, new_node, del_node, NULL);
- break;
- case '#':
- if (tokenize(in+1, &tok1, (char **) 0) != 1) {
- puts("what?");
- break;
- } else {
- int dictnum = atoi(tok1);
- if (dictnum < 0 || dictnum > 9) {
- puts("invalid number");
- break;
- }
- d = &darray[dictnum];
- }
- break;
- case 'j':
- if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
- puts("what?");
- break;
- } else {
- int dict1 = atoi(tok1), dict2 = atoi(tok2);
- if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
- puts("invalid number");
- break;
- }
- dict_merge(&darray[dict1], &darray[dict2]);
- }
- break;
- default:
- putchar('?');
- putchar('\n');
- break;
+ dict_merge (&darray[dict1], &darray[dict2]);
+ }
+ break;
+ default:
+ putchar ('?');
+ putchar ('\n');
+ break;
}
}
- return 0;
+ return 0;
}
#endif
diff --git a/isisd/dict.h b/isisd/dict.h
index 2977a90..1a5e9d7 100644
--- a/isisd/dict.h
+++ b/isisd/dict.h
@@ -14,7 +14,7 @@
* into proprietary software; there is no requirement for such software to
* contain a copyright notice related to this source.
*
- * $Id: dict.h,v 1.1 2003/12/23 08:09:48 jardin Exp $
+ * $Id: dict.h,v 1.2 2004/09/10 20:48:21 hasso Exp $
* $Name: $
*/
@@ -31,37 +31,41 @@
*/
#ifdef __cplusplus
-extern "C" {
+extern "C"
+{
#endif
-typedef unsigned long dictcount_t;
+ typedef unsigned long dictcount_t;
#define DICTCOUNT_T_MAX ULONG_MAX
/*
* The dictionary is implemented as a red-black tree
*/
-typedef enum { dnode_red, dnode_black } dnode_color_t;
+ typedef enum
+ { dnode_red, dnode_black } dnode_color_t;
-typedef struct dnode_t {
- #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
+ typedef struct dnode_t
+ {
+#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
struct dnode_t *dict_left;
struct dnode_t *dict_right;
struct dnode_t *dict_parent;
dnode_color_t dict_color;
const void *dict_key;
void *dict_data;
- #else
+#else
int dict_dummy;
- #endif
-} dnode_t;
+#endif
+ } dnode_t;
-typedef int (*dict_comp_t)(const void *, const void *);
-typedef dnode_t *(*dnode_alloc_t)(void *);
-typedef void (*dnode_free_t)(dnode_t *, void *);
+ typedef int (*dict_comp_t) (const void *, const void *);
+ typedef dnode_t *(*dnode_alloc_t) (void *);
+ typedef void (*dnode_free_t) (dnode_t *, void *);
-typedef struct dict_t {
- #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
+ typedef struct dict_t
+ {
+#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
dnode_t dict_nilnode;
dictcount_t dict_nodecount;
dictcount_t dict_maxcount;
@@ -70,59 +74,61 @@
dnode_free_t dict_freenode;
void *dict_context;
int dict_dupes;
- #else
+#else
int dict_dummmy;
- #endif
-} dict_t;
+#endif
+ } dict_t;
-typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *);
+ typedef void (*dnode_process_t) (dict_t *, dnode_t *, void *);
-typedef struct dict_load_t {
- #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
+ typedef struct dict_load_t
+ {
+#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
dict_t *dict_dictptr;
dnode_t dict_nilnode;
- #else
+#else
int dict_dummmy;
- #endif
-} dict_load_t;
+#endif
+ } dict_load_t;
-extern dict_t *dict_create(dictcount_t, dict_comp_t);
-extern void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *);
-extern void dict_destroy(dict_t *);
-extern void dict_free_nodes(dict_t *);
-extern void dict_free(dict_t *);
-extern dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t);
-extern void dict_init_like(dict_t *, const dict_t *);
-extern int dict_verify(dict_t *);
-extern int dict_similar(const dict_t *, const dict_t *);
-extern dnode_t *dict_lookup(dict_t *, const void *);
-extern dnode_t *dict_lower_bound(dict_t *, const void *);
-extern dnode_t *dict_upper_bound(dict_t *, const void *);
-extern void dict_insert(dict_t *, dnode_t *, const void *);
-extern dnode_t *dict_delete(dict_t *, dnode_t *);
-extern int dict_alloc_insert(dict_t *, const void *, void *);
-extern void dict_delete_free(dict_t *, dnode_t *);
-extern dnode_t *dict_first(dict_t *);
-extern dnode_t *dict_last(dict_t *);
-extern dnode_t *dict_next(dict_t *, dnode_t *);
-extern dnode_t *dict_prev(dict_t *, dnode_t *);
-extern dictcount_t dict_count(dict_t *);
-extern int dict_isempty(dict_t *);
-extern int dict_isfull(dict_t *);
-extern int dict_contains(dict_t *, dnode_t *);
-extern void dict_allow_dupes(dict_t *);
-extern int dnode_is_in_a_dict(dnode_t *);
-extern dnode_t *dnode_create(void *);
-extern dnode_t *dnode_init(dnode_t *, void *);
-extern void dnode_destroy(dnode_t *);
-extern void *dnode_get(dnode_t *);
-extern const void *dnode_getkey(dnode_t *);
-extern void dnode_put(dnode_t *, void *);
-extern void dict_process(dict_t *, void *, dnode_process_t);
-extern void dict_load_begin(dict_load_t *, dict_t *);
-extern void dict_load_next(dict_load_t *, dnode_t *, const void *);
-extern void dict_load_end(dict_load_t *);
-extern void dict_merge(dict_t *, dict_t *);
+ extern dict_t *dict_create (dictcount_t, dict_comp_t);
+ extern void dict_set_allocator (dict_t *, dnode_alloc_t, dnode_free_t,
+ void *);
+ extern void dict_destroy (dict_t *);
+ extern void dict_free_nodes (dict_t *);
+ extern void dict_free (dict_t *);
+ extern dict_t *dict_init (dict_t *, dictcount_t, dict_comp_t);
+ extern void dict_init_like (dict_t *, const dict_t *);
+ extern int dict_verify (dict_t *);
+ extern int dict_similar (const dict_t *, const dict_t *);
+ extern dnode_t *dict_lookup (dict_t *, const void *);
+ extern dnode_t *dict_lower_bound (dict_t *, const void *);
+ extern dnode_t *dict_upper_bound (dict_t *, const void *);
+ extern void dict_insert (dict_t *, dnode_t *, const void *);
+ extern dnode_t *dict_delete (dict_t *, dnode_t *);
+ extern int dict_alloc_insert (dict_t *, const void *, void *);
+ extern void dict_delete_free (dict_t *, dnode_t *);
+ extern dnode_t *dict_first (dict_t *);
+ extern dnode_t *dict_last (dict_t *);
+ extern dnode_t *dict_next (dict_t *, dnode_t *);
+ extern dnode_t *dict_prev (dict_t *, dnode_t *);
+ extern dictcount_t dict_count (dict_t *);
+ extern int dict_isempty (dict_t *);
+ extern int dict_isfull (dict_t *);
+ extern int dict_contains (dict_t *, dnode_t *);
+ extern void dict_allow_dupes (dict_t *);
+ extern int dnode_is_in_a_dict (dnode_t *);
+ extern dnode_t *dnode_create (void *);
+ extern dnode_t *dnode_init (dnode_t *, void *);
+ extern void dnode_destroy (dnode_t *);
+ extern void *dnode_get (dnode_t *);
+ extern const void *dnode_getkey (dnode_t *);
+ extern void dnode_put (dnode_t *, void *);
+ extern void dict_process (dict_t *, void *, dnode_process_t);
+ extern void dict_load_begin (dict_load_t *, dict_t *);
+ extern void dict_load_next (dict_load_t *, dnode_t *, const void *);
+ extern void dict_load_end (dict_load_t *);
+ extern void dict_merge (dict_t *, dict_t *);
#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
#ifdef KAZLIB_SIDEEFFECT_DEBUG
diff --git a/isisd/isis_adjacency.c b/isisd/isis_adjacency.c
index 86fed1d..3770ebd 100644
--- a/isisd/isis_adjacency.c
+++ b/isisd/isis_adjacency.c
@@ -47,172 +47,180 @@
#include "isisd/isis_dynhn.h"
#include "isisd/isis_pdu.h"
-
extern struct isis *isis;
-
struct isis_adjacency *
-adj_alloc (u_char *id)
+adj_alloc (u_char * id)
{
- struct isis_adjacency *adj;
+ struct isis_adjacency *adj;
- adj = XMALLOC (MTYPE_ISIS_ADJACENCY, sizeof (struct isis_adjacency));
- memset (adj, 0, sizeof (struct isis_adjacency));
- memcpy (adj->sysid, id, ISIS_SYS_ID_LEN);
-
- return adj;
+ adj = XMALLOC (MTYPE_ISIS_ADJACENCY, sizeof (struct isis_adjacency));
+ memset (adj, 0, sizeof (struct isis_adjacency));
+ memcpy (adj->sysid, id, ISIS_SYS_ID_LEN);
+
+ return adj;
}
struct isis_adjacency *
-isis_new_adj (u_char *id, u_char *snpa, int level,
+isis_new_adj (u_char * id, u_char * snpa, int level,
struct isis_circuit *circuit)
{
-
struct isis_adjacency *adj;
- int i;
+ int i;
- adj = adj_alloc (id); /* P2P kludge */
-
- if (adj == NULL){
- zlog_err ("Out of memory!");
- return NULL;
- }
+ adj = adj_alloc (id); /* P2P kludge */
+
+ if (adj == NULL)
+ {
+ zlog_err ("Out of memory!");
+ return NULL;
+ }
memcpy (adj->snpa, snpa, 6);
adj->circuit = circuit;
adj->level = level;
adj->flaps = 0;
adj->last_flap = time (NULL);
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- listnode_add (circuit->u.bc.adjdb[level-1], adj);
- adj->dischanges[level - 1] = 0;
- for (i = 0; i < DIS_RECORDS; i++) /* clear N DIS state change records */
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ listnode_add (circuit->u.bc.adjdb[level - 1], adj);
+ adj->dischanges[level - 1] = 0;
+ for (i = 0; i < DIS_RECORDS; i++) /* clear N DIS state change records */
{
- adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis
+ adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis
= ISIS_UNKNOWN_DIS;
- adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change
- = time (NULL);
+ adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change
+ = time (NULL);
}
- }
+ }
return adj;
}
struct isis_adjacency *
-isis_adj_lookup (u_char *sysid, struct list *adjdb)
+isis_adj_lookup (u_char * sysid, struct list *adjdb)
{
struct isis_adjacency *adj;
struct listnode *node;
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj = getdata (node);
- if (memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN) == 0)
- return adj;
- }
-
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj = getdata (node);
+ if (memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN) == 0)
+ return adj;
+ }
+
return NULL;
}
struct isis_adjacency *
-isis_adj_lookup_snpa (u_char *ssnpa, struct list *adjdb)
+isis_adj_lookup_snpa (u_char * ssnpa, struct list *adjdb)
{
struct listnode *node;
struct isis_adjacency *adj;
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj = getdata (node);
- if (memcmp (adj->snpa, ssnpa, ETH_ALEN) == 0)
- return adj;
- }
-
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj = getdata (node);
+ if (memcmp (adj->snpa, ssnpa, ETH_ALEN) == 0)
+ return adj;
+ }
+
return NULL;
}
/*
* When we recieve a NULL list, we will know its p2p
*/
-void
+void
isis_delete_adj (struct isis_adjacency *adj, struct list *adjdb)
{
struct isis_adjacency *adj2;
struct listnode *node;
-
- if (adjdb) {
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj2 = getdata (node);
- if (adj2 == adj)
- break;
+
+ if (adjdb)
+ {
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj2 = getdata (node);
+ if (adj2 == adj)
+ break;
+ }
+ listnode_delete (adjdb, adj);
}
- listnode_delete (adjdb, adj);
- }
-
+
if (adj->ipv4_addrs)
list_delete (adj->ipv4_addrs);
#ifdef HAVE_IPV6
if (adj->ipv6_addrs)
list_delete (adj->ipv6_addrs);
#endif
- if (adj) {
- XFREE (MTYPE_ISIS_ADJACENCY,adj);
- } else {
- zlog_info ("tried to delete a non-existent adjacency");
- }
-
-
+ if (adj)
+ {
+ XFREE (MTYPE_ISIS_ADJACENCY, adj);
+ }
+ else
+ {
+ zlog_info ("tried to delete a non-existent adjacency");
+ }
return;
}
-void
-isis_adj_state_change (struct isis_adjacency *adj, enum isis_adj_state state,
- char *reason)
-
+void
+isis_adj_state_change (struct isis_adjacency *adj, enum isis_adj_state state,
+ char *reason)
{
int old_state;
int level = adj->level;
struct isis_circuit *circuit;
-
+
old_state = adj->adj_state;
adj->adj_state = state;
circuit = adj->circuit;
-
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- zlog_info ("ISIS-Adj (%s): Adjacency state change %d->%d: %s",
- circuit->area->area_tag,
- old_state,
- state,
- reason ? reason : "unspecified");
- }
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- if (state == ISIS_ADJ_UP)
- circuit->upadjcount[level-1]++;
- if (state == ISIS_ADJ_DOWN) {
- isis_delete_adj (adj, adj->circuit->u.bc.adjdb[level - 1]);
- circuit->upadjcount[level-1]--;
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ zlog_info ("ISIS-Adj (%s): Adjacency state change %d->%d: %s",
+ circuit->area->area_tag,
+ old_state, state, reason ? reason : "unspecified");
}
- list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
- isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
- circuit->u.bc.lan_neighs[level - 1]);
- } else if (state == ISIS_ADJ_UP) { /* p2p interface */
- if (adj->sys_type == ISIS_SYSTYPE_UNKNOWN)
- send_hello (circuit, 1);
-
- /* update counter & timers for debugging purposes */
- adj->last_flap = time(NULL);
- adj->flaps++;
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ if (state == ISIS_ADJ_UP)
+ circuit->upadjcount[level - 1]++;
+ if (state == ISIS_ADJ_DOWN)
+ {
+ isis_delete_adj (adj, adj->circuit->u.bc.adjdb[level - 1]);
+ circuit->upadjcount[level - 1]--;
+ }
- /* 7.3.17 - going up on P2P -> send CSNP */
- /* FIXME: yup, I know its wrong... but i will do it! (for now) */
- send_csnp (circuit,1);
- send_csnp (circuit,2);
- } else if (state == ISIS_ADJ_DOWN) { /* p2p interface */
- adj->circuit->u.p2p.neighbor = NULL;
- isis_delete_adj (adj, NULL);
- }
+ list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
+ isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
+ circuit->u.bc.lan_neighs[level - 1]);
+ }
+ else if (state == ISIS_ADJ_UP)
+ { /* p2p interface */
+ if (adj->sys_type == ISIS_SYSTYPE_UNKNOWN)
+ send_hello (circuit, 1);
+
+ /* update counter & timers for debugging purposes */
+ adj->last_flap = time (NULL);
+ adj->flaps++;
+
+ /* 7.3.17 - going up on P2P -> send CSNP */
+ /* FIXME: yup, I know its wrong... but i will do it! (for now) */
+ send_csnp (circuit, 1);
+ send_csnp (circuit, 2);
+ }
+ else if (state == ISIS_ADJ_DOWN)
+ { /* p2p interface */
+ adj->circuit->u.p2p.neighbor = NULL;
+ isis_delete_adj (adj, NULL);
+ }
return;
}
@@ -223,47 +231,49 @@
struct isis_dynhn *dyn;
struct listnode *node;
struct in_addr *ipv4_addr;
-#ifdef HAVE_IPV6
+#ifdef HAVE_IPV6
struct in6_addr *ipv6_addr;
- u_char ip6 [INET6_ADDRSTRLEN];
+ u_char ip6[INET6_ADDRSTRLEN];
#endif /* HAVE_IPV6 */
-
- if(!adj)
+
+ if (!adj)
return;
dyn = dynhn_find_by_id (adj->sysid);
if (dyn)
zlog_info ("%s", dyn->name.name);
-
- zlog_info ("SystemId %20s SNPA %s, level %d\nHolding Time %d",
- adj->sysid ? sysid_print (adj->sysid) : "unknown" ,
- snpa_print (adj->snpa),
- adj->level, adj->hold_time);
- if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0) {
- zlog_info ("IPv4 Addresses:");
-
- for (node = listhead (adj->ipv4_addrs); node; nextnode (node)) {
- ipv4_addr = getdata (node);
- zlog_info ("%s", inet_ntoa(*ipv4_addr));
- }
- }
-#ifdef HAVE_IPV6
- if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0) {
- zlog_info ("IPv6 Addresses:");
- for (node = listhead (adj->ipv6_addrs); node; nextnode (node)) {
- ipv6_addr = getdata (node);
- inet_ntop (AF_INET6, ipv6_addr, ip6, INET6_ADDRSTRLEN);
- zlog_info ("%s", ip6);
+ zlog_info ("SystemId %20s SNPA %s, level %d\nHolding Time %d",
+ adj->sysid ? sysid_print (adj->sysid) : "unknown",
+ snpa_print (adj->snpa), adj->level, adj->hold_time);
+ if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0)
+ {
+ zlog_info ("IPv4 Addresses:");
+
+ for (node = listhead (adj->ipv4_addrs); node; nextnode (node))
+ {
+ ipv4_addr = getdata (node);
+ zlog_info ("%s", inet_ntoa (*ipv4_addr));
+ }
}
- }
+
+#ifdef HAVE_IPV6
+ if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0)
+ {
+ zlog_info ("IPv6 Addresses:");
+ for (node = listhead (adj->ipv6_addrs); node; nextnode (node))
+ {
+ ipv6_addr = getdata (node);
+ inet_ntop (AF_INET6, ipv6_addr, ip6, INET6_ADDRSTRLEN);
+ zlog_info ("%s", ip6);
+ }
+ }
#endif /* HAVE_IPV6 */
- zlog_info ("Speaks: %s", nlpid2string(&adj->nlpids));
-
+ zlog_info ("Speaks: %s", nlpid2string (&adj->nlpids));
return;
}
-int
+int
isis_adj_expire (struct thread *thread)
{
struct isis_adjacency *adj;
@@ -286,19 +296,20 @@
const char *
adj_state2string (int state)
{
-
- switch (state) {
- case ISIS_ADJ_INITIALIZING:
- return "Initializing";
- case ISIS_ADJ_UP:
- return "Up";
- case ISIS_ADJ_DOWN:
- return "Down";
- default:
- return "Unknown";
- }
-
- return NULL; /* not reached */
+
+ switch (state)
+ {
+ case ISIS_ADJ_INITIALIZING:
+ return "Initializing";
+ case ISIS_ADJ_UP:
+ return "Up";
+ case ISIS_ADJ_DOWN:
+ return "Down";
+ default:
+ return "Unknown";
+ }
+
+ return NULL; /* not reached */
}
/*
@@ -310,7 +321,7 @@
#ifdef HAVE_IPV6
struct in6_addr *ipv6_addr;
- u_char ip6 [INET6_ADDRSTRLEN];
+ u_char ip6[INET6_ADDRSTRLEN];
#endif /* HAVE_IPV6 */
struct in_addr *ip_addr;
time_t now;
@@ -321,111 +332,112 @@
dyn = dynhn_find_by_id (adj->sysid);
if (dyn)
vty_out (vty, " %-20s", dyn->name.name);
- else if (adj->sysid){
- vty_out (vty, " %-20s", sysid_print (adj->sysid));
- } else {
- vty_out (vty, " unknown ");
- }
-
- if (detail == ISIS_UI_LEVEL_BRIEF) {
- if (adj->circuit)
- vty_out (vty, "%-12s",adj->circuit->interface->name);
- else
- vty_out (vty, "NULL circuit!");
- vty_out (vty, "%-3u", adj->level); /* level */
- vty_out (vty, "%-13s", adj_state2string (adj->adj_state));
- now = time (NULL);
- if (adj->last_upd)
- vty_out (vty, "%-9lu", adj->last_upd + adj->hold_time - now);
- else
- vty_out (vty, "- ");
- vty_out (vty, "%-10s", snpa_print (adj->snpa));
- vty_out (vty, "%s", VTY_NEWLINE);
- }
-
- if (detail == ISIS_UI_LEVEL_DETAIL) {
- level = adj->level;
- if (adj->circuit)
- vty_out (vty, "%s Interface: %s",
- VTY_NEWLINE,
- adj->circuit->interface->name); /* interface name */
- else
- vty_out (vty, "NULL circuit!%s", VTY_NEWLINE);
- vty_out (vty, ", Level: %u", adj->level); /* level */
- vty_out (vty, ", State: %s", adj_state2string (adj->adj_state));
- now = time (NULL);
- if (adj->last_upd)
- vty_out (vty, ", Expires in %s",
- time2string (adj->last_upd + adj->hold_time - now));
- else
- vty_out (vty, ", Expires in %s",
- time2string (adj->hold_time));
- vty_out (vty, "%s Adjacency flaps: %u",
- VTY_NEWLINE,
- adj->flaps);
- vty_out (vty, ", Last: %s ago", time2string(now - adj->last_flap));
- vty_out (vty, "%s Circuit type: %s",
- VTY_NEWLINE,
- circuit_t2string(adj->circuit_t));
- vty_out (vty, ", Speaks: %s", nlpid2string(&adj->nlpids));
- vty_out (vty, "%s SNPA: %s",
- VTY_NEWLINE,
- snpa_print (adj->snpa));
- dyn = dynhn_find_by_id (adj->lanid);
- if (dyn)
- vty_out (vty, ", LAN id: %s.%02x",
- dyn->name.name,
- adj->lanid[ISIS_SYS_ID_LEN]);
- else
- vty_out (vty, ", LAN id: %s.%02x",
- sysid_print (adj->lanid),
- adj->lanid[ISIS_SYS_ID_LEN]);
-
- vty_out (vty, "%s Priority: %u",
- VTY_NEWLINE,
- adj->prio[adj->level-1]);
-
- vty_out (vty, ", %s, DIS flaps: %u, Last: %s ago%s",
- isis_disflag2string(adj->dis_record[ISIS_LEVELS+level-1].dis),
- adj->dischanges[level-1],
- time2string (now -
- (adj->dis_record[ISIS_LEVELS + level - 1].last_dis_change)),
- VTY_NEWLINE);
-
- if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0) {
- vty_out (vty, " IPv4 Addresses:%s", VTY_NEWLINE);
- for (node = listhead (adj->ipv4_addrs);node; nextnode (node)) {
- ip_addr = getdata (node);
- vty_out (vty, " %s%s", inet_ntoa(*ip_addr), VTY_NEWLINE);
- }
+ else if (adj->sysid)
+ {
+ vty_out (vty, " %-20s", sysid_print (adj->sysid));
}
-#ifdef HAVE_IPV6
- if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0) {
- vty_out (vty, " IPv6 Addresses:%s", VTY_NEWLINE);
- for (node = listhead (adj->ipv6_addrs); node; nextnode (node)) {
- ipv6_addr = getdata (node);
- inet_ntop (AF_INET6, ipv6_addr, ip6, INET6_ADDRSTRLEN);
- vty_out (vty, " %s%s", ip6, VTY_NEWLINE);
- }
+ else
+ {
+ vty_out (vty, " unknown ");
}
+
+ if (detail == ISIS_UI_LEVEL_BRIEF)
+ {
+ if (adj->circuit)
+ vty_out (vty, "%-12s", adj->circuit->interface->name);
+ else
+ vty_out (vty, "NULL circuit!");
+ vty_out (vty, "%-3u", adj->level); /* level */
+ vty_out (vty, "%-13s", adj_state2string (adj->adj_state));
+ now = time (NULL);
+ if (adj->last_upd)
+ vty_out (vty, "%-9lu", adj->last_upd + adj->hold_time - now);
+ else
+ vty_out (vty, "- ");
+ vty_out (vty, "%-10s", snpa_print (adj->snpa));
+ vty_out (vty, "%s", VTY_NEWLINE);
+ }
+
+ if (detail == ISIS_UI_LEVEL_DETAIL)
+ {
+ level = adj->level;
+ if (adj->circuit)
+ vty_out (vty, "%s Interface: %s", VTY_NEWLINE, adj->circuit->interface->name); /* interface name */
+ else
+ vty_out (vty, "NULL circuit!%s", VTY_NEWLINE);
+ vty_out (vty, ", Level: %u", adj->level); /* level */
+ vty_out (vty, ", State: %s", adj_state2string (adj->adj_state));
+ now = time (NULL);
+ if (adj->last_upd)
+ vty_out (vty, ", Expires in %s",
+ time2string (adj->last_upd + adj->hold_time - now));
+ else
+ vty_out (vty, ", Expires in %s", time2string (adj->hold_time));
+ vty_out (vty, "%s Adjacency flaps: %u", VTY_NEWLINE, adj->flaps);
+ vty_out (vty, ", Last: %s ago", time2string (now - adj->last_flap));
+ vty_out (vty, "%s Circuit type: %s",
+ VTY_NEWLINE, circuit_t2string (adj->circuit_t));
+ vty_out (vty, ", Speaks: %s", nlpid2string (&adj->nlpids));
+ vty_out (vty, "%s SNPA: %s", VTY_NEWLINE, snpa_print (adj->snpa));
+ dyn = dynhn_find_by_id (adj->lanid);
+ if (dyn)
+ vty_out (vty, ", LAN id: %s.%02x",
+ dyn->name.name, adj->lanid[ISIS_SYS_ID_LEN]);
+ else
+ vty_out (vty, ", LAN id: %s.%02x",
+ sysid_print (adj->lanid), adj->lanid[ISIS_SYS_ID_LEN]);
+
+ vty_out (vty, "%s Priority: %u",
+ VTY_NEWLINE, adj->prio[adj->level - 1]);
+
+ vty_out (vty, ", %s, DIS flaps: %u, Last: %s ago%s",
+ isis_disflag2string (adj->dis_record[ISIS_LEVELS + level - 1].
+ dis), adj->dischanges[level - 1],
+ time2string (now -
+ (adj->dis_record[ISIS_LEVELS + level - 1].
+ last_dis_change)), VTY_NEWLINE);
+
+ if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0)
+ {
+ vty_out (vty, " IPv4 Addresses:%s", VTY_NEWLINE);
+ for (node = listhead (adj->ipv4_addrs); node; nextnode (node))
+ {
+ ip_addr = getdata (node);
+ vty_out (vty, " %s%s", inet_ntoa (*ip_addr), VTY_NEWLINE);
+ }
+ }
+#ifdef HAVE_IPV6
+ if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0)
+ {
+ vty_out (vty, " IPv6 Addresses:%s", VTY_NEWLINE);
+ for (node = listhead (adj->ipv6_addrs); node; nextnode (node))
+ {
+ ipv6_addr = getdata (node);
+ inet_ntop (AF_INET6, ipv6_addr, ip6, INET6_ADDRSTRLEN);
+ vty_out (vty, " %s%s", ip6, VTY_NEWLINE);
+ }
+ }
#endif /* HAVE_IPV6 */
- vty_out (vty, "%s", VTY_NEWLINE);
- }
+ vty_out (vty, "%s", VTY_NEWLINE);
+ }
return;
}
void
-isis_adj_print_vty (struct isis_adjacency *adj, struct vty *vty) {
+isis_adj_print_vty (struct isis_adjacency *adj, struct vty *vty)
+{
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_BRIEF);
}
void
-isis_adj_print_vty_detail (struct isis_adjacency *adj, struct vty *vty) {
+isis_adj_print_vty_detail (struct isis_adjacency *adj, struct vty *vty)
+{
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_DETAIL);
}
void
-isis_adj_print_vty_extensive (struct isis_adjacency *adj, struct vty *vty) {
+isis_adj_print_vty_extensive (struct isis_adjacency *adj, struct vty *vty)
+{
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_EXTENSIVE);
}
@@ -435,54 +447,56 @@
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_BRIEF);
}
-void
-isis_adj_p2p_print_vty_detail (struct isis_adjacency *adj, struct vty *vty)
+void
+isis_adj_p2p_print_vty_detail (struct isis_adjacency *adj, struct vty *vty)
{
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_DETAIL);
}
-void
+void
isis_adj_p2p_print_vty_extensive (struct isis_adjacency *adj, struct vty *vty)
{
isis_adj_print_vty2 (adj, vty, ISIS_UI_LEVEL_EXTENSIVE);
}
void
-isis_adjdb_iterate (struct list *adjdb, void (*func)(struct isis_adjacency*,
- void *), void *arg)
+isis_adjdb_iterate (struct list *adjdb, void (*func) (struct isis_adjacency *,
+ void *), void *arg)
{
struct listnode *node;
struct isis_adjacency *adj;
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj = getdata (node);
- (*func)(adj, arg);
- }
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj = getdata (node);
+ (*func) (adj, arg);
+ }
}
void
isis_adj_build_neigh_list (struct list *adjdb, struct list *list)
-
{
struct isis_adjacency *adj;
struct listnode *node;
-
-
- if (!list) {
- zlog_warn ("isis_adj_build_neigh_list(): NULL list");
- return;
- }
-
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj = getdata (node);
- if (!adj) {
- zlog_warn ("isis_adj_build_neigh_list(): NULL adj");
+
+ if (!list)
+ {
+ zlog_warn ("isis_adj_build_neigh_list(): NULL list");
return;
}
-
- if ((adj->adj_state == ISIS_ADJ_UP ||
- adj->adj_state == ISIS_ADJ_INITIALIZING))
- listnode_add (list, adj->snpa);
- }
+
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj = getdata (node);
+ if (!adj)
+ {
+ zlog_warn ("isis_adj_build_neigh_list(): NULL adj");
+ return;
+ }
+
+ if ((adj->adj_state == ISIS_ADJ_UP ||
+ adj->adj_state == ISIS_ADJ_INITIALIZING))
+ listnode_add (list, adj->snpa);
+ }
return;
}
@@ -492,23 +506,25 @@
struct isis_adjacency *adj;
struct listnode *node;
- if (!list) {
- zlog_warn ("isis_adj_build_up_list(): NULL list");
- return;
- }
-
- for (node = listhead (adjdb); node; nextnode (node)) {
- adj = getdata (node);
-
- if (!adj) {
- zlog_warn ("isis_adj_build_up_list(): NULL adj");
+ if (!list)
+ {
+ zlog_warn ("isis_adj_build_up_list(): NULL list");
return;
}
- if (adj->adj_state == ISIS_ADJ_UP)
- listnode_add (list, adj);
- }
-
+ for (node = listhead (adjdb); node; nextnode (node))
+ {
+ adj = getdata (node);
+
+ if (!adj)
+ {
+ zlog_warn ("isis_adj_build_up_list(): NULL adj");
+ return;
+ }
+
+ if (adj->adj_state == ISIS_ADJ_UP)
+ listnode_add (list, adj);
+ }
+
return;
}
-
diff --git a/isisd/isis_adjacency.h b/isisd/isis_adjacency.h
index 5c0772c..a9b1913 100644
--- a/isisd/isis_adjacency.h
+++ b/isisd/isis_adjacency.h
@@ -33,7 +33,7 @@
ISIS_ADJ_LEVEL1AND2
};
-enum isis_system_type
+enum isis_system_type
{
ISIS_SYSTYPE_UNKNOWN,
ISIS_SYSTYPE_ES,
@@ -42,7 +42,7 @@
ISIS_SYSTYPE_L2_IS
};
-enum isis_adj_state
+enum isis_adj_state
{
ISIS_ADJ_INITIALIZING,
ISIS_ADJ_UP,
@@ -62,65 +62,66 @@
ISIS_ADJ_REASON_CHECKSUM_FAILED
};
-#define DIS_RECORDS 8 /* keep the last 8 DIS state changes on record */
+#define DIS_RECORDS 8 /* keep the last 8 DIS state changes on record */
-struct isis_dis_record {
- int dis; /* is our neighbor the DIS ? */ time_t last_dis_change; /* timestamp for last dis change */
+struct isis_dis_record
+{
+ int dis; /* is our neighbor the DIS ? */
+ time_t last_dis_change; /* timestamp for last dis change */
};
-struct isis_adjacency{
- u_char snpa[ETH_ALEN]; /* NeighbourSNPAAddress */
- u_char sysid[ISIS_SYS_ID_LEN]; /* neighbourSystemIdentifier */
- u_char lanid[ISIS_SYS_ID_LEN+1]; /* LAN id on bcast circuits */
- int dischanges[ISIS_LEVELS]; /* how many DIS changes ?*/
+struct isis_adjacency
+{
+ u_char snpa[ETH_ALEN]; /* NeighbourSNPAAddress */
+ u_char sysid[ISIS_SYS_ID_LEN]; /* neighbourSystemIdentifier */
+ u_char lanid[ISIS_SYS_ID_LEN + 1]; /* LAN id on bcast circuits */
+ int dischanges[ISIS_LEVELS]; /* how many DIS changes ? */
/* an array of N levels for M records */
- struct isis_dis_record dis_record[DIS_RECORDS * ISIS_LEVELS];
- enum isis_adj_state adj_state; /* adjacencyState */
- enum isis_adj_usage adj_usage; /* adjacencyUsage */
- struct list *area_addrs; /* areaAdressesOfNeighbour */
- struct nlpids nlpids; /* protocols spoken ... */
+ struct isis_dis_record dis_record[DIS_RECORDS * ISIS_LEVELS];
+ enum isis_adj_state adj_state; /* adjacencyState */
+ enum isis_adj_usage adj_usage; /* adjacencyUsage */
+ struct list *area_addrs; /* areaAdressesOfNeighbour */
+ struct nlpids nlpids; /* protocols spoken ... */
struct list *ipv4_addrs;
#ifdef HAVE_IPV6
struct list *ipv6_addrs;
-#endif /* HAVE_IPV6 */
- u_char prio[ISIS_LEVELS]; /* priorityOfNeighbour for DIS*/
- int circuit_t; /* from hello PDU hdr */
- int level; /* level (1 or 2) */
- enum isis_system_type sys_type; /* neighbourSystemType */
- u_int16_t hold_time; /* entryRemainingTime */
+#endif /* HAVE_IPV6 */
+ u_char prio[ISIS_LEVELS]; /* priorityOfNeighbour for DIS */
+ int circuit_t; /* from hello PDU hdr */
+ int level; /* level (1 or 2) */
+ enum isis_system_type sys_type; /* neighbourSystemType */
+ u_int16_t hold_time; /* entryRemainingTime */
u_int32_t last_upd;
- u_int32_t last_flap; /* last time the adj flapped */
- int flaps; /* number of adjacency flaps */
- struct thread *t_expire; /* expire after hold_time */
- struct isis_circuit *circuit; /* back pointer */
+ u_int32_t last_flap; /* last time the adj flapped */
+ int flaps; /* number of adjacency flaps */
+ struct thread *t_expire; /* expire after hold_time */
+ struct isis_circuit *circuit; /* back pointer */
};
-
-struct isis_adjacency *isis_adj_lookup (u_char *sysid, struct list *adjdb);
-struct isis_adjacency *isis_adj_lookup_snpa (u_char *ssnpa,
+struct isis_adjacency *isis_adj_lookup (u_char * sysid, struct list *adjdb);
+struct isis_adjacency *isis_adj_lookup_snpa (u_char * ssnpa,
struct list *adjdb);
-struct isis_adjacency *isis_new_adj (u_char *id, u_char *snpa, int level,
- struct isis_circuit *circuit);
-void isis_delete_adj (struct isis_adjacency *adj, struct list *adjdb);
-void isis_adj_state_change (struct isis_adjacency *adj,
- enum isis_adj_state state, char *reason);
-void isis_adj_print (struct isis_adjacency *adj);
-int isis_adj_expire (struct thread *thread);
+struct isis_adjacency *isis_new_adj (u_char * id, u_char * snpa, int level,
+ struct isis_circuit *circuit);
+void isis_delete_adj (struct isis_adjacency *adj, struct list *adjdb);
+void isis_adj_state_change (struct isis_adjacency *adj,
+ enum isis_adj_state state, char *reason);
+void isis_adj_print (struct isis_adjacency *adj);
+int isis_adj_expire (struct thread *thread);
void isis_adj_print_vty (struct isis_adjacency *adj, struct vty *vty);
void isis_adj_print_vty_detail (struct isis_adjacency *adj, struct vty *vty);
-void isis_adj_print_vty_extensive (struct isis_adjacency *adj,
- struct vty *vty);
+void isis_adj_print_vty_extensive (struct isis_adjacency *adj,
+ struct vty *vty);
void isis_adj_p2p_print_vty (struct isis_adjacency *adj, struct vty *vty);
-void isis_adj_p2p_print_vty_detail (struct isis_adjacency *adj,
- struct vty *vty);
-void isis_adj_p2p_print_vty_extensive (struct isis_adjacency *adj,
- struct vty *vty);
+void isis_adj_p2p_print_vty_detail (struct isis_adjacency *adj,
+ struct vty *vty);
+void isis_adj_p2p_print_vty_extensive (struct isis_adjacency *adj,
+ struct vty *vty);
void isis_adj_build_neigh_list (struct list *adjdb, struct list *list);
void isis_adj_build_up_list (struct list *adjdb, struct list *list);
-void isis_adjdb_iterate (struct list *adjdb,
- void (*func)(struct isis_adjacency*,
- void *), void *arg);
+void isis_adjdb_iterate (struct list *adjdb,
+ void (*func) (struct isis_adjacency *,
+ void *), void *arg);
#endif /* ISIS_ADJACENCY_H */
-
diff --git a/isisd/isis_circuit.c b/isisd/isis_circuit.c
index 192b107..671ebbf 100644
--- a/isisd/isis_circuit.c
+++ b/isisd/isis_circuit.c
@@ -67,24 +67,27 @@
int i;
circuit = XMALLOC (MTYPE_ISIS_CIRCUIT, sizeof (struct isis_circuit));
- if (circuit) {
- memset (circuit, 0, sizeof (struct isis_circuit));
- /* set default metrics for circuit */
- for (i = 0; i < 2; i++) {
- circuit->metrics[i].metric_default = DEFAULT_CIRCUIT_METRICS;
- circuit->metrics[i].metric_expense = METRICS_UNSUPPORTED;
- circuit->metrics[i].metric_error = METRICS_UNSUPPORTED;
- circuit->metrics[i].metric_delay = METRICS_UNSUPPORTED;
+ if (circuit)
+ {
+ memset (circuit, 0, sizeof (struct isis_circuit));
+ /* set default metrics for circuit */
+ for (i = 0; i < 2; i++)
+ {
+ circuit->metrics[i].metric_default = DEFAULT_CIRCUIT_METRICS;
+ circuit->metrics[i].metric_expense = METRICS_UNSUPPORTED;
+ circuit->metrics[i].metric_error = METRICS_UNSUPPORTED;
+ circuit->metrics[i].metric_delay = METRICS_UNSUPPORTED;
+ }
}
- } else {
- zlog_err ("Can't malloc isis circuit");
- return NULL;
- }
-
+ else
+ {
+ zlog_err ("Can't malloc isis circuit");
+ return NULL;
+ }
+
return circuit;
}
-
void
isis_circuit_configure (struct isis_circuit *circuit, struct isis_area *area)
{
@@ -98,18 +101,20 @@
/*
* Default values
*/
- for (i = 0; i < 2; i++) {
- circuit->hello_interval[i] = HELLO_INTERVAL;
- circuit->hello_multiplier[i] = HELLO_MULTIPLIER;
- circuit->csnp_interval[i] = CSNP_INTERVAL;
- circuit->psnp_interval[i] = PSNP_INTERVAL;
- circuit->u.bc.priority[i] = DEFAULT_PRIORITY;
- }
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- circuit->u.bc.adjdb[0] = list_new ();
- circuit->u.bc.adjdb[1] = list_new ();
- circuit->u.bc.pad_hellos = 1;
- }
+ for (i = 0; i < 2; i++)
+ {
+ circuit->hello_interval[i] = HELLO_INTERVAL;
+ circuit->hello_multiplier[i] = HELLO_MULTIPLIER;
+ circuit->csnp_interval[i] = CSNP_INTERVAL;
+ circuit->psnp_interval[i] = PSNP_INTERVAL;
+ circuit->u.bc.priority[i] = DEFAULT_PRIORITY;
+ }
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ circuit->u.bc.adjdb[0] = list_new ();
+ circuit->u.bc.adjdb[1] = list_new ();
+ circuit->u.bc.pad_hellos = 1;
+ }
circuit->lsp_interval = LSP_INTERVAL;
/*
@@ -123,11 +128,11 @@
return;
}
-void
+void
isis_circuit_deconfigure (struct isis_circuit *circuit,
- struct isis_area *area)
+ struct isis_area *area)
{
-
+
/* Remove circuit from area */
listnode_delete (area->circuit_list, circuit);
/* Free the index of SRM and SSN flags */
@@ -141,16 +146,17 @@
{
struct isis_circuit *circuit = NULL;
struct listnode *node;
-
+
if (!list)
return NULL;
-
- for (node = listhead (list); node; nextnode (node)) {
- circuit = getdata (node);
- if (circuit->interface == ifp)
- return circuit;
- }
-
+
+ for (node = listhead (list); node; nextnode (node))
+ {
+ circuit = getdata (node);
+ if (circuit->interface == ifp)
+ return circuit;
+ }
+
return NULL;
}
@@ -164,13 +170,14 @@
if (!isis->area_list)
return NULL;
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
- circuit = circuit_lookup_by_ifp (ifp, area->circuit_list);
- if (circuit)
- return circuit;
- }
-
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
+ circuit = circuit_lookup_by_ifp (ifp, area->circuit_list);
+ if (circuit)
+ return circuit;
+ }
+
return circuit_lookup_by_ifp (ifp, isis->init_circ_list);
}
@@ -181,17 +188,18 @@
if (!circuit)
return;
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- /* destroy adjacency databases */
- list_delete (circuit->u.bc.adjdb[0]);
- list_delete (circuit->u.bc.adjdb[1]);
- /* destroy neighbour lists */
- if (circuit->u.bc.lan_neighs[0])
- list_delete (circuit->u.bc.lan_neighs[0]);
- if (circuit->u.bc.lan_neighs[1])
- list_delete (circuit->u.bc.lan_neighs[1]);
- /* destroy addresses */
- }
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ /* destroy adjacency databases */
+ list_delete (circuit->u.bc.adjdb[0]);
+ list_delete (circuit->u.bc.adjdb[1]);
+ /* destroy neighbour lists */
+ if (circuit->u.bc.lan_neighs[0])
+ list_delete (circuit->u.bc.lan_neighs[0]);
+ if (circuit->u.bc.lan_neighs[1])
+ list_delete (circuit->u.bc.lan_neighs[1]);
+ /* destroy addresses */
+ }
if (circuit->ip_addrs)
list_delete (circuit->ip_addrs);
#ifdef HAVE_IPV6
@@ -200,7 +208,7 @@
if (circuit->ipv6_non_link)
list_delete (circuit->ipv6_non_link);
#endif /* HAVE_IPV6 */
-
+
/* and lastly the circuit itself */
XFREE (MTYPE_ISIS_CIRCUIT, circuit);
@@ -208,63 +216,70 @@
}
void
-isis_circuit_add_addr (struct isis_circuit *circuit,
- struct connected *conn)
+isis_circuit_add_addr (struct isis_circuit *circuit, struct connected *conn)
{
struct prefix_ipv4 *ipv4;
- u_char buf [BUFSIZ];
+ u_char buf[BUFSIZ];
#ifdef HAVE_IPV6
struct prefix_ipv6 *ipv6;
#endif /* HAVE_IPV6 */
- if (!circuit->ip_addrs) {
- circuit->ip_addrs = list_new ();
- }
+ if (!circuit->ip_addrs)
+ {
+ circuit->ip_addrs = list_new ();
+ }
#ifdef HAVE_IPV6
- if (!circuit->ipv6_link) {
- circuit->ipv6_link = list_new ();
- }
- if (!circuit->ipv6_non_link) {
- circuit->ipv6_non_link = list_new ();
- }
+ if (!circuit->ipv6_link)
+ {
+ circuit->ipv6_link = list_new ();
+ }
+ if (!circuit->ipv6_non_link)
+ {
+ circuit->ipv6_non_link = list_new ();
+ }
#endif /* HAVE_IPV6 */
memset (&buf, 0, BUFSIZ);
- if (conn->address->family == AF_INET) {
- ipv4 = prefix_ipv4_new ();
- ipv4->prefixlen = conn->address->prefixlen;
- ipv4->prefix = conn->address->u.prefix4;
- listnode_add (circuit->ip_addrs, ipv4);
- prefix2str (conn->address, buf, BUFSIZ);
+ if (conn->address->family == AF_INET)
+ {
+ ipv4 = prefix_ipv4_new ();
+ ipv4->prefixlen = conn->address->prefixlen;
+ ipv4->prefix = conn->address->u.prefix4;
+ listnode_add (circuit->ip_addrs, ipv4);
+ prefix2str (conn->address, buf, BUFSIZ);
#ifdef EXTREME_DEBUG
- zlog_info ("Added IP address %s to circuit %d", buf,
- circuit->circuit_id);
-#endif /* EXTREME_DEBUG */
- }
-#ifdef HAVE_IPV6
- if (conn->address->family == AF_INET6) {
- ipv6 = prefix_ipv6_new ();
- ipv6->prefixlen = conn->address->prefixlen;
- ipv6->prefix = conn->address->u.prefix6;
- if (IN6_IS_ADDR_LINKLOCAL(&ipv6->prefix)) {
- listnode_add (circuit->ipv6_link, ipv6);
- } else {
- listnode_add (circuit->ipv6_non_link, ipv6);
+ zlog_info ("Added IP address %s to circuit %d", buf,
+ circuit->circuit_id);
+#endif /* EXTREME_DEBUG */
}
- prefix2str (conn->address, buf, BUFSIZ);
+#ifdef HAVE_IPV6
+ if (conn->address->family == AF_INET6)
+ {
+ ipv6 = prefix_ipv6_new ();
+ ipv6->prefixlen = conn->address->prefixlen;
+ ipv6->prefix = conn->address->u.prefix6;
+ if (IN6_IS_ADDR_LINKLOCAL (&ipv6->prefix))
+ {
+ listnode_add (circuit->ipv6_link, ipv6);
+ }
+ else
+ {
+ listnode_add (circuit->ipv6_non_link, ipv6);
+ }
+ prefix2str (conn->address, buf, BUFSIZ);
#ifdef EXTREME_DEBUG
- zlog_info ("Added IPv6 address %s to circuit %d", buf,
- circuit->circuit_id);
-#endif /* EXTREME_DEBUG */
- }
+ zlog_info ("Added IPv6 address %s to circuit %d", buf,
+ circuit->circuit_id);
+#endif /* EXTREME_DEBUG */
+ }
#endif /* HAVE_IPV6 */
-
+
return;
}
void
isis_circuit_del_addr (struct isis_circuit *circuit,
- struct connected *connected)
+ struct connected *connected)
{
}
@@ -277,60 +292,71 @@
circuit->interface = ifp;
ifp->info = circuit;
-
- circuit->circuit_id = ifp->ifindex % 255; /* FIXME: Why not ? */
+
+ circuit->circuit_id = ifp->ifindex % 255; /* FIXME: Why not ? */
/* isis_circuit_update_addrs (circuit, ifp); */
- if (if_is_broadcast (ifp)) {
- circuit->circ_type = CIRCUIT_T_BROADCAST;
- /*
- * Get the Hardware Address
- */
+ if (if_is_broadcast (ifp))
+ {
+ circuit->circ_type = CIRCUIT_T_BROADCAST;
+ /*
+ * Get the Hardware Address
+ */
#ifdef HAVE_SOCKADDR_DL
- if (circuit->interface->sdl.sdl_alen != ETHER_ADDR_LEN)
- zlog_warn ("unsupported link layer");
- else
- memcpy (circuit->u.bc.snpa, LLADDR(&circuit->interface->sdl), ETH_ALEN);
+ if (circuit->interface->sdl.sdl_alen != ETHER_ADDR_LEN)
+ zlog_warn ("unsupported link layer");
+ else
+ memcpy (circuit->u.bc.snpa, LLADDR (&circuit->interface->sdl),
+ ETH_ALEN);
#else
- if (circuit->interface->hw_addr_len != ETH_ALEN) {
- zlog_warn ("unsupported link layer");
- } else {
- memcpy (circuit->u.bc.snpa, circuit->interface->hw_addr, ETH_ALEN);
- }
+ if (circuit->interface->hw_addr_len != ETH_ALEN)
+ {
+ zlog_warn ("unsupported link layer");
+ }
+ else
+ {
+ memcpy (circuit->u.bc.snpa, circuit->interface->hw_addr, ETH_ALEN);
+ }
#ifdef EXTREME_DEGUG
- zlog_info ("isis_circuit_if_add: if_id %d, isomtu %d snpa %s",
- circuit->interface->ifindex, ISO_MTU (circuit),
- snpa_print (circuit->u.bc.snpa));
+ zlog_info ("isis_circuit_if_add: if_id %d, isomtu %d snpa %s",
+ circuit->interface->ifindex, ISO_MTU (circuit),
+ snpa_print (circuit->u.bc.snpa));
#endif /* EXTREME_DEBUG */
-#endif /* HAVE_SOCKADDR_DL */
- } else if (if_is_pointopoint (ifp)) {
- circuit->circ_type = CIRCUIT_T_P2P;
- } else {
- zlog_warn ("isis_circuit_if_add: unsupported media");
- }
-
- for (node = ifp->connected ? listhead (ifp->connected) : NULL; node;
- nextnode (node)) {
- conn = getdata (node);
- isis_circuit_add_addr (circuit, conn);
- }
+#endif /* HAVE_SOCKADDR_DL */
+ }
+ else if (if_is_pointopoint (ifp))
+ {
+ circuit->circ_type = CIRCUIT_T_P2P;
+ }
+ else
+ {
+ zlog_warn ("isis_circuit_if_add: unsupported media");
+ }
+
+ for (node = ifp->connected ? listhead (ifp->connected) : NULL; node;
+ nextnode (node))
+ {
+ conn = getdata (node);
+ isis_circuit_add_addr (circuit, conn);
+ }
return;
}
void
-isis_circuit_update_params (struct isis_circuit *circuit,
- struct interface *ifp)
+isis_circuit_update_params (struct isis_circuit *circuit,
+ struct interface *ifp)
{
assert (circuit);
-
- if (circuit->circuit_id != ifp->ifindex) {
- zlog_warn ("changing circuit_id %d->%d", circuit->circuit_id,
- ifp->ifindex);
- circuit->circuit_id = ifp->ifindex % 255;
- }
+
+ if (circuit->circuit_id != ifp->ifindex)
+ {
+ zlog_warn ("changing circuit_id %d->%d", circuit->circuit_id,
+ ifp->ifindex);
+ circuit->circuit_id = ifp->ifindex % 255;
+ }
/* FIXME: Why is this needed? shouldn't we compare to the area's mtu */
/* Ofer, this was here in case someone changes the mtu (e.g. with ifconfig)
@@ -341,125 +367,141 @@
ifp->mtu);
circuit->mtu = ifp->mtu;
}
- */
+ */
/*
* Get the Hardware Address
*/
#ifdef HAVE_SOCKADDR_DL
if (circuit->interface->sdl.sdl_alen != ETHER_ADDR_LEN)
- zlog_warn ("unsupported link layer");
- else
- memcpy (circuit->u.bc.snpa, LLADDR(&circuit->interface->sdl), ETH_ALEN);
-#else
- if (circuit->interface->hw_addr_len != ETH_ALEN) {
zlog_warn ("unsupported link layer");
- } else {
- if (memcmp(circuit->u.bc.snpa, circuit->interface->hw_addr, ETH_ALEN)) {
- zlog_warn ("changing circuit snpa %s->%s",
- snpa_print (circuit->u.bc.snpa),
- snpa_print (circuit->interface->hw_addr));
+ else
+ memcpy (circuit->u.bc.snpa, LLADDR (&circuit->interface->sdl), ETH_ALEN);
+#else
+ if (circuit->interface->hw_addr_len != ETH_ALEN)
+ {
+ zlog_warn ("unsupported link layer");
}
- }
-#endif
+ else
+ {
+ if (memcmp (circuit->u.bc.snpa, circuit->interface->hw_addr, ETH_ALEN))
+ {
+ zlog_warn ("changing circuit snpa %s->%s",
+ snpa_print (circuit->u.bc.snpa),
+ snpa_print (circuit->interface->hw_addr));
+ }
+ }
+#endif
+ if (if_is_broadcast (ifp))
+ {
+ circuit->circ_type = CIRCUIT_T_BROADCAST;
+ }
+ else if (if_is_pointopoint (ifp))
+ {
+ circuit->circ_type = CIRCUIT_T_P2P;
+ }
+ else
+ {
+ zlog_warn ("isis_circuit_update_params: unsupported media");
+ }
-
- if (if_is_broadcast (ifp)) {
- circuit->circ_type = CIRCUIT_T_BROADCAST;
- } else if (if_is_pointopoint (ifp)) {
- circuit->circ_type = CIRCUIT_T_P2P;
- } else {
- zlog_warn ("isis_circuit_update_params: unsupported media");
- }
-
return;
}
void
-isis_circuit_if_del (struct isis_circuit *circuit)
+isis_circuit_if_del (struct isis_circuit *circuit)
{
circuit->interface->info = NULL;
circuit->interface = NULL;
-
+
return;
}
void
isis_circuit_up (struct isis_circuit *circuit)
{
-
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- if (circuit->area->min_bcast_mtu == 0 ||
- ISO_MTU(circuit) < circuit->area->min_bcast_mtu )
- circuit->area->min_bcast_mtu = ISO_MTU(circuit);
- /*
- * ISO 10589 - 8.4.1 Enabling of broadcast circuits
- */
- /* initilizing the hello sending threads
- * for a broadcast IF
- */
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ if (circuit->area->min_bcast_mtu == 0 ||
+ ISO_MTU (circuit) < circuit->area->min_bcast_mtu)
+ circuit->area->min_bcast_mtu = ISO_MTU (circuit);
+ /*
+ * ISO 10589 - 8.4.1 Enabling of broadcast circuits
+ */
- /* 8.4.1 a) commence sending of IIH PDUs */
+ /* initilizing the hello sending threads
+ * for a broadcast IF
+ */
- if (circuit->circuit_is_type & IS_LEVEL_1) {
- thread_add_event (master, send_lan_l1_hello, circuit, 0);
- circuit->u.bc.lan_neighs[0] = list_new ();
+ /* 8.4.1 a) commence sending of IIH PDUs */
+
+ if (circuit->circuit_is_type & IS_LEVEL_1)
+ {
+ thread_add_event (master, send_lan_l1_hello, circuit, 0);
+ circuit->u.bc.lan_neighs[0] = list_new ();
+ }
+
+ if (circuit->circuit_is_type & IS_LEVEL_2)
+ {
+ thread_add_event (master, send_lan_l2_hello, circuit, 0);
+ circuit->u.bc.lan_neighs[1] = list_new ();
+ }
+
+ /* 8.4.1 b) FIXME: solicit ES - 8.4.6 */
+ /* 8.4.1 c) FIXME: listen for ESH PDUs */
+
+ /* 8.4.1 d) */
+ /* dr election will commence in... */
+ if (circuit->circuit_is_type & IS_LEVEL_1)
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
+ circuit,
+ 2 * circuit->hello_multiplier[0] *
+ circuit->hello_interval[0]);
+ if (circuit->circuit_is_type & IS_LEVEL_2)
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
+ circuit,
+ 2 * circuit->hello_multiplier[1] *
+ circuit->hello_interval[1]);
}
+ else
+ {
+ /* initializing the hello send threads
+ * for a ptp IF
+ */
+ thread_add_event (master, send_p2p_hello, circuit, 0);
- if (circuit->circuit_is_type & IS_LEVEL_2) {
- thread_add_event (master, send_lan_l2_hello, circuit, 0);
- circuit->u.bc.lan_neighs[1] = list_new ();
}
- /* 8.4.1 b) FIXME: solicit ES - 8.4.6 */
- /* 8.4.1 c) FIXME: listen for ESH PDUs */
-
- /* 8.4.1 d) */
- /* dr election will commence in... */
- if (circuit->circuit_is_type & IS_LEVEL_1)
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit,
- 2 * circuit->hello_multiplier[0] * circuit->hello_interval[0]);
- if (circuit->circuit_is_type & IS_LEVEL_2)
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit,
- 2 * circuit->hello_multiplier[1] * circuit->hello_interval[1]);
- } else {
- /* initializing the hello send threads
- * for a ptp IF
- */
- thread_add_event (master, send_p2p_hello, circuit, 0);
-
- }
-
/* initializing PSNP timers */
- if (circuit->circuit_is_type & IS_LEVEL_1) {
- THREAD_TIMER_ON(master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter(circuit->psnp_interval[0], PSNP_JITTER));
- }
-
- if (circuit->circuit_is_type & IS_LEVEL_2) {
- THREAD_TIMER_ON(master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter(circuit->psnp_interval[1], PSNP_JITTER));
- }
-
+ if (circuit->circuit_is_type & IS_LEVEL_1)
+ {
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
+ }
+
+ if (circuit->circuit_is_type & IS_LEVEL_2)
+ {
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
+ }
+
/* initialize the circuit streams */
if (circuit->rcv_stream == NULL)
- circuit->rcv_stream = stream_new (ISO_MTU(circuit));
+ circuit->rcv_stream = stream_new (ISO_MTU (circuit));
if (circuit->snd_stream == NULL)
- circuit->snd_stream = stream_new (ISO_MTU(circuit));
+ circuit->snd_stream = stream_new (ISO_MTU (circuit));
/* unified init for circuits */
isis_sock_init (circuit);
#ifdef GNU_LINUX
- THREAD_READ_ON(master, circuit->t_read, isis_receive, circuit,
- circuit->fd);
+ THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
+ circuit->fd);
#else
- THREAD_TIMER_ON(master, circuit->t_read, isis_receive, circuit,
- circuit->fd);
+ THREAD_TIMER_ON (master, circuit->t_read, isis_receive, circuit,
+ circuit->fd);
#endif
return;
}
@@ -467,15 +509,18 @@
void
isis_circuit_down (struct isis_circuit *circuit)
{
- /* Cancel all active threads -- FIXME: wrong place*/
+ /* Cancel all active threads -- FIXME: wrong place */
/* HT: Read thread if GNU_LINUX, TIMER thread otherwise. */
- THREAD_OFF(circuit->t_read);
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[0]);
- THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[1]);
- } else if (circuit->circ_type == CIRCUIT_T_P2P) {
- THREAD_TIMER_OFF(circuit->u.p2p.t_send_p2p_hello);
- }
+ THREAD_OFF (circuit->t_read);
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ THREAD_TIMER_OFF (circuit->u.bc.t_send_lan_hello[0]);
+ THREAD_TIMER_OFF (circuit->u.bc.t_send_lan_hello[1]);
+ }
+ else if (circuit->circ_type == CIRCUIT_T_P2P)
+ {
+ THREAD_TIMER_OFF (circuit->u.p2p.t_send_p2p_hello);
+ }
/* close the socket */
close (circuit->fd);
@@ -486,22 +531,24 @@
circuit_update_nlpids (struct isis_circuit *circuit)
{
circuit->nlpids.count = 0;
-
- if (circuit->ip_router) {
- circuit->nlpids.nlpids[0] = NLPID_IP;
- circuit->nlpids.count++;
- }
+
+ if (circuit->ip_router)
+ {
+ circuit->nlpids.nlpids[0] = NLPID_IP;
+ circuit->nlpids.count++;
+ }
#ifdef HAVE_IPV6
- if (circuit->ipv6_router) {
- circuit->nlpids.nlpids[circuit->nlpids.count] = NLPID_IPV6;
- circuit->nlpids.count++;
- }
+ if (circuit->ipv6_router)
+ {
+ circuit->nlpids.nlpids[circuit->nlpids.count] = NLPID_IPV6;
+ circuit->nlpids.count++;
+ }
#endif /* HAVE_IPV6 */
return;
}
int
-isis_interface_config_write (struct vty *vty)
+isis_interface_config_write (struct vty *vty)
{
int write = 0;
@@ -519,146 +566,194 @@
char buf[BUFSIZ];
-
LIST_LOOP (iflist, ifp, node)
{
/* IF name */
- vty_out (vty, "interface %s%s", ifp->name,VTY_NEWLINE);
+ vty_out (vty, "interface %s%s", ifp->name, VTY_NEWLINE);
write++;
/* IF desc */
- if (ifp->desc) {
- vty_out (vty, " description %s%s", ifp->desc,VTY_NEWLINE);
- write++;
- }
+ if (ifp->desc)
+ {
+ vty_out (vty, " description %s%s", ifp->desc, VTY_NEWLINE);
+ write++;
+ }
/* ISIS Circuit */
LIST_LOOP (isis->area_list, area, node2)
{
c = circuit_lookup_by_ifp (ifp, area->circuit_list);
- if (c) {
- if (c->ip_router) {
- vty_out (vty, " ip router isis %s%s",area->area_tag,VTY_NEWLINE);
- write++;
- }
+ if (c)
+ {
+ if (c->ip_router)
+ {
+ vty_out (vty, " ip router isis %s%s", area->area_tag,
+ VTY_NEWLINE);
+ write++;
+ }
#ifdef HAVE_IPV6
- if (c->ipv6_router) {
- vty_out (vty, " ipv6 router isis %s%s",area->area_tag,VTY_NEWLINE);
- write++;
- }
+ if (c->ipv6_router)
+ {
+ vty_out (vty, " ipv6 router isis %s%s", area->area_tag,
+ VTY_NEWLINE);
+ write++;
+ }
#endif /* HAVE_IPV6 */
- /* ISIS - circuit type */
- if (c->circuit_is_type == IS_LEVEL_1) {
- vty_out (vty, " isis circuit-type level-1%s", VTY_NEWLINE);
- write ++;
- } else {if (c->circuit_is_type == IS_LEVEL_2) {
- vty_out (vty, " isis circuit-type level-2-only%s", VTY_NEWLINE);
- write ++;
- }}
+ /* ISIS - circuit type */
+ if (c->circuit_is_type == IS_LEVEL_1)
+ {
+ vty_out (vty, " isis circuit-type level-1%s", VTY_NEWLINE);
+ write++;
+ }
+ else
+ {
+ if (c->circuit_is_type == IS_LEVEL_2)
+ {
+ vty_out (vty, " isis circuit-type level-2-only%s",
+ VTY_NEWLINE);
+ write++;
+ }
+ }
- /* ISIS - CSNP interval - FIXME: compare to cisco*/
- if (c->csnp_interval[0] == c->csnp_interval[1]) {
- if (c->csnp_interval[0] != CSNP_INTERVAL) {
- vty_out (vty, " isis csnp-interval %d%s", c->csnp_interval[0],
- VTY_NEWLINE);
- write ++;
- }
- } else {
- for (i=0;i<2;i++) {
- if (c->csnp_interval[1] != CSNP_INTERVAL) {
- vty_out (vty, " isis csnp-interval %d level-%d%s",
- c->csnp_interval[1],i+1, VTY_NEWLINE);
- write ++;
- }
- }
- }
+ /* ISIS - CSNP interval - FIXME: compare to cisco */
+ if (c->csnp_interval[0] == c->csnp_interval[1])
+ {
+ if (c->csnp_interval[0] != CSNP_INTERVAL)
+ {
+ vty_out (vty, " isis csnp-interval %d%s",
+ c->csnp_interval[0], VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ if (c->csnp_interval[1] != CSNP_INTERVAL)
+ {
+ vty_out (vty, " isis csnp-interval %d level-%d%s",
+ c->csnp_interval[1], i + 1, VTY_NEWLINE);
+ write++;
+ }
+ }
+ }
- /* ISIS - Hello padding - Defaults to true so only display if false */
- if (c->circ_type == CIRCUIT_T_BROADCAST && !c->u.bc.pad_hellos) {
- vty_out (vty, " no isis hello padding%s", VTY_NEWLINE);
- write ++;
- }
+ /* ISIS - Hello padding - Defaults to true so only display if false */
+ if (c->circ_type == CIRCUIT_T_BROADCAST && !c->u.bc.pad_hellos)
+ {
+ vty_out (vty, " no isis hello padding%s", VTY_NEWLINE);
+ write++;
+ }
- /* ISIS - Hello interval - FIXME: compare to cisco */
- if (c->hello_interval[0] == c->hello_interval[1]) {
- if (c->hello_interval[0] != HELLO_INTERVAL) {
- vty_out (vty, " isis hello-interval %d%s", c->hello_interval[0],
- VTY_NEWLINE);
- write ++;
- }
- } else {
- for (i=0;i<2;i++) {
- if (c->hello_interval[i] != HELLO_INTERVAL) {
- if (c->hello_interval[i] == HELLO_MINIMAL) {
- vty_out (vty, " isis hello-interval minimal level-%d%s", i+1,
- VTY_NEWLINE);
- } else {
- vty_out (vty, " isis hello-interval %d level-%d%s",
- c->hello_interval[i],i+1, VTY_NEWLINE);
- }
- write ++;
- }
- }
- }
+ /* ISIS - Hello interval - FIXME: compare to cisco */
+ if (c->hello_interval[0] == c->hello_interval[1])
+ {
+ if (c->hello_interval[0] != HELLO_INTERVAL)
+ {
+ vty_out (vty, " isis hello-interval %d%s",
+ c->hello_interval[0], VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ if (c->hello_interval[i] != HELLO_INTERVAL)
+ {
+ if (c->hello_interval[i] == HELLO_MINIMAL)
+ {
+ vty_out (vty,
+ " isis hello-interval minimal level-%d%s",
+ i + 1, VTY_NEWLINE);
+ }
+ else
+ {
+ vty_out (vty, " isis hello-interval %d level-%d%s",
+ c->hello_interval[i], i + 1, VTY_NEWLINE);
+ }
+ write++;
+ }
+ }
+ }
- /* ISIS - Hello Multiplier */
- if (c->hello_multiplier[0] == c->hello_multiplier[1]) {
- if (c->hello_multiplier[0] != HELLO_MULTIPLIER ) {
- vty_out (vty, " isis hello-multiplier %d%s",
- c->hello_multiplier[0], VTY_NEWLINE);
- write ++;
- }
- } else {
- for (i=0;i<2;i++) {
- if (c->hello_multiplier[i] != HELLO_MULTIPLIER) {
- vty_out (vty, " isis hello-multiplier %d level-%d%s",
- c->hello_multiplier[i],i+1, VTY_NEWLINE);
- write ++;
- }
- }
- }
- /* ISIS - Priority */
- if (c->circ_type == CIRCUIT_T_BROADCAST) {
- if (c->u.bc.priority[0] == c->u.bc.priority[1]) {
- if (c->u.bc.priority[0] != DEFAULT_PRIORITY) {
- vty_out (vty, " isis priority %d%s", c->u.bc.priority[0],
- VTY_NEWLINE);
- write ++;
- }
- } else {
- for (i=0;i<2;i++) {
- if (c->u.bc.priority[i] != DEFAULT_PRIORITY) {
- vty_out (vty, " isis priority %d level-%d%s",
- c->u.bc.priority[i],i+1, VTY_NEWLINE);
- write ++;
- }
- }
- }
- }
- /* ISIS - Metric */
- if (c->metrics[0].metric_default == c->metrics[1].metric_default) {
- if (c->metrics[0].metric_default != DEFAULT_CIRCUIT_METRICS) {
- vty_out (vty, " isis metric %d%s", c->metrics[0].metric_default,
- VTY_NEWLINE);
- write ++;
- }
- } else {
- for (i=0;i<2;i++) {
- if (c->metrics[i].metric_default != DEFAULT_CIRCUIT_METRICS) {
- vty_out (vty, " isis metric %d level-%d%s",
- c->metrics[i].metric_default,i+1, VTY_NEWLINE);
- write ++;
- }
- }
- }
+ /* ISIS - Hello Multiplier */
+ if (c->hello_multiplier[0] == c->hello_multiplier[1])
+ {
+ if (c->hello_multiplier[0] != HELLO_MULTIPLIER)
+ {
+ vty_out (vty, " isis hello-multiplier %d%s",
+ c->hello_multiplier[0], VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ if (c->hello_multiplier[i] != HELLO_MULTIPLIER)
+ {
+ vty_out (vty, " isis hello-multiplier %d level-%d%s",
+ c->hello_multiplier[i], i + 1, VTY_NEWLINE);
+ write++;
+ }
+ }
+ }
+ /* ISIS - Priority */
+ if (c->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ if (c->u.bc.priority[0] == c->u.bc.priority[1])
+ {
+ if (c->u.bc.priority[0] != DEFAULT_PRIORITY)
+ {
+ vty_out (vty, " isis priority %d%s",
+ c->u.bc.priority[0], VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ if (c->u.bc.priority[i] != DEFAULT_PRIORITY)
+ {
+ vty_out (vty, " isis priority %d level-%d%s",
+ c->u.bc.priority[i], i + 1, VTY_NEWLINE);
+ write++;
+ }
+ }
+ }
+ }
+ /* ISIS - Metric */
+ if (c->metrics[0].metric_default == c->metrics[1].metric_default)
+ {
+ if (c->metrics[0].metric_default != DEFAULT_CIRCUIT_METRICS)
+ {
+ vty_out (vty, " isis metric %d%s",
+ c->metrics[0].metric_default, VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; i++)
+ {
+ if (c->metrics[i].metric_default != DEFAULT_CIRCUIT_METRICS)
+ {
+ vty_out (vty, " isis metric %d level-%d%s",
+ c->metrics[i].metric_default, i + 1,
+ VTY_NEWLINE);
+ write++;
+ }
+ }
+ }
- }
+ }
}
- vty_out (vty, "!%s",VTY_NEWLINE);
+ vty_out (vty, "!%s", VTY_NEWLINE);
}
-
+
return write;
}
-
DEFUN (ip_router_isis,
ip_router_isis_cmd,
@@ -666,47 +761,51 @@
"Interface Internet Protocol config commands\n"
"IP router interface commands\n"
"IS-IS Routing for IP\n"
- "Routing process tag\n"
- )
+ "Routing process tag\n")
{
struct isis_circuit *c;
struct interface *ifp;
struct isis_area *area;
-
- ifp = (struct interface *)vty->index;
+
+ ifp = (struct interface *) vty->index;
assert (ifp);
-
+
area = isis_area_lookup (argv[0]);
/* Prevent more than one circuit per interface */
if (area)
c = circuit_lookup_by_ifp (ifp, area->circuit_list);
- else c = NULL;
- if (c && (ifp->info != NULL)) {
+ else
+ c = NULL;
+ if (c && (ifp->info != NULL))
+ {
#ifdef HAVE_IPV6
- if (c->ipv6_router == 0) {
+ if (c->ipv6_router == 0)
+ {
#endif /* HAVE_IPV6 */
- vty_out (vty, "ISIS circuit is already defined%s", VTY_NEWLINE);
- return CMD_WARNING;
+ vty_out (vty, "ISIS circuit is already defined%s", VTY_NEWLINE);
+ return CMD_WARNING;
#ifdef HAVE_IPV6
+ }
+#endif /* HAVE_IPV6 */
}
-#endif /* HAVE_IPV6 */
- }
-
+
/* this is here for ciscopability */
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
- if (!c) {
- c = circuit_lookup_by_ifp (ifp, isis->init_circ_list);
- c = isis_csm_state_change (ISIS_ENABLE, c, area);
- c->interface = ifp; /* this is automatic */
- ifp->info = c; /* hardly related to the FSM */
- }
+ if (!c)
+ {
+ c = circuit_lookup_by_ifp (ifp, isis->init_circ_list);
+ c = isis_csm_state_change (ISIS_ENABLE, c, area);
+ c->interface = ifp; /* this is automatic */
+ ifp->info = c; /* hardly related to the FSM */
+ }
- if(!c)
+ if (!c)
return CMD_WARNING;
c->ip_router = 1;
@@ -714,7 +813,7 @@
circuit_update_nlpids (c);
vty->node = INTERFACE_NODE;
-
+
return CMD_SUCCESS;
}
@@ -725,36 +824,37 @@
"Interface Internet Protocol config commands\n"
"IP router interface commands\n"
"IS-IS Routing for IP\n"
- "Routing process tag\n"
- )
+ "Routing process tag\n")
{
struct isis_circuit *circuit = NULL;
struct interface *ifp;
struct isis_area *area;
struct listnode *node;
- ifp = (struct interface *)vty->index;
+ ifp = (struct interface *) vty->index;
assert (ifp);
-
+
area = isis_area_lookup (argv[0]);
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
LIST_LOOP (area->circuit_list, circuit, node)
if (circuit->interface == ifp)
break;
- if (!circuit) {
- vty_out (vty, "Can't find ISIS interface %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!circuit)
+ {
+ vty_out (vty, "Can't find ISIS interface %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
circuit->ip_router = 0;
area->ip_circuits--;
#ifdef HAVE_IPV6
if (circuit->ipv6_router == 0)
#endif
isis_csm_state_change (ISIS_DISABLE, circuit, area);
-
+
return CMD_SUCCESS;
}
@@ -765,38 +865,40 @@
"Configure circuit type for interface\n"
"Level-1 only adjacencies are formed\n"
"Level-1-2 adjacencies are formed\n"
- "Level-2 only adjacencies are formed\n"
- )
+ "Level-2 only adjacencies are formed\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int circuit_t;
int is_type;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
/* UGLY - will remove l8r */
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit_t = string2circuit_t (argv[0]);
- if (!circuit_t) {
- vty_out (vty, "Unknown circuit-type %s", VTY_NEWLINE);
- return CMD_SUCCESS;
- }
-
+ if (!circuit_t)
+ {
+ vty_out (vty, "Unknown circuit-type %s", VTY_NEWLINE);
+ return CMD_SUCCESS;
+ }
+
is_type = circuit->area->is_type;
if (is_type == IS_LEVEL_1_AND_2 || is_type == circuit_t)
- isis_event_circuit_type_change (circuit, circuit_t);
- else {
- vty_out (vty, "invalid circuit level for area %s.%s",
- circuit->area->area_tag, VTY_NEWLINE);
- }
-
+ isis_event_circuit_type_change (circuit, circuit_t);
+ else
+ {
+ vty_out (vty, "invalid circuit level for area %s.%s",
+ circuit->area->area_tag, VTY_NEWLINE);
+ }
+
return CMD_SUCCESS;
}
@@ -808,25 +910,25 @@
"Configure circuit type for interface\n"
"Level-1 only adjacencies are formed\n"
"Level-1-2 adjacencies are formed\n"
- "Level-2 only adjacencies are formed\n"
- )
+ "Level-2 only adjacencies are formed\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
- circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
- assert(circuit);
-
+ ifp = vty->index;
+ circuit = ifp->info;
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
+
+ assert (circuit);
+
/*
* Set the circuits level to its default value which is that of the area
*/
isis_event_circuit_type_change (circuit, circuit->area->is_type);
-
+
return CMD_SUCCESS;
}
@@ -840,22 +942,24 @@
struct isis_circuit *circuit;
struct interface *ifp;
int len;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
-
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
+
len = strlen (argv[0]);
- if (len > 254) {
- vty_out (vty, "Too long circuit password (>254)%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (len > 254)
+ {
+ vty_out (vty, "Too long circuit password (>254)%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
circuit->passwd.len = len;
circuit->passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;
strncpy (circuit->passwd.passwd, argv[0], 255);
-
+
return CMD_SUCCESS;
}
@@ -868,15 +972,16 @@
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
-
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
+
memset (&circuit->passwd, 0, sizeof (struct isis_passwd));
-
+
return CMD_SUCCESS;
}
@@ -886,25 +991,25 @@
"isis priority <0-127>",
"IS-IS commands\n"
"Set priority for Designated Router election\n"
- "Priority value\n"
- )
+ "Priority value\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int prio;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
prio = atoi (argv[0]);
circuit->u.bc.priority[0] = prio;
circuit->u.bc.priority[1] = prio;
-
+
return CMD_SUCCESS;
}
@@ -913,22 +1018,22 @@
"no isis priority",
NO_STR
"IS-IS commands\n"
- "Set priority for Designated Router election\n"
- )
+ "Set priority for Designated Router election\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit->u.bc.priority[0] = DEFAULT_PRIORITY;
circuit->u.bc.priority[1] = DEFAULT_PRIORITY;
-
+
return CMD_SUCCESS;
}
@@ -938,33 +1043,32 @@
NO_STR
"IS-IS commands\n"
"Set priority for Designated Router election\n"
- "Priority value\n"
- )
+ "Priority value\n")
DEFUN (isis_priority_l1,
isis_priority_l1_cmd,
- "isis priority <0-127> level-1",
+ "isis priority <0-127> level-1",
"IS-IS commands\n"
"Set priority for Designated Router election\n"
"Priority value\n"
- "Specify priority for level-1 routing\n"
- )
+ "Specify priority for level-1 routing\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int prio;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
prio = atoi (argv[0]);
circuit->u.bc.priority[0] = prio;
-
+
return CMD_SUCCESS;
}
@@ -974,21 +1078,21 @@
NO_STR
"IS-IS commands\n"
"Set priority for Designated Router election\n"
- "Specify priority for level-1 routing\n"
- )
+ "Specify priority for level-1 routing\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->u.bc.priority[0] = DEFAULT_PRIORITY;
-
+
return CMD_SUCCESS;
}
@@ -999,33 +1103,32 @@
"IS-IS commands\n"
"Set priority for Designated Router election\n"
"Priority value\n"
- "Specify priority for level-1 routing\n"
- )
+ "Specify priority for level-1 routing\n")
DEFUN (isis_priority_l2,
isis_priority_l2_cmd,
- "isis priority <0-127> level-2",
+ "isis priority <0-127> level-2",
"IS-IS commands\n"
"Set priority for Designated Router election\n"
"Priority value\n"
- "Specify priority for level-2 routing\n"
- )
+ "Specify priority for level-2 routing\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int prio;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
prio = atoi (argv[0]);
circuit->u.bc.priority[1] = prio;
-
+
return CMD_SUCCESS;
}
@@ -1035,21 +1138,21 @@
NO_STR
"IS-IS commands\n"
"Set priority for Designated Router election\n"
- "Specify priority for level-2 routing\n"
- )
+ "Specify priority for level-2 routing\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->u.bc.priority[1] = DEFAULT_PRIORITY;
-
+
return CMD_SUCCESS;
}
@@ -1060,28 +1163,26 @@
"IS-IS commands\n"
"Set priority for Designated Router election\n"
"Priority value\n"
- "Specify priority for level-2 routing\n"
- )
+ "Specify priority for level-2 routing\n")
/* Metric command */
-
-DEFUN (isis_metric,
+ DEFUN (isis_metric,
isis_metric_cmd,
"isis metric <0-63>",
"IS-IS commands\n"
"Set default metric for circuit\n"
- "Default metric value\n"
- )
+ "Default metric value\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int met;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
met = atoi (argv[0]);
@@ -1097,17 +1198,17 @@
"no isis metric",
NO_STR
"IS-IS commands\n"
- "Set default metric for circuit\n"
- )
+ "Set default metric for circuit\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit->metrics[0].metric_default = DEFAULT_CIRCUIT_METRICS;
@@ -1122,40 +1223,40 @@
NO_STR
"IS-IS commands\n"
"Set default metric for circuit\n"
- "Default metric value\n"
- )
+ "Default metric value\n")
+
/* end of metrics */
-
-
-DEFUN (isis_hello_interval,
+ DEFUN (isis_hello_interval,
isis_hello_interval_cmd,
"isis hello-interval (<1-65535>|minimal)",
"IS-IS commands\n"
"Set Hello interval\n"
"Hello interval value\n"
- "Holdtime 1 seconds, interval depends on multiplier\n"
- )
+ "Holdtime 1 seconds, interval depends on multiplier\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int interval;
char c;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
- assert (circuit);
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
+ assert (circuit);
c = *argv[0];
- if (isdigit((int)c)) {
- interval = atoi (argv[0]);
- } else
- interval = HELLO_MINIMAL; /* FIXME: should be calculated */
+ if (isdigit ((int) c))
+ {
+ interval = atoi (argv[0]);
+ }
+ else
+ interval = HELLO_MINIMAL; /* FIXME: should be calculated */
- circuit->hello_interval[0] = (u_int16_t)interval;
- circuit->hello_interval[1] = (u_int16_t)interval;
-
+ circuit->hello_interval[0] = (u_int16_t) interval;
+ circuit->hello_interval[1] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1164,23 +1265,23 @@
"no isis hello-interval",
NO_STR
"IS-IS commands\n"
- "Set Hello interval\n"
- )
+ "Set Hello interval\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
- circuit->hello_interval[0] = HELLO_INTERVAL; /* Default is 1 sec. */
+
+ circuit->hello_interval[0] = HELLO_INTERVAL; /* Default is 1 sec. */
circuit->hello_interval[1] = HELLO_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1191,8 +1292,7 @@
"IS-IS commands\n"
"Set Hello interval\n"
"Hello interval value\n"
- "Holdtime 1 second, interval depends on multiplier\n"
- )
+ "Holdtime 1 second, interval depends on multiplier\n")
DEFUN (isis_hello_interval_l1,
isis_hello_interval_l1_cmd,
@@ -1201,29 +1301,31 @@
"Set Hello interval\n"
"Hello interval value\n"
"Holdtime 1 second, interval depends on multiplier\n"
- "Specify hello-interval for level-1 IIHs\n"
- )
+ "Specify hello-interval for level-1 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
long interval;
char c;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
c = *argv[0];
- if (isdigit((int)c)) {
- interval = atoi (argv[0]);
- } else
+ if (isdigit ((int) c))
+ {
+ interval = atoi (argv[0]);
+ }
+ else
interval = HELLO_MINIMAL;
- circuit->hello_interval[0] = (u_int16_t)interval;
-
+ circuit->hello_interval[0] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1233,22 +1335,22 @@
NO_STR
"IS-IS commands\n"
"Set Hello interval\n"
- "Specify hello-interval for level-1 IIHs\n"
- )
+ "Specify hello-interval for level-1 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
- circuit->hello_interval[0] = HELLO_INTERVAL; /* Default is 1 sec. */
-
+
+ circuit->hello_interval[0] = HELLO_INTERVAL; /* Default is 1 sec. */
+
return CMD_SUCCESS;
}
@@ -1260,8 +1362,7 @@
"Set Hello interval\n"
"Hello interval value\n"
"Holdtime 1 second, interval depends on multiplier\n"
- "Specify hello-interval for level-1 IIHs\n"
- )
+ "Specify hello-interval for level-1 IIHs\n")
DEFUN (isis_hello_interval_l2,
isis_hello_interval_l2_cmd,
@@ -1270,29 +1371,31 @@
"Set Hello interval\n"
"Hello interval value\n"
"Holdtime 1 second, interval depends on multiplier\n"
- "Specify hello-interval for level-2 IIHs\n"
- )
+ "Specify hello-interval for level-2 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
long interval;
char c;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
c = *argv[0];
- if (isdigit((int)c)) {
- interval = atoi (argv[0]);
- } else
+ if (isdigit ((int) c))
+ {
+ interval = atoi (argv[0]);
+ }
+ else
interval = HELLO_MINIMAL;
- circuit->hello_interval[1] = (u_int16_t)interval;
-
+ circuit->hello_interval[1] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1302,22 +1405,22 @@
NO_STR
"IS-IS commands\n"
"Set Hello interval\n"
- "Specify hello-interval for level-2 IIHs\n"
- )
+ "Specify hello-interval for level-2 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
- circuit->hello_interval[1] = HELLO_INTERVAL; /* Default is 1 sec. */
-
+
+ circuit->hello_interval[1] = HELLO_INTERVAL; /* Default is 1 sec. */
+
return CMD_SUCCESS;
}
@@ -1329,34 +1432,32 @@
"Set Hello interval\n"
"Hello interval value\n"
"Holdtime 1 second, interval depends on multiplier\n"
- "Specify hello-interval for level-2 IIHs\n"
- )
-
+ "Specify hello-interval for level-2 IIHs\n")
DEFUN (isis_hello_multiplier,
isis_hello_multiplier_cmd,
"isis hello-multiplier <3-1000>",
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
- "Hello multiplier value\n"
- )
+ "Hello multiplier value\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int mult;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
mult = atoi (argv[0]);
- circuit->hello_multiplier[0] = (u_int16_t)mult;
- circuit->hello_multiplier[1] = (u_int16_t)mult;
-
+ circuit->hello_multiplier[0] = (u_int16_t) mult;
+ circuit->hello_multiplier[1] = (u_int16_t) mult;
+
return CMD_SUCCESS;
}
@@ -1365,17 +1466,17 @@
"no isis hello-multiplier",
NO_STR
"IS-IS commands\n"
- "Set multiplier for Hello holding time\n"
- )
+ "Set multiplier for Hello holding time\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit->hello_multiplier[0] = HELLO_MULTIPLIER;
@@ -1390,8 +1491,7 @@
NO_STR
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
- "Hello multiplier value\n"
- )
+ "Hello multiplier value\n")
DEFUN (isis_hello_multiplier_l1,
isis_hello_multiplier_l1_cmd,
@@ -1399,24 +1499,24 @@
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
"Hello multiplier value\n"
- "Specify hello multiplier for level-1 IIHs\n"
- )
+ "Specify hello multiplier for level-1 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int mult;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
mult = atoi (argv[0]);
- circuit->hello_multiplier[0] = (u_int16_t)mult;
-
+ circuit->hello_multiplier[0] = (u_int16_t) mult;
+
return CMD_SUCCESS;
}
@@ -1426,17 +1526,17 @@
NO_STR
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
- "Specify hello multiplier for level-1 IIHs\n"
- )
+ "Specify hello multiplier for level-1 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit->hello_multiplier[0] = HELLO_MULTIPLIER;
@@ -1451,8 +1551,7 @@
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
"Hello multiplier value\n"
- "Specify hello multiplier for level-1 IIHs\n"
- )
+ "Specify hello multiplier for level-1 IIHs\n")
DEFUN (isis_hello_multiplier_l2,
isis_hello_multiplier_l2_cmd,
@@ -1460,24 +1559,24 @@
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
"Hello multiplier value\n"
- "Specify hello multiplier for level-2 IIHs\n"
- )
+ "Specify hello multiplier for level-2 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
int mult;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
mult = atoi (argv[0]);
- circuit->hello_multiplier[1] = (u_int16_t)mult;
-
+ circuit->hello_multiplier[1] = (u_int16_t) mult;
+
return CMD_SUCCESS;
}
@@ -1487,17 +1586,17 @@
NO_STR
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
- "Specify hello multiplier for level-2 IIHs\n"
- )
+ "Specify hello multiplier for level-2 IIHs\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
circuit->hello_multiplier[1] = HELLO_MULTIPLIER;
@@ -1512,8 +1611,7 @@
"IS-IS commands\n"
"Set multiplier for Hello holding time\n"
"Hello multiplier value\n"
- "Specify hello multiplier for level-2 IIHs\n"
- )
+ "Specify hello multiplier for level-2 IIHs\n")
DEFUN (isis_hello,
isis_hello_cmd,
@@ -1525,16 +1623,17 @@
{
struct interface *ifp;
struct isis_circuit *circuit;
-
- ifp = vty->index;
+
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->u.bc.pad_hellos = 1;
-
+
return CMD_SUCCESS;
}
@@ -1543,9 +1642,7 @@
ip_address_cmd,
"ip address A.B.C.D/A",
"Interface Internet Protocol config commands\n"
- "Set the IP address of an interface\n"
- "IP address (e.g. 10.0.0.1/8\n")
-
+ "Set the IP address of an interface\n" "IP address (e.g. 10.0.0.1/8\n")
{
struct interface *ifp;
struct isis_circuit *circuit;
@@ -1553,11 +1650,12 @@
struct listnode *node;
int ret, found = 1;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
#ifdef HAVE_IPV6
@@ -1565,32 +1663,36 @@
#endif /* HAVE_IPV6 */
ipv4 = prefix_ipv4_new ();
-
- ret = str2prefix_ipv4 (argv[0], ipv4);
- if (ret <= 0) {
- zlog_warn ("ip_address_cmd(): malformed address");
- vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
- if (!circuit->ip_addrs)
- circuit->ip_addrs = list_new ();
- else {
- for (node = listhead (circuit->ip_addrs); node; nextnode (node)) {
- ip = getdata (node);
- if (prefix_same ((struct prefix *)ip, (struct prefix *)ipv4))
- found = 1;
- }
- if (found) {
- prefix_ipv4_free (ipv4);
- return CMD_SUCCESS;
- }
- }
-
+ ret = str2prefix_ipv4 (argv[0], ipv4);
+ if (ret <= 0)
+ {
+ zlog_warn ("ip_address_cmd(): malformed address");
+ vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ if (!circuit->ip_addrs)
+ circuit->ip_addrs = list_new ();
+ else
+ {
+ for (node = listhead (circuit->ip_addrs); node; nextnode (node))
+ {
+ ip = getdata (node);
+ if (prefix_same ((struct prefix *) ip, (struct prefix *) ipv4))
+ found = 1;
+ }
+ if (found)
+ {
+ prefix_ipv4_free (ipv4);
+ return CMD_SUCCESS;
+ }
+ }
+
+
listnode_add (circuit->ip_addrs, ipv4);
-#ifdef EXTREME_DEBUG
- zlog_info ("added IP address %s to circuit %d", argv[0],
+#ifdef EXTREME_DEBUG
+ zlog_info ("added IP address %s to circuit %d", argv[0],
circuit->interface->ifindex);
#endif /* EXTREME_DEBUG */
return CMD_SUCCESS;
@@ -1610,36 +1712,43 @@
struct listnode *node;
int ret;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
/* UGLY - will remove l8r */
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
- if (!circuit->ip_addrs || circuit->ip_addrs->count == 0) {
- vty_out (vty, "Invalid address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!circuit->ip_addrs || circuit->ip_addrs->count == 0)
+ {
+ vty_out (vty, "Invalid address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
ret = str2prefix_ipv4 (argv[0], &ipv4);
- if (ret <= 0) {
- vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
- for (node = listhead (circuit->ip_addrs); node; nextnode (node)) {
- ip = getdata (node);
- if (prefix_same ((struct prefix *)ip, (struct prefix *)&ipv4))
- break;
- }
-
- if (ip) {
- listnode_delete (circuit->ip_addrs, ip);
- } else {
- vty_out (vty, "Invalid address %s", VTY_NEWLINE);
- }
-
+ if (ret <= 0)
+ {
+ vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ for (node = listhead (circuit->ip_addrs); node; nextnode (node))
+ {
+ ip = getdata (node);
+ if (prefix_same ((struct prefix *) ip, (struct prefix *) &ipv4))
+ break;
+ }
+
+ if (ip)
+ {
+ listnode_delete (circuit->ip_addrs, ip);
+ }
+ else
+ {
+ vty_out (vty, "Invalid address %s", VTY_NEWLINE);
+ }
+
return CMD_SUCCESS;
}
#endif
@@ -1656,15 +1765,16 @@
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->u.bc.pad_hellos = 0;
-
+
return CMD_SUCCESS;
}
@@ -1679,18 +1789,19 @@
struct interface *ifp;
unsigned long interval;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
interval = atol (argv[0]);
- circuit->csnp_interval[0] = (u_int16_t)interval;
- circuit->csnp_interval[1] = (u_int16_t)interval;
-
+ circuit->csnp_interval[0] = (u_int16_t) interval;
+ circuit->csnp_interval[1] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1699,22 +1810,22 @@
"no isis csnp-interval",
NO_STR
"IS-IS commands\n"
- "Set CSNP interval in seconds\n"
- )
+ "Set CSNP interval in seconds\n")
{
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->csnp_interval[0] = CSNP_INTERVAL;
circuit->csnp_interval[1] = CSNP_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1726,7 +1837,6 @@
"Set CSNP interval in seconds\n"
"CSNP interval value\n")
-
DEFUN (csnp_interval_l1,
csnp_interval_l1_cmd,
"isis csnp-interval <0-65535> level-1",
@@ -1739,17 +1849,18 @@
struct interface *ifp;
unsigned long interval;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
interval = atol (argv[0]);
-
- circuit->csnp_interval[0] = (u_int16_t)interval;
-
+
+ circuit->csnp_interval[0] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1764,15 +1875,16 @@
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->csnp_interval[0] = CSNP_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1785,7 +1897,6 @@
"CSNP interval value\n"
"Specify interval for level-1 CSNPs\n")
-
DEFUN (csnp_interval_l2,
csnp_interval_l2_cmd,
"isis csnp-interval <0-65535> level-2",
@@ -1798,17 +1909,18 @@
struct interface *ifp;
unsigned long interval;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
interval = atol (argv[0]);
-
- circuit->csnp_interval[1] = (u_int16_t)interval;
-
+
+ circuit->csnp_interval[1] = (u_int16_t) interval;
+
return CMD_SUCCESS;
}
@@ -1823,15 +1935,16 @@
struct isis_circuit *circuit;
struct interface *ifp;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
-
+
circuit->csnp_interval[1] = CSNP_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1844,7 +1957,6 @@
"CSNP interval value\n"
"Specify interval for level-2 CSNPs\n")
-
#ifdef HAVE_IPV6
DEFUN (ipv6_router_isis,
ipv6_router_isis_cmd,
@@ -1857,38 +1969,44 @@
struct isis_circuit *c;
struct interface *ifp;
struct isis_area *area;
-
- ifp = (struct interface *)vty->index;
+
+ ifp = (struct interface *) vty->index;
assert (ifp);
-
+
area = isis_area_lookup (argv[0]);
/* Prevent more than one circuit per interface */
if (area)
c = circuit_lookup_by_ifp (ifp, area->circuit_list);
- else c = NULL;
-
- if (c && (ifp->info != NULL)) {
- if (c->ipv6_router == 1) {
- vty_out (vty, "ISIS circuit is already defined for IPv6%s", VTY_NEWLINE);
- return CMD_WARNING;
+ else
+ c = NULL;
+
+ if (c && (ifp->info != NULL))
+ {
+ if (c->ipv6_router == 1)
+ {
+ vty_out (vty, "ISIS circuit is already defined for IPv6%s",
+ VTY_NEWLINE);
+ return CMD_WARNING;
+ }
}
- }
/* this is here for ciscopability */
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
- if (!c) {
- c = circuit_lookup_by_ifp (ifp, isis->init_circ_list);
- c = isis_csm_state_change (ISIS_ENABLE, c, area);
- c->interface = ifp;
- ifp->info = c;
- }
+ if (!c)
+ {
+ c = circuit_lookup_by_ifp (ifp, isis->init_circ_list);
+ c = isis_csm_state_change (ISIS_ENABLE, c, area);
+ c->interface = ifp;
+ ifp->info = c;
+ }
- if(!c)
+ if (!c)
return CMD_WARNING;
c->ipv6_router = 1;
@@ -1912,20 +2030,21 @@
struct isis_circuit *c;
struct interface *ifp;
struct isis_area *area;
-
- ifp = (struct interface *)vty->index;
+
+ ifp = (struct interface *) vty->index;
/* UGLY - will remove l8r
if (circuit == NULL) {
- return CMD_WARNING;
- } */
+ return CMD_WARNING;
+ } */
assert (ifp);
-
+
area = isis_area_lookup (argv[0]);
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
c = circuit_lookup_by_ifp (ifp, area->circuit_list);
if (!c)
return CMD_WARNING;
@@ -1938,7 +2057,7 @@
return CMD_SUCCESS;
}
-#if 0 /* Guess we don't really need these */
+#if 0 /* Guess we don't really need these */
DEFUN (ipv6_address,
ipv6_address_cmd,
@@ -1953,46 +2072,52 @@
struct listnode *node;
int ret, found = 1;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
/* UGLY - will remove l8r */
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
#ifdef EXTREME_DEBUG
zlog_info ("ipv6_address_cmd circuit %d", circuit->idx);
#endif /* EXTREME_DEBUG */
-
- if (circuit == NULL) {
- zlog_warn ("ipv6_address_cmd(): no circuit");
- return CMD_WARNING;
- }
-
-
- ipv6 = prefix_ipv6_new ();
-
- ret = str2prefix_ipv6 (argv[0], ipv6);
- if (ret <= 0) {
- vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
- if (!circuit->ipv6_addrs)
- circuit->ipv6_addrs = list_new ();
- else {
- for (node = listhead (circuit->ipv6_addrs); node; nextnode (node)) {
- ip6 = getdata (node);
- if (prefix_same ((struct prefix *)ip6, (struct prefix *)ipv6))
- found = 1;
- }
- if (found) {
- prefix_ipv6_free (ipv6);
- return CMD_SUCCESS;
- }
- }
-
+ if (circuit == NULL)
+ {
+ zlog_warn ("ipv6_address_cmd(): no circuit");
+ return CMD_WARNING;
+ }
+
+
+ ipv6 = prefix_ipv6_new ();
+
+ ret = str2prefix_ipv6 (argv[0], ipv6);
+ if (ret <= 0)
+ {
+ vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ if (!circuit->ipv6_addrs)
+ circuit->ipv6_addrs = list_new ();
+ else
+ {
+ for (node = listhead (circuit->ipv6_addrs); node; nextnode (node))
+ {
+ ip6 = getdata (node);
+ if (prefix_same ((struct prefix *) ip6, (struct prefix *) ipv6))
+ found = 1;
+ }
+ if (found)
+ {
+ prefix_ipv6_free (ipv6);
+ return CMD_SUCCESS;
+ }
+ }
+
+
listnode_add (circuit->ipv6_addrs, ipv6);
#ifdef EXTREME_DEBUG
zlog_info ("added IPv6 address %s to circuit %d", argv[0], circuit->idx);
@@ -2003,7 +2128,7 @@
DEFUN (no_ipv6_address,
no_ipv6_address_cmd,
- "no ipv6 address X:X::X:X/M",
+ "no ipv6 address X:X::X:X/M",
NO_STR
"Interface Internet Protocol config commands\n"
"Set the IP address of an interface\n"
@@ -2015,50 +2140,54 @@
struct listnode *node;
int ret;
- ifp = vty->index;
+ ifp = vty->index;
circuit = ifp->info;
/* UGLY - will remove l8r */
- if (circuit == NULL) {
- return CMD_WARNING;
- }
+ if (circuit == NULL)
+ {
+ return CMD_WARNING;
+ }
assert (circuit);
- if (!circuit->ipv6_addrs || circuit->ipv6_addrs->count == 0) {
- vty_out (vty, "Invalid address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!circuit->ipv6_addrs || circuit->ipv6_addrs->count == 0)
+ {
+ vty_out (vty, "Invalid address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
ret = str2prefix_ipv6 (argv[0], &ipv6);
- if (ret <= 0) {
- vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
- for (node = listhead (circuit->ipv6_addrs); node; nextnode (node)) {
- ip6 = getdata (node);
- if (prefix_same ((struct prefix *)ip6, (struct prefix *)&ipv6))
- break;
- }
-
- if (ip6) {
- listnode_delete (circuit->ipv6_addrs, ip6);
- } else {
- vty_out (vty, "Invalid address %s", VTY_NEWLINE);
- }
-
+ if (ret <= 0)
+ {
+ vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ for (node = listhead (circuit->ipv6_addrs); node; nextnode (node))
+ {
+ ip6 = getdata (node);
+ if (prefix_same ((struct prefix *) ip6, (struct prefix *) &ipv6))
+ break;
+ }
+
+ if (ip6)
+ {
+ listnode_delete (circuit->ipv6_addrs, ip6);
+ }
+ else
+ {
+ vty_out (vty, "Invalid address %s", VTY_NEWLINE);
+ }
+
return CMD_SUCCESS;
}
#endif /* 0 */
-#endif /* HAVE_IPV6 */
+#endif /* HAVE_IPV6 */
-
-struct cmd_node interface_node =
-{
+struct cmd_node interface_node = {
INTERFACE_NODE,
"%s(config-if)# ",
1,
};
-
int
isis_if_new_hook (struct interface *ifp)
{
@@ -2077,11 +2206,9 @@
return 0;
}
-
void
isis_circuit_init ()
{
-
/* Initialize Zebra interface data structure */
if_init ();
if_add_hook (IF_NEW_HOOK, isis_if_new_hook);
@@ -2162,5 +2289,4 @@
install_element (INTERFACE_NODE, &no_ipv6_address_cmd);
#endif
#endif
-
}
diff --git a/isisd/isis_circuit.h b/isisd/isis_circuit.h
index 7163c5b..484c057 100644
--- a/isisd/isis_circuit.h
+++ b/isisd/isis_circuit.h
@@ -25,134 +25,139 @@
#define CIRCUIT_MAX 255
-struct password {
+struct password
+{
struct password *next;
- int len;
- u_char *pass;
+ int len;
+ u_char *pass;
};
-struct metric {
+struct metric
+{
u_char metric_default;
u_char metric_error;
u_char metric_expense;
u_char metric_delay;
};
-struct isis_bcast_info {
- u_char snpa [ETH_ALEN]; /* SNPA of this circuit */
- char run_dr_elect[2]; /* Should we run dr election ? */
- struct thread *t_run_dr[2]; /* DR election thread */
- struct thread *t_send_lan_hello[2]; /* send LAN IIHs in this thread */
- struct list *adjdb[2]; /* adjacency dbs */
- struct list *lan_neighs[2]; /* list of lx neigh snpa */
- char is_dr[2]; /* Are we level x DR ? */
- u_char l1_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-1 DR */
- u_char l2_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-2 DR */
- struct thread *t_refresh_pseudo_lsp[2]; /* refresh pseudo-node LSPs */
- int pad_hellos; /* add padding to Hello PDUs ? */
- u_char priority[2]; /* l1/2 IS Priority */
+struct isis_bcast_info
+{
+ u_char snpa[ETH_ALEN]; /* SNPA of this circuit */
+ char run_dr_elect[2]; /* Should we run dr election ? */
+ struct thread *t_run_dr[2]; /* DR election thread */
+ struct thread *t_send_lan_hello[2]; /* send LAN IIHs in this thread */
+ struct list *adjdb[2]; /* adjacency dbs */
+ struct list *lan_neighs[2]; /* list of lx neigh snpa */
+ char is_dr[2]; /* Are we level x DR ? */
+ u_char l1_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-1 DR */
+ u_char l2_desig_is[ISIS_SYS_ID_LEN + 1]; /* level-2 DR */
+ struct thread *t_refresh_pseudo_lsp[2]; /* refresh pseudo-node LSPs */
+ int pad_hellos; /* add padding to Hello PDUs ? */
+ u_char priority[2]; /* l1/2 IS Priority */
};
-struct isis_p2p_info {
- struct isis_adjacency *neighbor;
- struct thread *t_send_p2p_hello; /* send P2P IIHs in this thread */
+struct isis_p2p_info
+{
+ struct isis_adjacency *neighbor;
+ struct thread *t_send_p2p_hello; /* send P2P IIHs in this thread */
};
-struct isis_circuit {
+struct isis_circuit
+{
int state;
- u_char circuit_id; /* l1/l2 p2p/bcast CircuitID */
- struct isis_area *area; /* back pointer to the area */
- struct interface *interface; /* interface info from z */
- int fd; /* IS-IS l1/2 socket */
- struct nlpids nlpids;
+ u_char circuit_id; /* l1/l2 p2p/bcast CircuitID */
+ struct isis_area *area; /* back pointer to the area */
+ struct interface *interface; /* interface info from z */
+ int fd; /* IS-IS l1/2 socket */
+ struct nlpids nlpids;
/*
* Threads
*/
struct thread *t_read;
struct thread *t_send_csnp[2];
struct thread *t_send_psnp[2];
- struct list *lsp_queue; /* LSPs to be txed (both levels) */
+ struct list *lsp_queue; /* LSPs to be txed (both levels) */
/* there is no real point in two streams, just for programming kicker */
- int (* rx) (struct isis_circuit *circuit, u_char *ssnpa);
- struct stream *rcv_stream; /* Stream for receiving */
- int (* tx) (struct isis_circuit *circuit, int level);
- struct stream *snd_stream; /* Stream for sending */
- int idx; /* idx in S[RM|SN] flags */
-#define CIRCUIT_T_BROADCAST 0
+ int (*rx) (struct isis_circuit * circuit, u_char * ssnpa);
+ struct stream *rcv_stream; /* Stream for receiving */
+ int (*tx) (struct isis_circuit * circuit, int level);
+ struct stream *snd_stream; /* Stream for sending */
+ int idx; /* idx in S[RM|SN] flags */
+#define CIRCUIT_T_BROADCAST 0
#define CIRCUIT_T_P2P 1
#define CIRCUIT_T_STATIC_IN 2
#define CIRCUIT_T_STATIC_OUT 3
#define CIRCUIT_T_DA 4
- int circ_type; /* type of the physical interface */
- union {
+ int circ_type; /* type of the physical interface */
+ union
+ {
struct isis_bcast_info bc;
struct isis_p2p_info p2p;
} u;
- char ext_domain; /* externalDomain (boolean) */
+ char ext_domain; /* externalDomain (boolean) */
/*
* Configurables
*/
- struct isis_passwd passwd; /* Circuit rx/tx password */
- long lsp_interval;
- int manual_l2_only; /* manualL2OnlyMode (boolean) */
- int circuit_is_type; /* circuit is type == level of circuit
- * diffrenciated from circuit type (media) */
- u_int32_t hello_interval[2]; /* l1HelloInterval in msecs */
- u_int16_t hello_multiplier[2]; /* l1HelloMultiplier */
- u_int16_t csnp_interval[2]; /* level-1 csnp-interval in seconds */
- u_int16_t psnp_interval[2]; /* level-1 psnp-interval in seconds */
- struct metric metrics[2]; /* l1XxxMetric */
- struct password *c_rx_passwds; /* circuitReceivePasswords */
- struct password *c_tc_passwd; /* circuitTransmitPassword */
- int ip_router; /* Route IP ? */
- struct list *ip_addrs; /* our IP addresses */
+ struct isis_passwd passwd; /* Circuit rx/tx password */
+ long lsp_interval;
+ int manual_l2_only; /* manualL2OnlyMode (boolean) */
+ int circuit_is_type; /* circuit is type == level of circuit
+ * diffrenciated from circuit type (media) */
+ u_int32_t hello_interval[2]; /* l1HelloInterval in msecs */
+ u_int16_t hello_multiplier[2]; /* l1HelloMultiplier */
+ u_int16_t csnp_interval[2]; /* level-1 csnp-interval in seconds */
+ u_int16_t psnp_interval[2]; /* level-1 psnp-interval in seconds */
+ struct metric metrics[2]; /* l1XxxMetric */
+ struct password *c_rx_passwds; /* circuitReceivePasswords */
+ struct password *c_tc_passwd; /* circuitTransmitPassword */
+ int ip_router; /* Route IP ? */
+ struct list *ip_addrs; /* our IP addresses */
#ifdef HAVE_IPV6
- int ipv6_router; /* Route IPv6 ? */
- struct list *ipv6_link; /* our link local IPv6 addresses */
- struct list *ipv6_non_link; /* our non-link local IPv6 addresses */
-#endif /* HAVE_IPV6 */
+ int ipv6_router; /* Route IPv6 ? */
+ struct list *ipv6_link; /* our link local IPv6 addresses */
+ struct list *ipv6_non_link; /* our non-link local IPv6 addresses */
+#endif /* HAVE_IPV6 */
/*
* RFC 2973 IS-IS Mesh Groups
*/
#define MESH_INACTIVE 0
#define MESH_BLOCKED 1
#define MESH_SET 2
- int mesh_enabled; /* meshGroupEnabled */
- u_int16_t mesh_group; /* meshGroup */
+ int mesh_enabled; /* meshGroupEnabled */
+ u_int16_t mesh_group; /* meshGroup */
u_int16_t upadjcount[2];
/*
* Counters as in 10589--11.2.5.9
*/
- u_int32_t adj_state_changes; /* changesInAdjacencyState */
- u_int32_t init_failures; /* intialisationFailures */
- u_int32_t ctrl_pdus_rxed; /* controlPDUsReceived */
- u_int32_t ctrl_pdus_txed; /* controlPDUsSent */
- u_int32_t desig_changes[2]; /* lanLxDesignatedIntermediateSystemChanges*/
- u_int32_t rej_adjacencies; /* rejectedAdjacencies */
+ u_int32_t adj_state_changes; /* changesInAdjacencyState */
+ u_int32_t init_failures; /* intialisationFailures */
+ u_int32_t ctrl_pdus_rxed; /* controlPDUsReceived */
+ u_int32_t ctrl_pdus_txed; /* controlPDUsSent */
+ u_int32_t desig_changes[2]; /* lanLxDesignatedIntermediateSystemChanges */
+ u_int32_t rej_adjacencies; /* rejectedAdjacencies */
};
+void isis_circuit_init (void);
+struct isis_circuit *isis_circuit_new (void);
+struct isis_circuit *circuit_lookup_by_ifp (struct interface *ifp,
+ struct list *list);
+struct isis_circuit *circuit_scan_by_ifp (struct interface *ifp);
+void isis_circuit_del (struct isis_circuit *circuit);
+void isis_circuit_configure (struct isis_circuit *circuit,
+ struct isis_area *area);
+void isis_circuit_up (struct isis_circuit *circuit);
+void isis_circuit_deconfigure (struct isis_circuit *circuit,
+ struct isis_area *area);
-void isis_circuit_init (void);
-struct isis_circuit *isis_circuit_new (void);
-struct isis_circuit *circuit_lookup_by_ifp (struct interface *ifp,
- struct list *list);
-struct isis_circuit *circuit_scan_by_ifp (struct interface *ifp);
-void isis_circuit_del (struct isis_circuit *circuit);
-void isis_circuit_configure (struct isis_circuit *circuit,
- struct isis_area *area);
-void isis_circuit_up (struct isis_circuit *circuit);
-void isis_circuit_deconfigure (struct isis_circuit *circuit,
- struct isis_area *area);
-
-int isis_circuit_destroy (struct isis_circuit *circuit);
-void isis_circuit_if_add (struct isis_circuit *circuit,
- struct interface *ifp);
-void isis_circuit_if_del (struct isis_circuit *circuit);
-void circuit_update_nlpids (struct isis_circuit *circuit);
-void isis_circuit_update_params (struct isis_circuit *circuit,
- struct interface *ifp);
-void isis_circuit_add_addr (struct isis_circuit *circuit,
- struct connected *conn);
-void isis_circuit_del_addr (struct isis_circuit *circuit,
- struct connected *conn);
+int isis_circuit_destroy (struct isis_circuit *circuit);
+void isis_circuit_if_add (struct isis_circuit *circuit,
+ struct interface *ifp);
+void isis_circuit_if_del (struct isis_circuit *circuit);
+void circuit_update_nlpids (struct isis_circuit *circuit);
+void isis_circuit_update_params (struct isis_circuit *circuit,
+ struct interface *ifp);
+void isis_circuit_add_addr (struct isis_circuit *circuit,
+ struct connected *conn);
+void isis_circuit_del_addr (struct isis_circuit *circuit,
+ struct connected *conn);
#endif /* _ZEBRA_ISIS_CIRCUIT_H */
diff --git a/isisd/isis_common.h b/isisd/isis_common.h
index 951e637..7a0768a 100644
--- a/isisd/isis_common.h
+++ b/isisd/isis_common.h
@@ -23,13 +23,15 @@
/*
* Area Address
- */
-struct area_addr {
- u_char addr_len;
- u_char area_addr[20];
+ */
+struct area_addr
+{
+ u_char addr_len;
+ u_char area_addr[20];
};
-struct isis_passwd {
+struct isis_passwd
+{
u_char len;
#define ISIS_PASSWD_TYPE_UNUSED 0
#define ISIS_PASSWD_TYPE_CLEARTXT 1
@@ -43,7 +45,8 @@
* one struct for cache list
* one struct for LSP TLV
*/
-struct hostname {
+struct hostname
+{
u_char namelen;
u_char name[255];
};
@@ -51,15 +54,17 @@
/*
* Supported Protocol IDs
*/
-struct nlpids {
+struct nlpids
+{
u_char count;
- u_char nlpids[4]; /* FIXME: enough ? */
+ u_char nlpids[4]; /* FIXME: enough ? */
};
/*
* Flags structure for SSN and SRM flags
- */
-struct flags {
+ */
+struct flags
+{
int maxindex;
struct list *free_idcs;
};
diff --git a/isisd/isis_constants.h b/isisd/isis_constants.h
index c732bfc..1b75ba6 100644
--- a/isisd/isis_constants.h
+++ b/isisd/isis_constants.h
@@ -25,9 +25,9 @@
/*
* Architectural constant values from p. 35 of ISO/IEC 10589
- */
+ */
-#define MAX_LINK_METRIC 63
+#define MAX_LINK_METRIC 63
#define MAX_PATH_METRIC 1023
#define ISO_SAP 0xFE
#define INTRADOMAIN_ROUTEING_SELECTOR 0
@@ -38,11 +38,11 @@
* implementation specific jitter values
*/
-#define IIH_JITTER 25 /* % */
-#define MAX_AGE_JITTER 5 /* % */
-#define MAX_LSP_GEN_JITTER 5 /* % */
-#define CSNP_JITTER 10 /* % */
-#define PSNP_JITTER 10 /* % */
+#define IIH_JITTER 25 /* % */
+#define MAX_AGE_JITTER 5 /* % */
+#define MAX_LSP_GEN_JITTER 5 /* % */
+#define CSNP_JITTER 10 /* % */
+#define PSNP_JITTER 10 /* % */
#define RANDOM_SPREAD 100000.0
@@ -70,12 +70,12 @@
#define HELLO_MULTIPLIER 3
#define DEFAULT_PRIORITY 64
/* different vendors implement different values 5-10 on average */
-#define LSP_GEN_INTERVAL_DEFAULT 10
-#define LSP_INTERVAL 33 /* msecs */
+#define LSP_GEN_INTERVAL_DEFAULT 10
+#define LSP_INTERVAL 33 /* msecs */
#define DEFAULT_CIRCUIT_METRICS 10
#define METRICS_UNSUPPORTED 0x80
-#define PERIODIC_SPF_INTERVAL 60 /* at the top of my head */
-#define MINIMUM_SPF_INTERVAL 5 /* .. same here */
+#define PERIODIC_SPF_INTERVAL 60 /* at the top of my head */
+#define MINIMUM_SPF_INTERVAL 5 /* .. same here */
/*
* NLPID values
@@ -143,12 +143,4 @@
#define ETH_ALEN 6
#endif
-#endif /* ISIS_CONSTANTS_H */
-
-
-
-
-
-
-
-
+#endif /* ISIS_CONSTANTS_H */
diff --git a/isisd/isis_csm.c b/isisd/isis_csm.c
index b205790..8f44db1 100644
--- a/isisd/isis_csm.c
+++ b/isisd/isis_csm.c
@@ -52,8 +52,7 @@
extern struct isis *isis;
-static char *csm_statestr[] =
-{
+static char *csm_statestr[] = {
"C_STATE_NA",
"C_STATE_INIT",
"C_STATE_CONF",
@@ -62,8 +61,7 @@
#define STATE2STR(S) csm_statestr[S]
-static char *csm_eventstr[] =
-{
+static char *csm_eventstr[] = {
"NO_STATE",
"ISIS_ENABLE",
"IF_UP_FROM_Z",
@@ -73,113 +71,113 @@
#define EVENT2STR(E) csm_eventstr[E]
-
-struct isis_circuit*
-isis_csm_state_change (int event, struct isis_circuit *circuit,
- void *arg)
+struct isis_circuit *
+isis_csm_state_change (int event, struct isis_circuit *circuit, void *arg)
{
int old_state;
old_state = circuit ? circuit->state : C_STATE_NA;
-
- zlog_info ("CSM_EVENT: %s", EVENT2STR(event));
-
- switch (old_state) {
- case C_STATE_NA:
- if (circuit)
- zlog_warn ("Non-null circuit while state C_STATE_NA");
- switch (event) {
- case ISIS_ENABLE:
- circuit = isis_circuit_new ();
- isis_circuit_configure (circuit, (struct isis_area *)arg);
- circuit->state = C_STATE_CONF;
+
+ zlog_info ("CSM_EVENT: %s", EVENT2STR (event));
+
+ switch (old_state)
+ {
+ case C_STATE_NA:
+ if (circuit)
+ zlog_warn ("Non-null circuit while state C_STATE_NA");
+ switch (event)
+ {
+ case ISIS_ENABLE:
+ circuit = isis_circuit_new ();
+ isis_circuit_configure (circuit, (struct isis_area *) arg);
+ circuit->state = C_STATE_CONF;
+ break;
+ case IF_UP_FROM_Z:
+ circuit = isis_circuit_new ();
+ isis_circuit_if_add (circuit, (struct interface *) arg);
+ listnode_add (isis->init_circ_list, circuit);
+ circuit->state = C_STATE_INIT;
+ break;
+ case ISIS_DISABLE:
+ zlog_warn ("circuit already disabled");
+ case IF_DOWN_FROM_Z:
+ zlog_warn ("circuit already disconnected");
+ break;
+ }
break;
- case IF_UP_FROM_Z:
- circuit = isis_circuit_new ();
- isis_circuit_if_add (circuit, (struct interface *)arg);
- listnode_add (isis->init_circ_list, circuit);
- circuit->state = C_STATE_INIT;
+ case C_STATE_INIT:
+ switch (event)
+ {
+ case ISIS_ENABLE:
+ isis_circuit_configure (circuit, (struct isis_area *) arg);
+ isis_circuit_up (circuit);
+ circuit->state = C_STATE_UP;
+ isis_event_circuit_state_change (circuit, 1);
+ listnode_delete (isis->init_circ_list, circuit);
+ break;
+ case IF_UP_FROM_Z:
+ zlog_warn ("circuit already connected");
+ break;
+ case ISIS_DISABLE:
+ zlog_warn ("circuit already disabled");
+ break;
+ case IF_DOWN_FROM_Z:
+ isis_circuit_if_del (circuit);
+ listnode_delete (isis->init_circ_list, circuit);
+ isis_circuit_del (circuit);
+ break;
+ }
break;
- case ISIS_DISABLE:
- zlog_warn ("circuit already disabled");
- case IF_DOWN_FROM_Z:
- zlog_warn ("circuit already disconnected");
+ case C_STATE_CONF:
+ switch (event)
+ {
+ case ISIS_ENABLE:
+ zlog_warn ("circuit already enabled");
+ break;
+ case IF_UP_FROM_Z:
+ isis_circuit_if_add (circuit, (struct interface *) arg);
+ isis_circuit_up (circuit);
+ circuit->state = C_STATE_UP;
+ isis_event_circuit_state_change (circuit, 1);
+ break;
+ case ISIS_DISABLE:
+ isis_circuit_deconfigure (circuit, (struct isis_area *) arg);
+ isis_circuit_del (circuit);
+ break;
+ case IF_DOWN_FROM_Z:
+ zlog_warn ("circuit already disconnected");
+ break;
+ }
break;
+ case C_STATE_UP:
+ switch (event)
+ {
+ case ISIS_ENABLE:
+ zlog_warn ("circuit already configured");
+ break;
+ case IF_UP_FROM_Z:
+ zlog_warn ("circuit already connected");
+ break;
+ case ISIS_DISABLE:
+ isis_circuit_deconfigure (circuit, (struct isis_area *) arg);
+ listnode_add (isis->init_circ_list, circuit);
+ circuit->state = C_STATE_INIT;
+ isis_event_circuit_state_change (circuit, 0);
+ break;
+ case IF_DOWN_FROM_Z:
+ isis_circuit_if_del (circuit);
+ circuit->state = C_STATE_CONF;
+ isis_event_circuit_state_change (circuit, 0);
+ break;
+ }
+ break;
+
+ default:
+ zlog_warn ("Invalid circuit state %d", old_state);
}
- break;
- case C_STATE_INIT:
- switch (event) {
- case ISIS_ENABLE:
- isis_circuit_configure (circuit, (struct isis_area *)arg);
- isis_circuit_up (circuit);
- circuit->state = C_STATE_UP;
- isis_event_circuit_state_change (circuit, 1);
- listnode_delete (isis->init_circ_list, circuit);
- break;
- case IF_UP_FROM_Z:
- zlog_warn ("circuit already connected");
- break;
- case ISIS_DISABLE:
- zlog_warn ("circuit already disabled");
- break;
- case IF_DOWN_FROM_Z:
- isis_circuit_if_del (circuit);
- listnode_delete (isis->init_circ_list, circuit);
- isis_circuit_del (circuit);
- break;
- }
- break;
- case C_STATE_CONF:
- switch (event) {
- case ISIS_ENABLE:
- zlog_warn ("circuit already enabled");
- break;
- case IF_UP_FROM_Z:
- isis_circuit_if_add (circuit, (struct interface *)arg);
- isis_circuit_up (circuit);
- circuit->state = C_STATE_UP;
- isis_event_circuit_state_change (circuit, 1);
- break;
- case ISIS_DISABLE:
- isis_circuit_deconfigure (circuit, (struct isis_area *)arg);
- isis_circuit_del (circuit);
- break;
- case IF_DOWN_FROM_Z:
- zlog_warn ("circuit already disconnected");
- break;
- }
- break;
- case C_STATE_UP:
- switch (event) {
- case ISIS_ENABLE:
- zlog_warn ("circuit already configured");
- break;
- case IF_UP_FROM_Z:
- zlog_warn ("circuit already connected");
- break;
- case ISIS_DISABLE:
- isis_circuit_deconfigure (circuit, (struct isis_area *)arg);
- listnode_add (isis->init_circ_list, circuit);
- circuit->state = C_STATE_INIT;
- isis_event_circuit_state_change (circuit, 0);
- break;
- case IF_DOWN_FROM_Z:
- isis_circuit_if_del (circuit);
- circuit->state = C_STATE_CONF;
- isis_event_circuit_state_change (circuit, 0);
- break;
- }
- break;
-
- default:
- zlog_warn ("Invalid circuit state %d", old_state);
- }
-
- zlog_info ("CSM_STATE_CHANGE: %s -> %s ", STATE2STR (old_state),
- circuit ? STATE2STR (circuit->state) : STATE2STR (C_STATE_NA));
+
+ zlog_info ("CSM_STATE_CHANGE: %s -> %s ", STATE2STR (old_state),
+ circuit ? STATE2STR (circuit->state) : STATE2STR (C_STATE_NA));
return circuit;
}
-
-
-
diff --git a/isisd/isis_csm.h b/isisd/isis_csm.h
index 23cc215..d6b13ac 100644
--- a/isisd/isis_csm.h
+++ b/isisd/isis_csm.h
@@ -28,9 +28,9 @@
* Circuit states
*/
#define C_STATE_NA 0
-#define C_STATE_INIT 1 /* Connected to interface */
-#define C_STATE_CONF 2 /* Configured for ISIS */
-#define C_STATE_UP 3 /* CONN | CONF */
+#define C_STATE_INIT 1 /* Connected to interface */
+#define C_STATE_CONF 2 /* Configured for ISIS */
+#define C_STATE_UP 3 /* CONN | CONF */
/*
* Circuit events
@@ -40,8 +40,8 @@
#define ISIS_DISABLE 3
#define IF_DOWN_FROM_Z 4
-struct isis_circuit *isis_csm_state_change (int event,
- struct isis_circuit *circuit,
- void *arg);
+struct isis_circuit *isis_csm_state_change (int event,
+ struct isis_circuit *circuit,
+ void *arg);
#endif /* _ZEBRA_ISIS_CSM_H */
diff --git a/isisd/isis_dr.c b/isisd/isis_dr.c
index a2fddcc..b44d212 100644
--- a/isisd/isis_dr.c
+++ b/isisd/isis_dr.c
@@ -51,37 +51,37 @@
extern struct thread_master *master;
char *
-isis_disflag2string (int disflag) {
+isis_disflag2string (int disflag)
+{
- switch (disflag) {
+ switch (disflag)
+ {
case ISIS_IS_NOT_DIS:
return "is not DIS";
case ISIS_IS_DIS:
return "is DIS";
case ISIS_WAS_DIS:
return "was DIS";
- default:
- return "unknown DIS state";
- }
- return NULL; /* not reached */
+ default:
+ return "unknown DIS state";
+ }
+ return NULL; /* not reached */
}
-
-
int
isis_run_dr_l1 (struct thread *thread)
{
struct isis_circuit *circuit;
-
+
circuit = THREAD_ARG (thread);
assert (circuit);
if (circuit->u.bc.run_dr_elect[0])
zlog_warn ("isis_run_dr(): run_dr_elect already set for l1");
-
+
circuit->u.bc.t_run_dr[0] = NULL;
circuit->u.bc.run_dr_elect[0] = 1;
-
+
return ISIS_OK;
}
@@ -89,17 +89,17 @@
isis_run_dr_l2 (struct thread *thread)
{
struct isis_circuit *circuit;
-
+
circuit = THREAD_ARG (thread);
assert (circuit);
if (circuit->u.bc.run_dr_elect[1])
zlog_warn ("isis_run_dr(): run_dr_elect already set for l2");
-
-
- circuit->u.bc.t_run_dr[1] = NULL;
+
+
+ circuit->u.bc.t_run_dr[1] = NULL;
circuit->u.bc.run_dr_elect[1] = 1;
-
+
return ISIS_OK;
}
@@ -108,24 +108,25 @@
{
int i;
- if ( adj->dis_record[level-1].dis !=
- adj->dis_record[(1*ISIS_LEVELS) + level - 1].dis)
- /* was there a DIS state transition ? */
+ if (adj->dis_record[level - 1].dis !=
+ adj->dis_record[(1 * ISIS_LEVELS) + level - 1].dis)
+ /* was there a DIS state transition ? */
{
- adj->dischanges[level-1]++;
+ adj->dischanges[level - 1]++;
/* ok rotate the history list through */
- for (i = DIS_RECORDS - 1; i > 0; i--)
+ for (i = DIS_RECORDS - 1; i > 0; i--)
{
- adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
- adj->dis_record[((i-1) * ISIS_LEVELS) + level - 1].dis;
- adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change =
- adj->dis_record[((i-1) * ISIS_LEVELS) + level - 1].last_dis_change;
+ adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
+ adj->dis_record[((i - 1) * ISIS_LEVELS) + level - 1].dis;
+ adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change =
+ adj->dis_record[((i - 1) * ISIS_LEVELS) + level -
+ 1].last_dis_change;
}
}
return ISIS_OK;
}
-int
+int
isis_dr_elect (struct isis_circuit *circuit, int level)
{
struct list *adjdb;
@@ -135,213 +136,242 @@
u_char own_prio;
int biggest_prio = -1;
int cmp_res, retval = ISIS_OK;
-
+
own_prio = circuit->u.bc.priority[level - 1];
adjdb = circuit->u.bc.adjdb[level - 1];
- if (!adjdb) {
- zlog_warn ("isis_dr_elect() adjdb == NULL");
- retval = ISIS_WARNING;
- list_delete (list);
- goto out;
- }
+ if (!adjdb)
+ {
+ zlog_warn ("isis_dr_elect() adjdb == NULL");
+ retval = ISIS_WARNING;
+ list_delete (list);
+ goto out;
+ }
isis_adj_build_up_list (adjdb, list);
/*
* Loop the adjacencies and find the one with the biggest priority
*/
- for (node = listhead (list); node; nextnode (node)) {
- adj = getdata (node);
- /* clear flag for show output */
- adj->dis_record[level-1].dis = ISIS_IS_NOT_DIS;
- adj->dis_record[level-1].last_dis_change = time (NULL);
+ for (node = listhead (list); node; nextnode (node))
+ {
+ adj = getdata (node);
+ /* clear flag for show output */
+ adj->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
+ adj->dis_record[level - 1].last_dis_change = time (NULL);
- if (adj->prio[level-1] > biggest_prio) {
- biggest_prio = adj->prio[level-1];
- adj_dr = adj;
- } else if (adj->prio[level-1] == biggest_prio) {
- /*
- * Comparison of MACs breaks a tie
- */
- if (adj_dr) {
- cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN);
- if (cmp_res < 0) {
- adj_dr = adj;
+ if (adj->prio[level - 1] > biggest_prio)
+ {
+ biggest_prio = adj->prio[level - 1];
+ adj_dr = adj;
}
- if (cmp_res == 0)
- zlog_warn ("isis_dr_elect(): multiple adjacencies with same SNPA");
- } else {
- adj_dr = adj;
- }
+ else if (adj->prio[level - 1] == biggest_prio)
+ {
+ /*
+ * Comparison of MACs breaks a tie
+ */
+ if (adj_dr)
+ {
+ cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN);
+ if (cmp_res < 0)
+ {
+ adj_dr = adj;
+ }
+ if (cmp_res == 0)
+ zlog_warn
+ ("isis_dr_elect(): multiple adjacencies with same SNPA");
+ }
+ else
+ {
+ adj_dr = adj;
+ }
+ }
}
- }
-
- if (!adj_dr) {
- /*
- * Could not find the DR - means we are alone and thus the DR
- */
- if ( !circuit->u.bc.is_dr[level - 1]) {
- list_delete (list);
- list = NULL;
- return isis_dr_commence (circuit, level);
+
+ if (!adj_dr)
+ {
+ /*
+ * Could not find the DR - means we are alone and thus the DR
+ */
+ if (!circuit->u.bc.is_dr[level - 1])
+ {
+ list_delete (list);
+ list = NULL;
+ return isis_dr_commence (circuit, level);
+ }
+ goto out;
}
- goto out;
- }
/*
* Now we have the DR adjacency, compare it to self
*/
- if (adj_dr->prio[level-1] < own_prio || (adj_dr->prio[level-1] == own_prio &&
- memcmp (adj_dr->snpa, circuit->u.bc.snpa,
- ETH_ALEN) < 0)) {
- if (!circuit->u.bc.is_dr[level - 1]) {
- /*
- * We are the DR -> commence
+ if (adj_dr->prio[level - 1] < own_prio
+ || (adj_dr->prio[level - 1] == own_prio
+ && memcmp (adj_dr->snpa, circuit->u.bc.snpa, ETH_ALEN) < 0))
+ {
+ if (!circuit->u.bc.is_dr[level - 1])
+ {
+ /*
+ * We are the DR -> commence
+ */
+ list_delete (list);
+ return isis_dr_commence (circuit, level);
+ }
+ }
+ else
+ {
+
+ /* ok we have found the DIS - lets mark the adjacency */
+ /* set flag for show output */
+ adj_dr->dis_record[level - 1].dis = ISIS_IS_DIS;
+ adj_dr->dis_record[level - 1].last_dis_change = time (NULL);
+
+ /* now loop through a second time to check if there has been a DIS change
+ * if yes rotate the history log
*/
- list_delete (list);
- return isis_dr_commence (circuit, level);
+
+ for (node = listhead (list); node; nextnode (node))
+ {
+ adj = getdata (node);
+ isis_check_dr_change (adj, level);
+ }
+
+ /*
+ * We are not DR - if we were -> resign
+ */
+
+ if (circuit->u.bc.is_dr[level - 1])
+ {
+ list_delete (list);
+ return isis_dr_resign (circuit, level);
+ }
}
- } else {
-
- /* ok we have found the DIS - lets mark the adjacency */
- /* set flag for show output */
- adj_dr->dis_record[level - 1].dis = ISIS_IS_DIS;
- adj_dr->dis_record[level - 1].last_dis_change = time(NULL);
-
- /* now loop through a second time to check if there has been a DIS change
- * if yes rotate the history log
- */
-
- for (node = listhead (list); node; nextnode (node)) {
- adj = getdata (node);
- isis_check_dr_change(adj, level);
- }
-
- /*
- * We are not DR - if we were -> resign
- */
-
- if (circuit->u.bc.is_dr[level - 1]) {
- list_delete (list);
- return isis_dr_resign (circuit, level);
- }
- }
- out:
+out:
if (list)
list_delete (list);
return retval;
}
-int
+int
isis_dr_resign (struct isis_circuit *circuit, int level)
{
u_char id[ISIS_SYS_ID_LEN + 2];
-
+
zlog_info ("isis_dr_resign l%d", level);
circuit->u.bc.is_dr[level - 1] = 0;
- circuit->u.bc.run_dr_elect[level - 1] = 0;
- THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[level - 1]);
- THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
-
+ circuit->u.bc.run_dr_elect[level - 1] = 0;
+ THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[level - 1]);
+ THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
+
memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID(id) = circuit->circuit_id;
- LSP_FRAGMENT(id) = 0;
+ LSP_PSEUDO_ID (id) = circuit->circuit_id;
+ LSP_FRAGMENT (id) = 0;
lsp_purge_dr (id, circuit, level);
- if (level == 1) {
- memset (circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);
-
- THREAD_TIMER_OFF(circuit->t_send_csnp[0]);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[1]);
-
- THREAD_TIMER_ON(master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter (circuit->psnp_interval[level - 1], PSNP_JITTER));
- } else {
- memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
+ if (level == 1)
+ {
+ memset (circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);
- THREAD_TIMER_OFF(circuit->t_send_csnp[1]);
+ THREAD_TIMER_OFF (circuit->t_send_csnp[0]);
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
-
- THREAD_TIMER_ON(master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter (circuit->psnp_interval[level - 1], PSNP_JITTER));
- }
-
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
+ circuit, 2 * circuit->hello_interval[1]);
+
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[level - 1],
+ PSNP_JITTER));
+ }
+ else
+ {
+ memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
+
+ THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
+
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
+ circuit, 2 * circuit->hello_interval[1]);
+
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[level - 1],
+ PSNP_JITTER));
+ }
+
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
return ISIS_OK;
}
-int
+int
isis_dr_commence (struct isis_circuit *circuit, int level)
{
u_char old_dr[ISIS_SYS_ID_LEN + 2];
-
+
zlog_info ("isis_dr_commence l%d", level);
/* Lets keep a pause in DR election */
circuit->u.bc.run_dr_elect[level - 1] = 0;
- if (level == 1)
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_multiplier[0] *
- circuit->hello_interval[0]);
- else
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_multiplier[1] *
- circuit->hello_interval[1]);
+ if (level == 1)
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
+ circuit, 2 * circuit->hello_multiplier[0] *
+ circuit->hello_interval[0]);
+ else
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
+ circuit, 2 * circuit->hello_multiplier[1] *
+ circuit->hello_interval[1]);
circuit->u.bc.is_dr[level - 1] = 1;
- if (level == 1) {
- memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
- LSP_FRAGMENT (old_dr) = 0;
- if (LSP_PSEUDO_ID(old_dr)) {
- /* there was a dr elected, purge its LSPs from the db */
- lsp_purge_dr (old_dr, circuit, level);
- }
- memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
- *(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
-
- assert (circuit->circuit_id); /* must be non-zero */
- /* if (circuit->t_send_l1_psnp)
- thread_cancel (circuit->t_send_l1_psnp); */
- lsp_l1_pseudo_generate (circuit);
+ if (level == 1)
+ {
+ memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
+ LSP_FRAGMENT (old_dr) = 0;
+ if (LSP_PSEUDO_ID (old_dr))
+ {
+ /* there was a dr elected, purge its LSPs from the db */
+ lsp_purge_dr (old_dr, circuit, level);
+ }
+ memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
+ *(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
- THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[0]);
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, 2 * circuit->hello_interval[0]);
-
- THREAD_TIMER_ON(master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
- isis_jitter(circuit->csnp_interval[level-1], CSNP_JITTER));
-
- } else {
- memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
- LSP_FRAGMENT (old_dr) = 0;
- if (LSP_PSEUDO_ID(old_dr)) {
- /* there was a dr elected, purge its LSPs from the db */
- lsp_purge_dr (old_dr, circuit, level);
- }
- memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
- *(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
-
- assert (circuit->circuit_id); /* must be non-zero */
- /* if (circuit->t_send_l1_psnp)
- thread_cancel (circuit->t_send_l1_psnp); */
- lsp_l2_pseudo_generate (circuit);
+ assert (circuit->circuit_id); /* must be non-zero */
+ /* if (circuit->t_send_l1_psnp)
+ thread_cancel (circuit->t_send_l1_psnp); */
+ lsp_l1_pseudo_generate (circuit);
- THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[1]);
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, 2 * circuit->hello_interval[1]);
-
- THREAD_TIMER_ON(master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
- isis_jitter (circuit->csnp_interval[level-1], CSNP_JITTER));
- }
+ THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
+ circuit, 2 * circuit->hello_interval[0]);
+
+ THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
+ isis_jitter (circuit->csnp_interval[level - 1],
+ CSNP_JITTER));
+
+ }
+ else
+ {
+ memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
+ LSP_FRAGMENT (old_dr) = 0;
+ if (LSP_PSEUDO_ID (old_dr))
+ {
+ /* there was a dr elected, purge its LSPs from the db */
+ lsp_purge_dr (old_dr, circuit, level);
+ }
+ memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
+ *(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
+
+ assert (circuit->circuit_id); /* must be non-zero */
+ /* if (circuit->t_send_l1_psnp)
+ thread_cancel (circuit->t_send_l1_psnp); */
+ lsp_l2_pseudo_generate (circuit);
+
+ THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
+ circuit, 2 * circuit->hello_interval[1]);
+
+ THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
+ isis_jitter (circuit->csnp_interval[level - 1],
+ CSNP_JITTER));
+ }
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
-
+
return ISIS_OK;
}
-
diff --git a/isisd/isis_dr.h b/isisd/isis_dr.h
index 73d9cd3..b0386d4 100644
--- a/isisd/isis_dr.h
+++ b/isisd/isis_dr.h
@@ -31,7 +31,8 @@
int isis_dr_commence (struct isis_circuit *circuit, int level);
char *isis_disflag2string (int disflag);
-enum isis_dis_state {
+enum isis_dis_state
+{
ISIS_IS_NOT_DIS,
ISIS_IS_DIS,
ISIS_WAS_DIS,
@@ -39,4 +40,3 @@
};
#endif /* _ZEBRA_ISIS_DR_H */
-
diff --git a/isisd/isis_dynhn.c b/isisd/isis_dynhn.c
index 6b1d27b..41c3637 100644
--- a/isisd/isis_dynhn.c
+++ b/isisd/isis_dynhn.c
@@ -50,48 +50,52 @@
dyn_cache_init (void)
{
dyn_cache = list_new ();
-
+
return;
}
-struct isis_dynhn *dynhn_find_by_id (u_char * id)
+struct isis_dynhn *
+dynhn_find_by_id (u_char * id)
{
struct listnode *node = NULL;
struct isis_dynhn *dyn = NULL;
- for (node = listhead (dyn_cache); node; nextnode (node)) {
- dyn = getdata (node);
- if (memcmp (dyn->id, id, ISIS_SYS_ID_LEN) == 0)
- return dyn;
- }
-
+ for (node = listhead (dyn_cache); node; nextnode (node))
+ {
+ dyn = getdata (node);
+ if (memcmp (dyn->id, id, ISIS_SYS_ID_LEN) == 0)
+ return dyn;
+ }
+
return NULL;
}
void
-isis_dynhn_insert (u_char *id, struct hostname *hostname, int level)
+isis_dynhn_insert (u_char * id, struct hostname *hostname, int level)
{
struct isis_dynhn *dyn;
dyn = dynhn_find_by_id (id);
- if (dyn) {
- memcpy (&dyn->name, hostname, hostname->namelen + 1);
- memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
- dyn->refresh = time (NULL);
- return;
- }
+ if (dyn)
+ {
+ memcpy (&dyn->name, hostname, hostname->namelen + 1);
+ memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
+ dyn->refresh = time (NULL);
+ return;
+ }
dyn = XMALLOC (MTYPE_ISIS_DYNHN, sizeof (struct isis_dynhn));
- if (!dyn) {
- zlog_warn ("isis_dynhn_insert(): out of memory!");
- return;
- }
- memset (dyn,0,sizeof(struct isis_dynhn));
+ if (!dyn)
+ {
+ zlog_warn ("isis_dynhn_insert(): out of memory!");
+ return;
+ }
+ memset (dyn, 0, sizeof (struct isis_dynhn));
/* we also copy the length */
- memcpy (&dyn->name, hostname, hostname->namelen + 1);
+ memcpy (&dyn->name, hostname, hostname->namelen + 1);
memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
dyn->refresh = time (NULL);
dyn->level = level;
-
+
listnode_add (dyn_cache, dyn);
return;
@@ -103,21 +107,22 @@
* 2 0000.0000.0002 bar-gw
* * 0000.0000.0004 this-gw
*/
-void dynhn_print_all (struct vty *vty)
+void
+dynhn_print_all (struct vty *vty)
{
struct listnode *node;
struct isis_dynhn *dyn;
vty_out (vty, "Level System ID Dynamic Hostname%s", VTY_NEWLINE);
- for (node = listhead (dyn_cache); node; nextnode (node)) {
- dyn = getdata (node);
- vty_out (vty, "%-7d", dyn->level);
- vty_out (vty, "%-15s%-15s%s", sysid_print (dyn->id), dyn->name.name,
- VTY_NEWLINE);
- }
-
- vty_out (vty, " * %s %s%s", sysid_print (isis->sysid), unix_hostname(),
+ for (node = listhead (dyn_cache); node; nextnode (node))
+ {
+ dyn = getdata (node);
+ vty_out (vty, "%-7d", dyn->level);
+ vty_out (vty, "%-15s%-15s%s", sysid_print (dyn->id), dyn->name.name,
+ VTY_NEWLINE);
+ }
+
+ vty_out (vty, " * %s %s%s", sysid_print (isis->sysid), unix_hostname (),
VTY_NEWLINE);
return;
}
-
diff --git a/isisd/isis_dynhn.h b/isisd/isis_dynhn.h
index 2a7f3ec..37a7b03 100644
--- a/isisd/isis_dynhn.h
+++ b/isisd/isis_dynhn.h
@@ -23,7 +23,8 @@
#ifndef _ZEBRA_ISIS_DYNHN_H
#define _ZEBRA_ISIS_DYNHN_H
-struct isis_dynhn {
+struct isis_dynhn
+{
u_char id[ISIS_SYS_ID_LEN];
struct hostname name;
time_t refresh;
@@ -31,12 +32,8 @@
};
void dyn_cache_init (void);
-void isis_dynhn_insert (u_char *id, struct hostname *hostname, int level);
+void isis_dynhn_insert (u_char * id, struct hostname *hostname, int level);
struct isis_dynhn *dynhn_find_by_id (u_char * id);
-void dynhn_print_all (struct vty *vty);
+void dynhn_print_all (struct vty *vty);
#endif /* _ZEBRA_ISIS_DYNHN_H */
-
-
-
-
diff --git a/isisd/isis_events.c b/isisd/isis_events.c
index be136e2..a99869b 100644
--- a/isisd/isis_events.c
+++ b/isisd/isis_events.c
@@ -64,19 +64,19 @@
4w5d: ISIS-Spf (tlt): L2 SPF needed, periodic SPF, from 0x6091C844
*/
-void
+void
isis_event_circuit_state_change (struct isis_circuit *circuit, int up)
{
struct isis_area *area;
-
+
area = circuit->area;
assert (area);
area->circuit_state_changes++;
-
- if (isis->debugs & DEBUG_EVENTS)
- zlog_info ("ISIS-Evt (%s) circuit %s", circuit->area->area_tag,
+
+ if (isis->debugs & DEBUG_EVENTS)
+ zlog_info ("ISIS-Evt (%s) circuit %s", circuit->area->area_tag,
up ? "up" : "down");
-
+
/*
* Regenerate LSPs this affects
*/
@@ -85,47 +85,51 @@
return;
}
-void
+void
isis_event_system_type_change (struct isis_area *area, int newtype)
{
struct listnode *node;
struct isis_circuit *circuit;
- if (isis->debugs & DEBUG_EVENTS)
- zlog_info ("ISIS-Evt (%s) system type change %s -> %s", area->area_tag,
+ if (isis->debugs & DEBUG_EVENTS)
+ zlog_info ("ISIS-Evt (%s) system type change %s -> %s", area->area_tag,
circuit_t2string (area->is_type), circuit_t2string (newtype));
-
+
if (area->is_type == newtype)
- return; /* No change */
-
- switch (area->is_type) {
- case IS_LEVEL_1:
- if (area->lspdb[1] == NULL)
- area->lspdb[1] = lsp_db_init ();
- lsp_l2_generate (area);
- break;
- case IS_LEVEL_1_AND_2:
- if (newtype == IS_LEVEL_1) {
- lsp_db_destroy (area->lspdb[1]);
- }
- else {
- lsp_db_destroy (area->lspdb[0]);
- }
- break;
- case IS_LEVEL_2:
- if (area->lspdb[0] == NULL)
- area->lspdb[0] = lsp_db_init ();
- lsp_l1_generate (area);
- break;
- default:
- break;
- }
-
+ return; /* No change */
+
+ switch (area->is_type)
+ {
+ case IS_LEVEL_1:
+ if (area->lspdb[1] == NULL)
+ area->lspdb[1] = lsp_db_init ();
+ lsp_l2_generate (area);
+ break;
+ case IS_LEVEL_1_AND_2:
+ if (newtype == IS_LEVEL_1)
+ {
+ lsp_db_destroy (area->lspdb[1]);
+ }
+ else
+ {
+ lsp_db_destroy (area->lspdb[0]);
+ }
+ break;
+ case IS_LEVEL_2:
+ if (area->lspdb[0] == NULL)
+ area->lspdb[0] = lsp_db_init ();
+ lsp_l1_generate (area);
+ break;
+ default:
+ break;
+ }
+
area->is_type = newtype;
- for (node = listhead (area->circuit_list); node; nextnode (node)) {
- circuit = getdata (node);
- isis_event_circuit_type_change (circuit, newtype);
- }
+ for (node = listhead (area->circuit_list); node; nextnode (node))
+ {
+ circuit = getdata (node);
+ isis_event_circuit_type_change (circuit, newtype);
+ }
spftree_area_init (area);
lsp_regenerate_schedule (area);
@@ -133,9 +137,7 @@
return;
}
-
-
-void
+void
isis_event_area_addr_change (struct isis_area *area)
{
@@ -146,40 +148,49 @@
{
uint32_t interval;
- if (level == 1) {
- THREAD_TIMER_ON(master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter(circuit->psnp_interval[0], PSNP_JITTER));
+ if (level == 1)
+ {
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- interval = circuit->hello_multiplier[0] * (circuit->hello_interval[0]);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
- circuit, interval);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_send_lan_hello[0],
- send_lan_l1_hello, circuit,
- isis_jitter(circuit->hello_interval[0], IIH_JITTER));
-
- circuit->u.bc.lan_neighs[0] = list_new ();
- }
- } else {
- THREAD_TIMER_ON(master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter(circuit->psnp_interval[1], PSNP_JITTER));
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ interval =
+ circuit->hello_multiplier[0] * (circuit->hello_interval[0]);
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- interval = circuit->hello_multiplier[1] * (circuit->hello_interval[1]);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
- circuit, interval);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_send_lan_hello[1],
- send_lan_l2_hello, circuit,
- isis_jitter(circuit->hello_interval[1], IIH_JITTER));
-
- circuit->u.bc.lan_neighs[1] = list_new ();
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
+ circuit, interval);
+
+ THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
+ send_lan_l1_hello, circuit,
+ isis_jitter (circuit->hello_interval[0],
+ IIH_JITTER));
+
+ circuit->u.bc.lan_neighs[0] = list_new ();
+ }
}
- }
-
+ else
+ {
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
+
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ interval =
+ circuit->hello_multiplier[1] * (circuit->hello_interval[1]);
+
+ THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
+ circuit, interval);
+
+ THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
+ send_lan_l2_hello, circuit,
+ isis_jitter (circuit->hello_interval[1],
+ IIH_JITTER));
+
+ circuit->u.bc.lan_neighs[1] = list_new ();
+ }
+ }
+
return;
}
@@ -187,61 +198,64 @@
circuit_resign_level (struct isis_circuit *circuit, int level)
{
int idx = level - 1;
-
- THREAD_TIMER_OFF(circuit->t_send_csnp[idx]);
- THREAD_TIMER_OFF(circuit->t_send_psnp[idx]);
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[idx]);
- THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[idx]);
- circuit->u.bc.run_dr_elect[idx] = 0;
- }
-
+ THREAD_TIMER_OFF (circuit->t_send_csnp[idx]);
+ THREAD_TIMER_OFF (circuit->t_send_psnp[idx]);
+
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ THREAD_TIMER_OFF (circuit->u.bc.t_send_lan_hello[idx]);
+ THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[idx]);
+ circuit->u.bc.run_dr_elect[idx] = 0;
+ }
+
return;
}
-void
-isis_event_circuit_type_change (struct isis_circuit *circuit, int newtype)
+void
+isis_event_circuit_type_change (struct isis_circuit *circuit, int newtype)
{
-
- if (isis->debugs & DEBUG_EVENTS)
- zlog_info ("ISIS-Evt (%s) circuit type change %s -> %s",
- circuit->area->area_tag,
- circuit_t2string (circuit->circuit_is_type),
+
+ if (isis->debugs & DEBUG_EVENTS)
+ zlog_info ("ISIS-Evt (%s) circuit type change %s -> %s",
+ circuit->area->area_tag,
+ circuit_t2string (circuit->circuit_is_type),
circuit_t2string (newtype));
if (circuit->circuit_is_type == newtype)
- return; /* No change */
+ return; /* No change */
- if (!(newtype & circuit->area->is_type)) {
- zlog_err ("ISIS-Evt (%s) circuit type change - invalid level %s because"
- " area is %s", circuit->area->area_tag,
- circuit_t2string (newtype),
- circuit_t2string (circuit->area->is_type));
- return;
- }
-
- switch (circuit->circuit_is_type) {
- case IS_LEVEL_1:
- if (newtype == IS_LEVEL_2)
- circuit_resign_level (circuit, 1);
- circuit_commence_level (circuit, 2);
- break;
- case IS_LEVEL_1_AND_2:
- if (newtype == IS_LEVEL_1)
- circuit_resign_level (circuit, 2);
- else
- circuit_resign_level (circuit, 1);
- break;
- case IS_LEVEL_2:
- if (newtype == IS_LEVEL_1)
- circuit_resign_level (circuit, 2);
- circuit_commence_level (circuit, 1);
- break;
- default:
- break;
- }
-
+ if (!(newtype & circuit->area->is_type))
+ {
+ zlog_err ("ISIS-Evt (%s) circuit type change - invalid level %s because"
+ " area is %s", circuit->area->area_tag,
+ circuit_t2string (newtype),
+ circuit_t2string (circuit->area->is_type));
+ return;
+ }
+
+ switch (circuit->circuit_is_type)
+ {
+ case IS_LEVEL_1:
+ if (newtype == IS_LEVEL_2)
+ circuit_resign_level (circuit, 1);
+ circuit_commence_level (circuit, 2);
+ break;
+ case IS_LEVEL_1_AND_2:
+ if (newtype == IS_LEVEL_1)
+ circuit_resign_level (circuit, 2);
+ else
+ circuit_resign_level (circuit, 1);
+ break;
+ case IS_LEVEL_2:
+ if (newtype == IS_LEVEL_1)
+ circuit_resign_level (circuit, 2);
+ circuit_commence_level (circuit, 1);
+ break;
+ default:
+ break;
+ }
+
circuit->circuit_is_type = newtype;
lsp_regenerate_schedule (circuit->area);
@@ -270,18 +284,19 @@
*
* ***********************************************************************/
-void
+void
isis_event_adjacency_state_change (struct isis_adjacency *adj, int newstate)
{
/* adjacency state change event.
* - the only proto-type was supported */
-
- /* invalid arguments */
- if ( !adj || !adj->circuit || !adj->circuit->area ) return;
-
- zlog_info ("ISIS-Evt (%s) Adjacency State change",
- adj->circuit->area->area_tag );
-
+
+ /* invalid arguments */
+ if (!adj || !adj->circuit || !adj->circuit->area)
+ return;
+
+ zlog_info ("ISIS-Evt (%s) Adjacency State change",
+ adj->circuit->area->area_tag);
+
/* LSP generation again */
lsp_regenerate_schedule (adj->circuit->area);
@@ -294,27 +309,26 @@
isis_event_dis_status_change (struct thread *thread)
{
struct isis_circuit *circuit;
-
+
circuit = THREAD_ARG (thread);
-
+
/* invalid arguments */
- if (!circuit || !circuit->area) return 0;
-
+ if (!circuit || !circuit->area)
+ return 0;
+
zlog_info ("ISIS-Evt (%s) DIS status change", circuit->area->area_tag);
/* LSP generation again */
lsp_regenerate_schedule (circuit->area);
-
+
return 0;
}
-
-void
-isis_event_auth_failure (char *area_tag, char *error_string, char *sysid)
+void
+isis_event_auth_failure (char *area_tag, char *error_string, char *sysid)
{
zlog_info ("ISIS-Evt (%s) Authentication failure %s from %s",
area_tag, error_string, sysid_print (sysid));
-
+
return;
}
-
diff --git a/isisd/isis_events.h b/isisd/isis_events.h
index 75dd92e..a6ec2e8 100644
--- a/isisd/isis_events.h
+++ b/isisd/isis_events.h
@@ -31,14 +31,15 @@
/*
* Events related to circuit
*/
-void isis_event_circuit_state_change (struct isis_circuit *circuit, int state);
-void isis_event_circuit_type_change (struct isis_circuit *circuit,
- int newtype);
+void isis_event_circuit_state_change (struct isis_circuit *circuit,
+ int state);
+void isis_event_circuit_type_change (struct isis_circuit *circuit,
+ int newtype);
/*
* Events related to adjacencies
*/
-void isis_event_adjacency_state_change(struct isis_adjacency *adj,
- int newstate);
+void isis_event_adjacency_state_change (struct isis_adjacency *adj,
+ int newstate);
int isis_event_dis_status_change (struct thread *thread);
@@ -48,7 +49,7 @@
#define AUTH_ERROR_TYPE_LSP 3
#define AUTH_ERROR_TYPE_SNP 2
#define AUTH_ERROR_TYPE_HELLO 1
-void isis_event_auth_failure (char *area_tag, char *error_string, char *sysid);
+void isis_event_auth_failure (char *area_tag, char *error_string,
+ char *sysid);
#endif /* _ZEBRA_ISIS_EVENTS_H */
-
diff --git a/isisd/isis_flags.c b/isisd/isis_flags.c
index 716bee0..0ef048e 100644
--- a/isisd/isis_flags.c
+++ b/isisd/isis_flags.c
@@ -21,7 +21,6 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-
#include <zebra.h>
#include "log.h"
#include "linklist.h"
@@ -31,41 +30,44 @@
#include "isisd/isis_flags.h"
int
-flags_get_index (struct flags *flags)
+flags_get_index (struct flags *flags)
{
struct listnode *node;
int index;
- if (flags->free_idcs == NULL || flags->free_idcs->count == 0) {
- flags->maxindex++;
- index = flags->maxindex;
- } else {
- node = listhead (flags->free_idcs);
- index = (int) getdata (node);
- listnode_delete (flags->free_idcs, (void *)index);
- }
-
+ if (flags->free_idcs == NULL || flags->free_idcs->count == 0)
+ {
+ flags->maxindex++;
+ index = flags->maxindex;
+ }
+ else
+ {
+ node = listhead (flags->free_idcs);
+ index = (int) getdata (node);
+ listnode_delete (flags->free_idcs, (void *) index);
+ }
+
return index;
}
-void
-flags_free_index (struct flags *flags, int index)
+void
+flags_free_index (struct flags *flags, int index)
{
- if (flags->free_idcs == NULL) {
- flags->free_idcs = list_new ();
- }
-
- listnode_add (flags->free_idcs, (void *)index);
-
+ if (flags->free_idcs == NULL)
+ {
+ flags->free_idcs = list_new ();
+ }
+
+ listnode_add (flags->free_idcs, (void *) index);
+
return;
}
-int
-flags_any_set (u_int32_t *flags)
+int
+flags_any_set (u_int32_t * flags)
{
+ u_int32_t zero[ISIS_MAX_CIRCUITS];
+ memset (zero, 0x00, ISIS_MAX_CIRCUITS * 4);
- u_int32_t zero[ISIS_MAX_CIRCUITS];
- memset (zero, 0x00, ISIS_MAX_CIRCUITS*4);
-
- return bcmp(flags, zero, ISIS_MAX_CIRCUITS*4);
+ return bcmp (flags, zero, ISIS_MAX_CIRCUITS * 4);
}
diff --git a/isisd/isis_flags.h b/isisd/isis_flags.h
index 66b9484..f2421f2 100644
--- a/isisd/isis_flags.h
+++ b/isisd/isis_flags.h
@@ -26,13 +26,13 @@
/* The grand plan is to support 1024 circuits so we have 32*32 bit flags
* the support will be achived using the newest drafts */
-#define ISIS_MAX_CIRCUITS 32 /* = 1024 */ /*FIXME:defined in lsp.h as well*/
+#define ISIS_MAX_CIRCUITS 32 /* = 1024 */ /*FIXME:defined in lsp.h as well */
-struct flags *new_flags (int size);
-int flags_get_index (struct flags *flags);
-void flags_free_index (struct flags *flags, int index);
+struct flags *new_flags (int size);
+int flags_get_index (struct flags *flags);
+void flags_free_index (struct flags *flags, int index);
-int flags_any_set (u_int32_t *flags);
+int flags_any_set (u_int32_t * flags);
#define ISIS_SET_FLAG(F,C) \
F[C->idx>>5] |= (1<<(C->idx & 0x1F));
@@ -50,9 +50,3 @@
memset(FLAGS,0x00,ISIS_MAX_CIRCUITS*4);
#endif /* _ZEBRA_ISIS_FLAGS_H */
-
-
-
-
-
-
diff --git a/isisd/isis_lsp.c b/isisd/isis_lsp.c
index a29ba80..214b438 100644
--- a/isisd/isis_lsp.c
+++ b/isisd/isis_lsp.c
@@ -55,46 +55,47 @@
#include "spgrid.h"
#endif
-#define LSP_MEMORY_PREASSIGN
+#define LSP_MEMORY_PREASSIGN
extern struct isis *isis;
extern struct thread_master *master;
-int
-lsp_id_cmp (u_char *id1, u_char *id2)
-{
+int
+lsp_id_cmp (u_char * id1, u_char * id2)
+{
return memcmp (id1, id2, ISIS_SYS_ID_LEN + 2);
}
dict_t *
-lsp_db_init (void)
+lsp_db_init (void)
{
dict_t *dict;
-
- dict = dict_create (DICTCOUNT_T_MAX, (dict_comp_t)lsp_id_cmp);
-
+
+ dict = dict_create (DICTCOUNT_T_MAX, (dict_comp_t) lsp_id_cmp);
+
return dict;
}
struct isis_lsp *
-lsp_search (u_char *id, dict_t *lspdb)
+lsp_search (u_char * id, dict_t * lspdb)
{
dnode_t *node;
-#ifdef EXTREME_DEBUG
+#ifdef EXTREME_DEBUG
dnode_t *dn;
- zlog_warn("searching db");
- for (dn = dict_first(lspdb); dn; dn = dict_next(lspdb, dn)) {
- zlog_warn("%s\t%pX", rawlspid_print((char *) dnode_getkey(dn)),
- dnode_get(dn));
- }
+ zlog_warn ("searching db");
+ for (dn = dict_first (lspdb); dn; dn = dict_next (lspdb, dn))
+ {
+ zlog_warn ("%s\t%pX", rawlspid_print ((char *) dnode_getkey (dn)),
+ dnode_get (dn));
+ }
#endif /* EXTREME DEBUG */
node = dict_lookup (lspdb, id);
-
+
if (node)
- return (struct isis_lsp *)dnode_get (node);
+ return (struct isis_lsp *) dnode_get (node);
return NULL;
}
@@ -104,13 +105,14 @@
{
if (!lsp)
return;
-
- if (lsp->own_lsp) {
- if (lsp->tlv_data.nlpids)
- XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.nlpids);
- if (lsp->tlv_data.hostname)
- XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.hostname);
- }
+
+ if (lsp->own_lsp)
+ {
+ if (lsp->tlv_data.nlpids)
+ XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.nlpids);
+ if (lsp->tlv_data.hostname)
+ XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.hostname);
+ }
if (lsp->tlv_data.is_neighs)
list_delete (lsp->tlv_data.is_neighs);
if (lsp->tlv_data.area_addrs)
@@ -140,35 +142,37 @@
{
if (!lsp)
return;
-
+
lsp_clear_data (lsp);
-
- if (LSP_FRAGMENT (lsp->lsp_header->lsp_id) == 0 && lsp->lspu.frags) {
+
+ if (LSP_FRAGMENT (lsp->lsp_header->lsp_id) == 0 && lsp->lspu.frags)
+ {
list_delete (lsp->lspu.frags);
- }
-
+ }
+
if (lsp->pdu)
stream_free (lsp->pdu);
XFREE (MTYPE_ISIS_LSP, lsp);
}
-void
-lsp_db_destroy (dict_t *lspdb)
+void
+lsp_db_destroy (dict_t * lspdb)
{
dnode_t *dnode, *next;
struct isis_lsp *lsp;
-
+
dnode = dict_first (lspdb);
- while (dnode) {
- next = dict_next (lspdb, dnode);
- lsp = dnode_get (dnode);
- lsp_destroy (lsp);
- dict_delete_free (lspdb, dnode);
- dnode = next;
- }
-
+ while (dnode)
+ {
+ next = dict_next (lspdb, dnode);
+ lsp = dnode_get (dnode);
+ lsp_destroy (lsp);
+ dict_delete_free (lspdb, dnode);
+ dnode = next;
+ }
+
dict_free (lspdb);
-
+
return;
}
@@ -176,133 +180,136 @@
* Remove all the frags belonging to the given lsp
*/
void
-lsp_remove_frags (struct list *frags, dict_t *lspdb)
+lsp_remove_frags (struct list *frags, dict_t * lspdb)
{
dnode_t *dnode;
struct listnode *lnode;
struct isis_lsp *lsp;
- for (lnode = listhead (frags); lnode; nextnode (lnode)) {
- lsp = getdata (lnode);
- dnode = dict_lookup (lspdb, lsp->lsp_header->lsp_id);
- lsp_destroy (lsp);
- dnode_destroy (dict_delete(lspdb, dnode));
- }
-
+ for (lnode = listhead (frags); lnode; nextnode (lnode))
+ {
+ lsp = getdata (lnode);
+ dnode = dict_lookup (lspdb, lsp->lsp_header->lsp_id);
+ lsp_destroy (lsp);
+ dnode_destroy (dict_delete (lspdb, dnode));
+ }
+
list_delete_all_node (frags);
-
+
return;
}
void
-lsp_search_and_destroy (u_char *id, dict_t *lspdb)
+lsp_search_and_destroy (u_char * id, dict_t * lspdb)
{
dnode_t *node;
struct isis_lsp *lsp;
node = dict_lookup (lspdb, id);
- if (node) {
- node = dict_delete (lspdb, node);
- lsp = dnode_get (node);
- /*
- * If this is a zero lsp, remove all the frags now
- */
- if (LSP_FRAGMENT(lsp->lsp_header->lsp_id) == 0) {
- if (lsp->lspu.frags)
- lsp_remove_frags (lsp->lspu.frags, lspdb);
- } else {
- /*
- * else just remove this frag, from the zero lsps' frag list
- */
- if (lsp->lspu.zero_lsp && lsp->lspu.zero_lsp->lspu.frags)
- listnode_delete (lsp->lspu.zero_lsp->lspu.frags, lsp);
+ if (node)
+ {
+ node = dict_delete (lspdb, node);
+ lsp = dnode_get (node);
+ /*
+ * If this is a zero lsp, remove all the frags now
+ */
+ if (LSP_FRAGMENT (lsp->lsp_header->lsp_id) == 0)
+ {
+ if (lsp->lspu.frags)
+ lsp_remove_frags (lsp->lspu.frags, lspdb);
+ }
+ else
+ {
+ /*
+ * else just remove this frag, from the zero lsps' frag list
+ */
+ if (lsp->lspu.zero_lsp && lsp->lspu.zero_lsp->lspu.frags)
+ listnode_delete (lsp->lspu.zero_lsp->lspu.frags, lsp);
+ }
+ lsp_destroy (lsp);
+ dnode_destroy (node);
}
- lsp_destroy (lsp);
- dnode_destroy (node);
- }
}
/*
* Compares a LSP to given values
* Params are given in net order
*/
-int
-lsp_compare (char *areatag, struct isis_lsp *lsp, u_int32_t seq_num,
+int
+lsp_compare (char *areatag, struct isis_lsp *lsp, u_int32_t seq_num,
u_int16_t checksum, u_int16_t rem_lifetime)
{
- /* no point in double ntohl on seqnum */
- if (lsp->lsp_header->seq_num == seq_num &&
+ /* no point in double ntohl on seqnum */
+ if (lsp->lsp_header->seq_num == seq_num &&
lsp->lsp_header->checksum == checksum &&
/*comparing with 0, no need to do ntohl */
((lsp->lsp_header->rem_lifetime == 0 && rem_lifetime == 0) ||
- (lsp->lsp_header->rem_lifetime != 0 && rem_lifetime != 0))) {
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- zlog_info ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
- " lifetime %us",
- areatag,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(lsp->lsp_header->seq_num),
- ntohs(lsp->lsp_header->checksum),
- ntohs(lsp->lsp_header->rem_lifetime) );
- zlog_info ("ISIS-Snp (%s): is equal to ours seq 0x%08x,"
- " cksum 0x%04x, lifetime %us",
- areatag,
- ntohl(seq_num),
- ntohs(checksum),
- ntohs(rem_lifetime));
+ (lsp->lsp_header->rem_lifetime != 0 && rem_lifetime != 0)))
+ {
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ zlog_info ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
+ " lifetime %us",
+ areatag,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ zlog_info ("ISIS-Snp (%s): is equal to ours seq 0x%08x,"
+ " cksum 0x%04x, lifetime %us",
+ areatag,
+ ntohl (seq_num), ntohs (checksum), ntohs (rem_lifetime));
+ }
+ return LSP_EQUAL;
}
- return LSP_EQUAL;
- }
- if (ntohl(seq_num) >= ntohl(lsp->lsp_header->seq_num)) {
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- zlog_info ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
- " lifetime %us",
- areatag,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(seq_num),
- ntohs(checksum),
- ntohs(rem_lifetime ));
- zlog_info ("ISIS-Snp (%s): is newer than ours seq 0x%08x, "
- "cksum 0x%04x, lifetime %us",
- areatag,
- ntohl(lsp->lsp_header->seq_num),
- ntohs(lsp->lsp_header->checksum),
- ntohs(lsp->lsp_header->rem_lifetime) );
+ if (ntohl (seq_num) >= ntohl (lsp->lsp_header->seq_num))
+ {
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ zlog_info ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
+ " lifetime %us",
+ areatag,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (seq_num), ntohs (checksum), ntohs (rem_lifetime));
+ zlog_info ("ISIS-Snp (%s): is newer than ours seq 0x%08x, "
+ "cksum 0x%04x, lifetime %us",
+ areatag,
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ }
+ return LSP_NEWER;
}
- return LSP_NEWER;
- }
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- zlog_info ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x, lifetime %us",
- areatag,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(seq_num),
- ntohs(checksum),
- ntohs(rem_lifetime ));
- zlog_info ("ISIS-Snp (%s): is older than ours seq 0x%08x,"
- " cksum 0x%04x, lifetime %us",
- areatag,
- ntohl(lsp->lsp_header->seq_num),
- ntohs(lsp->lsp_header->checksum),
- ntohs(lsp->lsp_header->rem_lifetime) );
- }
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ zlog_info
+ ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x, lifetime %us",
+ areatag, rawlspid_print (lsp->lsp_header->lsp_id), ntohl (seq_num),
+ ntohs (checksum), ntohs (rem_lifetime));
+ zlog_info ("ISIS-Snp (%s): is older than ours seq 0x%08x,"
+ " cksum 0x%04x, lifetime %us", areatag,
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ }
return LSP_OLDER;
}
-void
+void
lsp_inc_seqnum (struct isis_lsp *lsp, u_int32_t seq_num)
{
u_int32_t newseq;
-
+
if (seq_num == 0 || ntohl (lsp->lsp_header->seq_num) > seq_num)
newseq = ntohl (lsp->lsp_header->seq_num) + 1;
else
- newseq = seq_num ++;
-
+ newseq = seq_num++;
+
lsp->lsp_header->seq_num = htonl (newseq);
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
return;
}
@@ -315,23 +322,24 @@
{
struct isis_lsp *lsp;
struct listnode *node;
-
+
lsp_inc_seqnum (lsp0, 0);
if (!lsp0->lspu.frags)
return;
- for (node = listhead (lsp0->lspu.frags); node; nextnode (node)) {
- lsp = getdata (node);
- lsp_inc_seqnum(lsp, 0);
- }
-
+ for (node = listhead (lsp0->lspu.frags); node; nextnode (node))
+ {
+ lsp = getdata (node);
+ lsp_inc_seqnum (lsp, 0);
+ }
+
return;
}
-int
+int
isis_lsp_authinfo_check (struct stream *stream, struct isis_area *area,
- int pdulen, struct isis_passwd *passwd)
+ int pdulen, struct isis_passwd *passwd)
{
uint32_t expected = 0, found;
struct tlvs tlvs;
@@ -339,23 +347,22 @@
expected |= TLVFLAG_AUTH_INFO;
retval = parse_tlvs (area->area_tag, stream->data +
- ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
- pdulen - ISIS_FIXED_HDR_LEN
- - ISIS_LSP_HDR_LEN,
- &expected, &found, &tlvs);
+ ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
+ pdulen - ISIS_FIXED_HDR_LEN
+ - ISIS_LSP_HDR_LEN, &expected, &found, &tlvs);
if (retval || !(found & TLVFLAG_AUTH_INFO))
- return 1; /* Auth fail (parsing failed or no auth-tlv)*/
+ return 1; /* Auth fail (parsing failed or no auth-tlv) */
return authentication_check (passwd, &tlvs.auth_info);
}
void
-lsp_update_data (struct isis_lsp *lsp, struct stream *stream,
- struct isis_area *area)
+lsp_update_data (struct isis_lsp *lsp, struct stream *stream,
+ struct isis_area *area)
{
- uint32_t expected = 0,found;
+ uint32_t expected = 0, found;
int retval;
-
+
/* copying only the relevant part of our stream */
lsp->pdu = stream_new (stream->endp);
lsp->pdu->putp = stream->putp;
@@ -364,27 +371,28 @@
memcpy (lsp->pdu->data, stream->data, stream->endp);
/* setting pointers to the correct place */
- lsp->isis_header = (struct isis_fixed_hdr *)(STREAM_DATA(lsp->pdu));
- lsp->lsp_header = (struct isis_link_state_hdr *)(STREAM_DATA(lsp->pdu) +
- ISIS_FIXED_HDR_LEN);
+ lsp->isis_header = (struct isis_fixed_hdr *) (STREAM_DATA (lsp->pdu));
+ lsp->lsp_header = (struct isis_link_state_hdr *) (STREAM_DATA (lsp->pdu) +
+ ISIS_FIXED_HDR_LEN);
lsp->age_out = ZERO_AGE_LIFETIME;
- lsp->installed = time(NULL);
+ lsp->installed = time (NULL);
/*
* Get LSP data i.e. TLVs
*/
expected |= TLVFLAG_AUTH_INFO;
expected |= TLVFLAG_AREA_ADDRS;
expected |= TLVFLAG_IS_NEIGHS;
- if ((lsp->lsp_header->lsp_bits & 3) == 3) /* a level 2 LSP */
+ if ((lsp->lsp_header->lsp_bits & 3) == 3) /* a level 2 LSP */
expected |= TLVFLAG_PARTITION_DESIG_LEVEL2_IS;
expected |= TLVFLAG_NLPID;
if (area->dynhostname)
expected |= TLVFLAG_DYN_HOSTNAME;
- if (area->newmetric) {
- expected |= TLVFLAG_TE_IS_NEIGHS;
- expected |= TLVFLAG_TE_IPV4_REACHABILITY;
- expected |= TLVFLAG_TE_ROUTER_ID;
- }
+ if (area->newmetric)
+ {
+ expected |= TLVFLAG_TE_IS_NEIGHS;
+ expected |= TLVFLAG_TE_IPV4_REACHABILITY;
+ expected |= TLVFLAG_TE_ROUTER_ID;
+ }
expected |= TLVFLAG_IPV4_ADDR;
expected |= TLVFLAG_IPV4_INT_REACHABILITY;
expected |= TLVFLAG_IPV4_EXT_REACHABILITY;
@@ -394,101 +402,103 @@
#endif /* HAVE_IPV6 */
retval = parse_tlvs (area->area_tag, lsp->pdu->data +
- ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
- ntohs(lsp->lsp_header->pdu_len) - ISIS_FIXED_HDR_LEN
- - ISIS_LSP_HDR_LEN, &expected, &found, &lsp->tlv_data);
+ ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
+ ntohs (lsp->lsp_header->pdu_len) - ISIS_FIXED_HDR_LEN
+ - ISIS_LSP_HDR_LEN, &expected, &found, &lsp->tlv_data);
- if (found & TLVFLAG_DYN_HOSTNAME) {
- if (area->dynhostname)
- isis_dynhn_insert (lsp->lsp_header->lsp_id, lsp->tlv_data.hostname,
- (lsp->lsp_header->lsp_bits & LSPBIT_IST) ==
- IS_LEVEL_1_AND_2 ? IS_LEVEL_2 :
- (lsp->lsp_header->lsp_bits & LSPBIT_IST));
- }
+ if (found & TLVFLAG_DYN_HOSTNAME)
+ {
+ if (area->dynhostname)
+ isis_dynhn_insert (lsp->lsp_header->lsp_id, lsp->tlv_data.hostname,
+ (lsp->lsp_header->lsp_bits & LSPBIT_IST) ==
+ IS_LEVEL_1_AND_2 ? IS_LEVEL_2 :
+ (lsp->lsp_header->lsp_bits & LSPBIT_IST));
+ }
}
void
lsp_update (struct isis_lsp *lsp, struct isis_link_state_hdr *lsp_hdr,
- struct stream *stream, struct isis_area *area)
+ struct stream *stream, struct isis_area *area)
{
-
- /* free the old lsp data*/
+ /* free the old lsp data */
XFREE (MTYPE_STREAM_DATA, lsp->pdu);
lsp_clear_data (lsp);
/* rebuild the lsp data */
lsp_update_data (lsp, stream, area);
- /* set the new values for lsp header */
+ /* set the new values for lsp header */
memcpy (lsp->lsp_header, lsp_hdr, ISIS_LSP_HDR_LEN);
-
}
-
/* creation of LSP directly from what we received */
struct isis_lsp *
-lsp_new_from_stream_ptr (struct stream *stream,
- u_int16_t pdu_len, struct isis_lsp *lsp0,
- struct isis_area *area)
+lsp_new_from_stream_ptr (struct stream *stream,
+ u_int16_t pdu_len, struct isis_lsp *lsp0,
+ struct isis_area *area)
{
struct isis_lsp *lsp;
lsp = XMALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
memset (lsp, 0, sizeof (struct isis_lsp));
-
+
lsp_update_data (lsp, stream, area);
-
- if (lsp0 == NULL) {
- /*
- * zero lsp -> create the list for fragments
- */
- lsp->lspu.frags = list_new ();
- } else {
- /*
- * a fragment -> set the backpointer and add this to zero lsps frag list
- */
- lsp->lspu.zero_lsp = lsp0;
- listnode_add (lsp0->lspu.frags, lsp);
- }
-
+
+ if (lsp0 == NULL)
+ {
+ /*
+ * zero lsp -> create the list for fragments
+ */
+ lsp->lspu.frags = list_new ();
+ }
+ else
+ {
+ /*
+ * a fragment -> set the backpointer and add this to zero lsps frag list
+ */
+ lsp->lspu.zero_lsp = lsp0;
+ listnode_add (lsp0->lspu.frags, lsp);
+ }
+
return lsp;
}
struct isis_lsp *
-lsp_new (u_char *lsp_id, u_int16_t rem_lifetime, u_int32_t seq_num,
- u_int8_t lsp_bits, u_int16_t checksum, int level)
+lsp_new (u_char * lsp_id, u_int16_t rem_lifetime, u_int32_t seq_num,
+ u_int8_t lsp_bits, u_int16_t checksum, int level)
{
struct isis_lsp *lsp;
lsp = XMALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
- if (!lsp) {
- /* FIXME: set lspdbol bit */
- zlog_warn ("lsp_new(): out of memory");
- return NULL;
- }
+ if (!lsp)
+ {
+ /* FIXME: set lspdbol bit */
+ zlog_warn ("lsp_new(): out of memory");
+ return NULL;
+ }
memset (lsp, 0, sizeof (struct isis_lsp));
#ifdef LSP_MEMORY_PREASSIGN
- lsp->pdu = stream_new (1514); /*Should be minimal mtu? yup...*/
+ lsp->pdu = stream_new (1514); /*Should be minimal mtu? yup... */
#else
- /* We need to do realloc on TLVs additions*/
- lsp->pdu = malloc (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
+ /* We need to do realloc on TLVs additions */
+ lsp->pdu = malloc (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
#endif /* LSP_MEMORY_PREASSIGN */
if (LSP_FRAGMENT (lsp_id) == 0)
lsp->lspu.frags = list_new ();
- lsp->isis_header = (struct isis_fixed_hdr*)(STREAM_DATA(lsp->pdu));
- lsp->lsp_header = (struct isis_link_state_hdr*)
- (STREAM_DATA(lsp->pdu) + ISIS_FIXED_HDR_LEN);
-
+ lsp->isis_header = (struct isis_fixed_hdr *) (STREAM_DATA (lsp->pdu));
+ lsp->lsp_header = (struct isis_link_state_hdr *)
+ (STREAM_DATA (lsp->pdu) + ISIS_FIXED_HDR_LEN);
+
/* at first we fill the FIXED HEADER */
- (level == 1) ? fill_fixed_hdr (lsp->isis_header, L1_LINK_STATE):
- fill_fixed_hdr (lsp->isis_header, L2_LINK_STATE);
-
+ (level == 1) ? fill_fixed_hdr (lsp->isis_header, L1_LINK_STATE) :
+ fill_fixed_hdr (lsp->isis_header, L2_LINK_STATE);
+
/* now for the LSP HEADER */
/* Minimal LSP PDU size */
- lsp->lsp_header->pdu_len = htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
+ lsp->lsp_header->pdu_len = htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
memcpy (lsp->lsp_header->lsp_id, lsp_id, ISIS_SYS_ID_LEN + 2);
- lsp->lsp_header->checksum = checksum; /* Provided in network order */
+ lsp->lsp_header->checksum = checksum; /* Provided in network order */
lsp->lsp_header->seq_num = htonl (seq_num);
lsp->lsp_header->rem_lifetime = htons (rem_lifetime);
lsp->lsp_header->lsp_bits = lsp_bits;
@@ -500,16 +510,16 @@
/* #ifdef EXTREME_DEBUG */
/* logging */
zlog_info ("New LSP with ID %s-%02x-%02x seqnum %08x", sysid_print (lsp_id),
- LSP_PSEUDO_ID (lsp->lsp_header->lsp_id),
- LSP_FRAGMENT (lsp->lsp_header->lsp_id),
- ntohl (lsp->lsp_header->seq_num));
+ LSP_PSEUDO_ID (lsp->lsp_header->lsp_id),
+ LSP_FRAGMENT (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num));
/* #endif EXTREME DEBUG */
return lsp;
}
void
-lsp_insert (struct isis_lsp *lsp, dict_t *lspdb)
+lsp_insert (struct isis_lsp *lsp, dict_t * lspdb)
{
dict_alloc_insert (lspdb, lsp->lsp_header->lsp_id, lsp);
}
@@ -517,62 +527,64 @@
/*
* Build a list of LSPs with non-zero ht bounded by start and stop ids
*/
-void
-lsp_build_list_nonzero_ht (u_char *start_id, u_char *stop_id,
- struct list *list, dict_t *lspdb)
+void
+lsp_build_list_nonzero_ht (u_char * start_id, u_char * stop_id,
+ struct list *list, dict_t * lspdb)
{
dnode_t *first, *last, *curr;
first = dict_lower_bound (lspdb, start_id);
if (!first)
return;
-
+
last = dict_upper_bound (lspdb, stop_id);
-
+
curr = first;
-
- if (((struct isis_lsp *)(curr->dict_data))->lsp_header->rem_lifetime)
+
+ if (((struct isis_lsp *) (curr->dict_data))->lsp_header->rem_lifetime)
listnode_add (list, first->dict_data);
- while (curr) {
- curr = dict_next (lspdb, curr);
- if (curr &&
- ((struct isis_lsp *)(curr->dict_data))->lsp_header->rem_lifetime)
- listnode_add (list, curr->dict_data);
- if (curr == last)
- break;
- }
-
+ while (curr)
+ {
+ curr = dict_next (lspdb, curr);
+ if (curr &&
+ ((struct isis_lsp *) (curr->dict_data))->lsp_header->rem_lifetime)
+ listnode_add (list, curr->dict_data);
+ if (curr == last)
+ break;
+ }
+
return;
}
/*
* Build a list of all LSPs bounded by start and stop ids
*/
-void
-lsp_build_list (u_char *start_id, u_char *stop_id,
- struct list *list, dict_t *lspdb)
+void
+lsp_build_list (u_char * start_id, u_char * stop_id,
+ struct list *list, dict_t * lspdb)
{
dnode_t *first, *last, *curr;
first = dict_lower_bound (lspdb, start_id);
if (!first)
return;
-
+
last = dict_upper_bound (lspdb, stop_id);
-
+
curr = first;
-
+
listnode_add (list, first->dict_data);
- while (curr) {
- curr = dict_next (lspdb, curr);
- if (curr)
- listnode_add (list, curr->dict_data);
- if (curr == last)
- break;
- }
-
+ while (curr)
+ {
+ curr = dict_next (lspdb, curr);
+ if (curr)
+ listnode_add (list, curr->dict_data);
+ if (curr == last)
+ break;
+ }
+
return;
}
@@ -580,21 +592,22 @@
* Build a list of LSPs with SSN flag set for the given circuit
*/
void
-lsp_build_list_ssn (struct isis_circuit *circuit, struct list *list,
- dict_t *lspdb)
+lsp_build_list_ssn (struct isis_circuit *circuit, struct list *list,
+ dict_t * lspdb)
{
dnode_t *dnode, *next;
struct isis_lsp *lsp;
-
+
dnode = dict_first (lspdb);
- while (dnode != NULL) {
- next = dict_next (lspdb, dnode);
- lsp = dnode_get (dnode);
- if (ISIS_CHECK_FLAG (lsp->SSNflags, circuit))
- listnode_add (list, lsp);
- dnode = next;
- }
-
+ while (dnode != NULL)
+ {
+ next = dict_next (lspdb, dnode);
+ lsp = dnode_get (dnode);
+ if (ISIS_CHECK_FLAG (lsp->SSNflags, circuit))
+ listnode_add (list, lsp);
+ dnode = next;
+ }
+
return;
}
@@ -602,31 +615,34 @@
lsp_set_time (struct isis_lsp *lsp)
{
assert (lsp);
-
- if (lsp->lsp_header->rem_lifetime == 0) {
- if (lsp->age_out != 0) lsp->age_out--;
- return;
- }
+
+ if (lsp->lsp_header->rem_lifetime == 0)
+ {
+ if (lsp->age_out != 0)
+ lsp->age_out--;
+ return;
+ }
/* If we are turning 0 */
/* ISO 10589 - 7.3.16.4 first paragraph */
- if (ntohs (lsp->lsp_header->rem_lifetime) == 1) {
- /* 7.3.16.4 a) set SRM flags on all */
- ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- /* 7.3.16.4 b) retain only the header FIXME */
- /* 7.3.16.4 c) record the time to purge FIXME (other way to do it)*/
- }
+ if (ntohs (lsp->lsp_header->rem_lifetime) == 1)
+ {
+ /* 7.3.16.4 a) set SRM flags on all */
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ /* 7.3.16.4 b) retain only the header FIXME */
+ /* 7.3.16.4 c) record the time to purge FIXME (other way to do it) */
+ }
- lsp->lsp_header->rem_lifetime =
+ lsp->lsp_header->rem_lifetime =
htons (ntohs (lsp->lsp_header->rem_lifetime) - 1);
}
void
-lspid_print (u_char *lsp_id, u_char *trg, char dynhost, char frag)
+lspid_print (u_char * lsp_id, u_char * trg, char dynhost, char frag)
{
struct isis_dynhn *dyn = NULL;
- u_char id [SYSID_STRLEN];
+ u_char id[SYSID_STRLEN];
if (dynhost)
dyn = dynhn_find_by_id (lsp_id);
@@ -636,74 +652,69 @@
if (dyn)
sprintf (id, "%.14s", dyn->name.name);
else if (!memcmp (isis->sysid, lsp_id, ISIS_SYS_ID_LEN) & dynhost)
- sprintf (id, "%.14s", unix_hostname());
- else {
- memcpy(id, sysid_print (lsp_id), 15);
- }
- if (frag)
- sprintf (trg, "%s.%02x-%02x", id, LSP_PSEUDO_ID(lsp_id),
- LSP_FRAGMENT(lsp_id));
+ sprintf (id, "%.14s", unix_hostname ());
else
- sprintf (trg, "%s.%02x", id, LSP_PSEUDO_ID(lsp_id));
+ {
+ memcpy (id, sysid_print (lsp_id), 15);
+ }
+ if (frag)
+ sprintf (trg, "%s.%02x-%02x", id, LSP_PSEUDO_ID (lsp_id),
+ LSP_FRAGMENT (lsp_id));
+ else
+ sprintf (trg, "%s.%02x", id, LSP_PSEUDO_ID (lsp_id));
}
-/* Convert the lsp attribute bits to attribute string */
-char *
-lsp_bits2string (u_char *lsp_bits) {
+/* Convert the lsp attribute bits to attribute string */
+char *
+lsp_bits2string (u_char * lsp_bits)
+{
+ char *pos = lsp_bits_string;
- char *pos = lsp_bits_string;
-
- if(!*lsp_bits)
+ if (!*lsp_bits)
return " none";
/* we only focus on the default metric */
pos += sprintf (pos, "%d/",
- ISIS_MASK_LSP_ATT_DEFAULT_BIT(*lsp_bits) ?
- 1 : 0);
+ ISIS_MASK_LSP_ATT_DEFAULT_BIT (*lsp_bits) ? 1 : 0);
pos += sprintf (pos, "%d/",
- ISIS_MASK_LSP_PARTITION_BIT(*lsp_bits) ?
- 1 : 0);
+ ISIS_MASK_LSP_PARTITION_BIT (*lsp_bits) ? 1 : 0);
- pos += sprintf (pos, "%d",
- ISIS_MASK_LSP_OL_BIT(*lsp_bits) ?
- 1 : 0);
-
+ pos += sprintf (pos, "%d", ISIS_MASK_LSP_OL_BIT (*lsp_bits) ? 1 : 0);
+
*(pos) = '\0';
-
- return lsp_bits_string;
+ return lsp_bits_string;
}
/* this function prints the lsp on show isis database */
void
-lsp_print (dnode_t *node, struct vty *vty, char dynhost)
+lsp_print (dnode_t * node, struct vty *vty, char dynhost)
{
- struct isis_lsp *lsp = dnode_get(node);
+ struct isis_lsp *lsp = dnode_get (node);
u_char LSPid[255];
lspid_print (lsp->lsp_header->lsp_id, LSPid, dynhost, 1);
- vty_out (vty, "%-21s%c ", LSPid,lsp->own_lsp?'*':' ');
- vty_out (vty, "0x%08x ", ntohl(lsp->lsp_header->seq_num));
- vty_out (vty, "0x%04x ", ntohs(lsp->lsp_header->checksum));
+ vty_out (vty, "%-21s%c ", LSPid, lsp->own_lsp ? '*' : ' ');
+ vty_out (vty, "0x%08x ", ntohl (lsp->lsp_header->seq_num));
+ vty_out (vty, "0x%04x ", ntohs (lsp->lsp_header->checksum));
- if (ntohs(lsp->lsp_header->rem_lifetime) == 0)
- vty_out (vty, " (%2u)",lsp->age_out);
+ if (ntohs (lsp->lsp_header->rem_lifetime) == 0)
+ vty_out (vty, " (%2u)", lsp->age_out);
else
- vty_out (vty, "%5u", ntohs(lsp->lsp_header->rem_lifetime));
+ vty_out (vty, "%5u", ntohs (lsp->lsp_header->rem_lifetime));
vty_out (vty, " %s%s",
- lsp_bits2string(&lsp->lsp_header->lsp_bits),
- VTY_NEWLINE);
+ lsp_bits2string (&lsp->lsp_header->lsp_bits), VTY_NEWLINE);
}
void
-lsp_print_detail (dnode_t *node, struct vty *vty, char dynhost)
+lsp_print_detail (dnode_t * node, struct vty *vty, char dynhost)
{
struct isis_lsp *lsp = dnode_get (node);
struct area_addr *area_addr;
- char nlpidstr[2];
- int i;
+ char nlpidstr[2];
+ int i;
struct listnode *lnode;
struct is_neigh *is_neigh;
struct te_is_neigh *te_is_neigh;
@@ -717,124 +728,124 @@
u_char LSPid[255];
u_char hostname[255];
u_char buff[BUFSIZ];
- u_int32_t now,helper;
+ u_int32_t now, helper;
u_char ipv4_reach_prefix[20];
u_char ipv4_reach_mask[20];
u_char ipv4_address[20];
lspid_print (lsp->lsp_header->lsp_id, LSPid, dynhost, 1);
- lsp_print(node, vty, dynhost);
+ lsp_print (node, vty, dynhost);
/* for all area address */
- if (lsp->tlv_data.area_addrs) {
- LIST_LOOP (lsp->tlv_data.area_addrs, area_addr, lnode) {
- vty_out (vty, " Area Address: %s%s",
- isonet_print (area_addr->area_addr, area_addr->addr_len),
- VTY_NEWLINE);
+ if (lsp->tlv_data.area_addrs)
+ {
+ LIST_LOOP (lsp->tlv_data.area_addrs, area_addr, lnode)
+ {
+ vty_out (vty, " Area Address: %s%s",
+ isonet_print (area_addr->area_addr, area_addr->addr_len),
+ VTY_NEWLINE);
+ }
}
- }
/* for the nlpid tlv */
- if (lsp->tlv_data.nlpids) {
- for (i = 0; i < lsp->tlv_data.nlpids->count; i++) {
- switch (lsp->tlv_data.nlpids->nlpids[i]) {
- case NLPID_IP:
- case NLPID_IPV6:
- vty_out (vty, " NLPID: 0x%X%s",
- lsp->tlv_data.nlpids->nlpids[i],
- VTY_NEWLINE);
- break;
- default:
- vty_out (vty, " NLPID: %s%s",
- "unknown",
- VTY_NEWLINE);
- break;
- }
- }
- }
+ if (lsp->tlv_data.nlpids)
+ {
+ for (i = 0; i < lsp->tlv_data.nlpids->count; i++)
+ {
+ switch (lsp->tlv_data.nlpids->nlpids[i])
+ {
+ case NLPID_IP:
+ case NLPID_IPV6:
+ vty_out (vty, " NLPID: 0x%X%s",
+ lsp->tlv_data.nlpids->nlpids[i], VTY_NEWLINE);
+ break;
+ default:
+ vty_out (vty, " NLPID: %s%s", "unknown", VTY_NEWLINE);
+ break;
+ }
+ }
+ }
/* for the hostname tlv */
- if (lsp->tlv_data.hostname) {
- bzero (hostname, sizeof (hostname));
- memcpy (hostname, lsp->tlv_data.hostname->name,
- lsp->tlv_data.hostname->namelen);
- vty_out (vty, " Hostname: %s%s", hostname, VTY_NEWLINE);
- }
-
- if (lsp->tlv_data.ipv4_addrs) {
- LIST_LOOP(lsp->tlv_data.ipv4_addrs, ipv4_addr, lnode) {
- memcpy (ipv4_address, inet_ntoa (*ipv4_addr), sizeof (ipv4_address));
- vty_out (vty, " IP: %s%s",
- ipv4_address,
- VTY_NEWLINE);
+ if (lsp->tlv_data.hostname)
+ {
+ bzero (hostname, sizeof (hostname));
+ memcpy (hostname, lsp->tlv_data.hostname->name,
+ lsp->tlv_data.hostname->namelen);
+ vty_out (vty, " Hostname: %s%s", hostname, VTY_NEWLINE);
}
- }
-
+
+ if (lsp->tlv_data.ipv4_addrs)
+ {
+ LIST_LOOP (lsp->tlv_data.ipv4_addrs, ipv4_addr, lnode)
+ {
+ memcpy (ipv4_address, inet_ntoa (*ipv4_addr), sizeof (ipv4_address));
+ vty_out (vty, " IP: %s%s", ipv4_address, VTY_NEWLINE);
+ }
+ }
+
/* for the internal reachable tlv */
if (lsp->tlv_data.ipv4_int_reachs)
- LIST_LOOP(lsp->tlv_data.ipv4_int_reachs, ipv4_reach, lnode) {
- memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix), sizeof (ipv4_reach_prefix));
- memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask), sizeof (ipv4_reach_mask));
+ LIST_LOOP (lsp->tlv_data.ipv4_int_reachs, ipv4_reach, lnode)
+ {
+ memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix),
+ sizeof (ipv4_reach_prefix));
+ memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask),
+ sizeof (ipv4_reach_mask));
vty_out (vty, " Metric: %d IP %s %s%s",
- ipv4_reach->metrics.metric_default,
- ipv4_reach_prefix,
- ipv4_reach_mask,
- VTY_NEWLINE);
- }
+ ipv4_reach->metrics.metric_default, ipv4_reach_prefix,
+ ipv4_reach_mask, VTY_NEWLINE);
+ }
/* for the external reachable tlv */
if (lsp->tlv_data.ipv4_ext_reachs)
- LIST_LOOP(lsp->tlv_data.ipv4_ext_reachs, ipv4_reach, lnode) {
- memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix), sizeof (ipv4_reach_prefix));
- memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask), sizeof (ipv4_reach_mask));
+ LIST_LOOP (lsp->tlv_data.ipv4_ext_reachs, ipv4_reach, lnode)
+ {
+ memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix),
+ sizeof (ipv4_reach_prefix));
+ memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask),
+ sizeof (ipv4_reach_mask));
vty_out (vty, " Metric: %d IP-External %s %s%s",
- ipv4_reach->metrics.metric_default,
- ipv4_reach_prefix,
- ipv4_reach_mask,
- VTY_NEWLINE);
- }
+ ipv4_reach->metrics.metric_default, ipv4_reach_prefix,
+ ipv4_reach_mask, VTY_NEWLINE);
+ }
/* for the IS neighbor tlv */
- if (lsp->tlv_data.is_neighs) {
- LIST_LOOP(lsp->tlv_data.is_neighs,is_neigh,lnode) {
- lspid_print (is_neigh->neigh_id, LSPid, dynhost, 0);
- vty_out (vty, " Metric: %d IS %s%s",
- is_neigh->metrics.metric_default,
- LSPid,
- VTY_NEWLINE);
+ if (lsp->tlv_data.is_neighs)
+ {
+ LIST_LOOP (lsp->tlv_data.is_neighs, is_neigh, lnode)
+ {
+ lspid_print (is_neigh->neigh_id, LSPid, dynhost, 0);
+ vty_out (vty, " Metric: %d IS %s%s",
+ is_neigh->metrics.metric_default, LSPid, VTY_NEWLINE);
+ }
}
- }
/* IPv6 tlv */
#ifdef HAVE_IPV6
if (lsp->tlv_data.ipv6_reachs)
- LIST_LOOP(lsp->tlv_data.ipv6_reachs, ipv6_reach, lnode) {
- memset(&in6, 0, sizeof(in6));
- memcpy (in6.s6_addr, ipv6_reach->prefix, PSIZE(ipv6_reach->prefix_len));
+ LIST_LOOP (lsp->tlv_data.ipv6_reachs, ipv6_reach, lnode)
+ {
+ memset (&in6, 0, sizeof (in6));
+ memcpy (in6.s6_addr, ipv6_reach->prefix,
+ PSIZE (ipv6_reach->prefix_len));
inet_ntop (AF_INET6, &in6, buff, BUFSIZ);
if ((ipv6_reach->control_info &&
- CTRL_INFO_DISTRIBUTION) == DISTRIBUTION_INTERNAL)
- vty_out (vty, " Metric: %d IPv6-Intern %s/%d%s",
- ntohl (ipv6_reach->metric),
- buff,
- ipv6_reach->prefix_len,
- VTY_NEWLINE);
+ CTRL_INFO_DISTRIBUTION) == DISTRIBUTION_INTERNAL)
+ vty_out (vty, " Metric: %d IPv6-Intern %s/%d%s",
+ ntohl (ipv6_reach->metric),
+ buff, ipv6_reach->prefix_len, VTY_NEWLINE);
else
- vty_out (vty, " Metric: %d IPv6-Extern %s/%d%s",
- ntohl (ipv6_reach->metric),
- buff,
- ipv6_reach->prefix_len,
- VTY_NEWLINE);
+ vty_out (vty, " Metric: %d IPv6-Extern %s/%d%s",
+ ntohl (ipv6_reach->metric),
+ buff, ipv6_reach->prefix_len, VTY_NEWLINE);
}
#endif
/* FIXME: Other tlvs such as te or external tlv will be added later */
-#if 0
+#if 0
vty_out (vty, "%s %s %c%s",
- VTY_NEWLINE,
- LSPid,
- lsp->own_lsp ? '*' : ' ',
- VTY_NEWLINE);
+ VTY_NEWLINE, LSPid, lsp->own_lsp ? '*' : ' ', VTY_NEWLINE);
vty_out (vty, " Sequence: 0x%08x Checksum: 0x%04x Lifetime: ",
ntohl (lsp->lsp_header->seq_num),
@@ -846,8 +857,7 @@
vty_out (vty, "%5u ", ntohs (lsp->lsp_header->rem_lifetime));
vty_out (vty, "%s Attributes:%s",
- VTY_NEWLINE,
- lsp_bits2string (&lsp->lsp_header->lsp_bits));
+ VTY_NEWLINE, lsp_bits2string (&lsp->lsp_header->lsp_bits));
/* if this is a self originated LSP then print
* the generation time plus when we sent it last
@@ -855,152 +865,158 @@
* time when the LSP has been installed
*/
- if (lsp->own_lsp) {
+ if (lsp->own_lsp)
+ {
- now = time (NULL);
- helper = now - lsp->last_generated;
- if (!lsp->last_generated)
- helper = 0;
+ now = time (NULL);
+ helper = now - lsp->last_generated;
+ if (!lsp->last_generated)
+ helper = 0;
- vty_out (vty, ", Generated: %s ago",
- time2string (helper));
+ vty_out (vty, ", Generated: %s ago", time2string (helper));
- now = time (NULL);
- helper = now - lsp->last_sent;
- if (!lsp->last_sent)
- helper = 0;
+ now = time (NULL);
+ helper = now - lsp->last_sent;
+ if (!lsp->last_sent)
+ helper = 0;
- vty_out (vty, ", Last sent: %s ago",
- time2string (helper));
- } else {
- now = time (NULL);
- helper = now - lsp->installed;
- if (!lsp->installed)
- helper = 0;
+ vty_out (vty, ", Last sent: %s ago", time2string (helper));
+ }
+ else
+ {
+ now = time (NULL);
+ helper = now - lsp->installed;
+ if (!lsp->installed)
+ helper = 0;
- vty_out (vty, ", Installed: %s ago",
- time2string (helper));
+ vty_out (vty, ", Installed: %s ago", time2string (helper));
- }
+ }
vty_out (vty, "%s", VTY_NEWLINE);
- if (lsp->tlv_data.nlpids) {
- vty_out (vty, " Speaks: %s%s", nlpid2string (lsp->tlv_data.nlpids),
- VTY_NEWLINE);
- }
+ if (lsp->tlv_data.nlpids)
+ {
+ vty_out (vty, " Speaks: %s%s", nlpid2string (lsp->tlv_data.nlpids),
+ VTY_NEWLINE);
+ }
- if (lsp->tlv_data.router_id) {
- vty_out (vty, " Router ID: %s%s",
- inet_ntoa (lsp->tlv_data.router_id->id), VTY_NEWLINE);
- }
+ if (lsp->tlv_data.router_id)
+ {
+ vty_out (vty, " Router ID: %s%s",
+ inet_ntoa (lsp->tlv_data.router_id->id), VTY_NEWLINE);
+ }
if (lsp->tlv_data.is_neighs)
- LIST_LOOP(lsp->tlv_data.is_neighs,is_neigh,lnode) {
- lspid_print (is_neigh->neigh_id, LSPid, dynhost, 0);
- vty_out (vty, " IS %s, Metric: %d%s",
- LSPid,
- is_neigh->metrics.metric_default,
- VTY_NEWLINE);
- }
+ LIST_LOOP (lsp->tlv_data.is_neighs, is_neigh, lnode)
+ {
+ lspid_print (is_neigh->neigh_id, LSPid, dynhost, 0);
+ vty_out (vty, " IS %s, Metric: %d%s",
+ LSPid, is_neigh->metrics.metric_default, VTY_NEWLINE);
+ }
if (lsp->tlv_data.te_is_neighs)
- LIST_LOOP(lsp->tlv_data.te_is_neighs,te_is_neigh,lnode) {
- /* FIXME: metric display is wrong */
- lspid_print (te_is_neigh->neigh_id, LSPid, dynhost, 0);
- vty_out (vty, " extd-IS %s, Metric: %d%s",
- LSPid,
- te_is_neigh->te_metric[0],
- VTY_NEWLINE);
- }
+ LIST_LOOP (lsp->tlv_data.te_is_neighs, te_is_neigh, lnode)
+ {
+ /* FIXME: metric display is wrong */
+ lspid_print (te_is_neigh->neigh_id, LSPid, dynhost, 0);
+ vty_out (vty, " extd-IS %s, Metric: %d%s",
+ LSPid, te_is_neigh->te_metric[0], VTY_NEWLINE);
+ }
if (lsp->tlv_data.ipv4_int_reachs)
- LIST_LOOP(lsp->tlv_data.ipv4_int_reachs, ipv4_reach, lnode) {
- vty_out (vty, " int-IP %s/%d, Metric: %d%s",
- inet_ntoa (ipv4_reach->prefix),
- ip_masklen (ipv4_reach->mask),
- ipv4_reach->metrics.metric_default,
- VTY_NEWLINE);
- }
+ LIST_LOOP (lsp->tlv_data.ipv4_int_reachs, ipv4_reach, lnode)
+ {
+ vty_out (vty, " int-IP %s/%d, Metric: %d%s",
+ inet_ntoa (ipv4_reach->prefix),
+ ip_masklen (ipv4_reach->mask),
+ ipv4_reach->metrics.metric_default, VTY_NEWLINE);
+ }
if (lsp->tlv_data.ipv4_ext_reachs)
- LIST_LOOP(lsp->tlv_data.ipv4_ext_reachs,ipv4_reach,lnode) {
- vty_out (vty, " ext-IP %s/%d, Metric: %d%s",
- inet_ntoa(ipv4_reach->prefix),
- ip_masklen(ipv4_reach->mask),
- ipv4_reach->metrics.metric_default,
- VTY_NEWLINE);
- }
+ LIST_LOOP (lsp->tlv_data.ipv4_ext_reachs, ipv4_reach, lnode)
+ {
+ vty_out (vty, " ext-IP %s/%d, Metric: %d%s",
+ inet_ntoa (ipv4_reach->prefix),
+ ip_masklen (ipv4_reach->mask),
+ ipv4_reach->metrics.metric_default, VTY_NEWLINE);
+ }
if (lsp->tlv_data.te_ipv4_reachs)
- LIST_LOOP(lsp->tlv_data.te_ipv4_reachs,te_ipv4_reach,lnode) {
- vty_out (vty, " extd-IP %s/%d, Metric: %d%s",
- inet_ntoa ( newprefix2inaddr (&te_ipv4_reach->prefix_start,
- te_ipv4_reach->control)),
- te_ipv4_reach->control & 0x3F,
- ntohl (te_ipv4_reach->te_metric),
- VTY_NEWLINE);
- }
+ LIST_LOOP (lsp->tlv_data.te_ipv4_reachs, te_ipv4_reach, lnode)
+ {
+ vty_out (vty, " extd-IP %s/%d, Metric: %d%s",
+ inet_ntoa (newprefix2inaddr (&te_ipv4_reach->prefix_start,
+ te_ipv4_reach->control)),
+ te_ipv4_reach->control & 0x3F,
+ ntohl (te_ipv4_reach->te_metric), VTY_NEWLINE);
+ }
#ifdef HAVE_IPV6
if (lsp->tlv_data.ipv6_reachs)
- LIST_LOOP(lsp->tlv_data.ipv6_reachs, ipv6_reach, lnode) {
- memcpy (in6.s6_addr, ipv6_reach->prefix, 16);
- inet_ntop (AF_INET6, &in6, buff, BUFSIZ);
- if ((ipv6_reach->control_info &&
- CTRL_INFO_DISTRIBUTION) == DISTRIBUTION_INTERNAL)
- vty_out (vty, " int-IPv6 %s/%d, Metric: %d%s",
- buff,
- ipv6_reach->prefix_len,
- ntohl (ipv6_reach->metric),
- VTY_NEWLINE);
- else
- vty_out (vty, " ext-IPv6 %s/%d, Metric: %d%s",
- buff,
- ipv6_reach->prefix_len,
- ntohl (ipv6_reach->metric),
- VTY_NEWLINE);
-
- }
+ LIST_LOOP (lsp->tlv_data.ipv6_reachs, ipv6_reach, lnode)
+ {
+ memcpy (in6.s6_addr, ipv6_reach->prefix, 16);
+ inet_ntop (AF_INET6, &in6, buff, BUFSIZ);
+ if ((ipv6_reach->control_info &&
+ CTRL_INFO_DISTRIBUTION) == DISTRIBUTION_INTERNAL)
+ vty_out (vty, " int-IPv6 %s/%d, Metric: %d%s",
+ buff,
+ ipv6_reach->prefix_len,
+ ntohl (ipv6_reach->metric), VTY_NEWLINE);
+ else
+ vty_out (vty, " ext-IPv6 %s/%d, Metric: %d%s",
+ buff,
+ ipv6_reach->prefix_len,
+ ntohl (ipv6_reach->metric), VTY_NEWLINE);
+
+ }
#endif
- if (lsp->tlv_data.hostname) {
- memset (hostname, 0, sizeof (hostname));
- memcpy (hostname, lsp->tlv_data.hostname->name,
- lsp->tlv_data.hostname->namelen);
- vty_out (vty, " Hostname: %s%s", hostname, VTY_NEWLINE);
- }
+ if (lsp->tlv_data.hostname)
+ {
+ memset (hostname, 0, sizeof (hostname));
+ memcpy (hostname, lsp->tlv_data.hostname->name,
+ lsp->tlv_data.hostname->namelen);
+ vty_out (vty, " Hostname: %s%s", hostname, VTY_NEWLINE);
+ }
#endif
- return;
+ return;
}
/* print all the lsps info in the local lspdb */
-int
-lsp_print_all (struct vty *vty, dict_t *lspdb, char detail, char dynhost)
+int
+lsp_print_all (struct vty *vty, dict_t * lspdb, char detail, char dynhost)
{
- dnode_t *node = dict_first(lspdb), *next;
+ dnode_t *node = dict_first (lspdb), *next;
int lsp_count = 0;
/* print the title, for both modes */
vty_out (vty, "LSP ID LSP Seq Num LSP Checksum "
- "LSP Holdtime ATT/P/OL%s", VTY_NEWLINE);
-
- if (detail == ISIS_UI_LEVEL_BRIEF) {
- while (node != NULL) {
- /* dict_contains (lspdb, node); */ /* I think it is unnecessary, so I comment it out */
- next = dict_next (lspdb, node);
- lsp_print (node, vty, dynhost);
- node = next;
- lsp_count++;
+ "LSP Holdtime ATT/P/OL%s", VTY_NEWLINE);
+
+ if (detail == ISIS_UI_LEVEL_BRIEF)
+ {
+ while (node != NULL)
+ {
+ /* I think it is unnecessary, so I comment it out */
+ /* dict_contains (lspdb, node); */
+ next = dict_next (lspdb, node);
+ lsp_print (node, vty, dynhost);
+ node = next;
+ lsp_count++;
+ }
}
- } else if (detail == ISIS_UI_LEVEL_DETAIL) {
- while (node != NULL) {
- next = dict_next (lspdb, node);
- lsp_print_detail (node, vty, dynhost);
- node = next;
- lsp_count++;
+ else if (detail == ISIS_UI_LEVEL_DETAIL)
+ {
+ while (node != NULL)
+ {
+ next = dict_next (lspdb, node);
+ lsp_print_detail (node, vty, dynhost);
+ node = next;
+ lsp_count++;
+ }
}
- }
return lsp_count;
}
@@ -1009,31 +1025,30 @@
* size of memory, it scans the lsp and moves all pointers the
* way they should */
u_char *
-lsppdu_realloc (struct isis_lsp *lsp, int memorytype, int size)
+lsppdu_realloc (struct isis_lsp * lsp, int memorytype, int size)
{
u_char *retval;
-
- retval = STREAM_DATA(lsp->pdu) + ntohs(lsp->lsp_header->pdu_len);
+
+ retval = STREAM_DATA (lsp->pdu) + ntohs (lsp->lsp_header->pdu_len);
#ifdef LSP_MEMORY_PREASSIGN
- lsp->lsp_header->pdu_len = htons(ntohs(lsp->lsp_header->pdu_len) + size);
+ lsp->lsp_header->pdu_len = htons (ntohs (lsp->lsp_header->pdu_len) + size);
return retval;
-#else /* otherwise we have to move all pointers */
+#else /* otherwise we have to move all pointers */
u_char *newpdu;
newpdu = stream_new (ntohs (lsp->lsp_header->pdu_len) + size);
- memcpy (STREAM_DATA (newpdu), STREAM_DATA(lsp->pdu),
- ntohs (lsp->lsp_header->pdu_len));
+ memcpy (STREAM_DATA (newpdu), STREAM_DATA (lsp->pdu),
+ ntohs (lsp->lsp_header->pdu_len));
XFREE (memorytype, lsp->pdu);
lsp->pdu = newpdu;
- lsp->isis_header = (struct isis_fixed_hdr*)STREAM_DATA(lsp->pdu);
- lsp->lsp_header = (struct isis_link_state_hdr*)
- (STREAM_DATA(lsp->pdu) + ISIS_FIXED_HDR_LEN);
+ lsp->isis_header = (struct isis_fixed_hdr *) STREAM_DATA (lsp->pdu);
+ lsp->lsp_header = (struct isis_link_state_hdr *)
+ (STREAM_DATA (lsp->pdu) + ISIS_FIXED_HDR_LEN);
htons (ntohs (lsp->lsp_header->pdu_len) += size);
- return STREAM_DATA(lsp->pdu) + (lsp->lsp_header->pdu_len - size);
+ return STREAM_DATA (lsp->pdu) + (lsp->lsp_header->pdu_len - size);
#endif /* LSP_MEMORY_PREASSIGN */
}
-
-#if 0 /* Saving the old one just in case :) */
+#if 0 /* Saving the old one just in case :) */
/*
* Builds the lsp->tlv_data
* and writes the tlvs into lsp->pdu
@@ -1052,181 +1067,200 @@
struct prefix_ipv6 *ipv6;
struct ipv6_reachability *ip6reach;
#endif /* HAVE_IPV6 */
-
+
/*
* First add the tlvs related to area
*/
-
+
/* Area addresses */
if (lsp->tlv_data.area_addrs == NULL)
lsp->tlv_data.area_addrs = list_new ();
list_add_list (lsp->tlv_data.area_addrs, area->area_addrs);
/* Protocols Supported */
- if (area->ip_circuits > 0
+ if (area->ip_circuits > 0
#ifdef HAVE_IPV6
|| area->ipv6_circuits > 0
#endif /* HAVE_IPV6 */
- )
+ )
{
lsp->tlv_data.nlpids = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct nlpids));
lsp->tlv_data.nlpids->count = 0;
- if (area->ip_circuits > 0) {
- lsp->tlv_data.nlpids->count++;
- lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
- }
+ if (area->ip_circuits > 0)
+ {
+ lsp->tlv_data.nlpids->count++;
+ lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
+ }
#ifdef HAVE_IPV6
- if (area->ipv6_circuits > 0) {
- lsp->tlv_data.nlpids->count++;
- lsp->tlv_data.nlpids->nlpids[lsp->tlv_data.nlpids->count - 1] =
- NLPID_IPV6;
- }
+ if (area->ipv6_circuits > 0)
+ {
+ lsp->tlv_data.nlpids->count++;
+ lsp->tlv_data.nlpids->nlpids[lsp->tlv_data.nlpids->count - 1] =
+ NLPID_IPV6;
+ }
#endif /* HAVE_IPV6 */
}
/* Dynamic Hostname */
- if (area->dynhostname) {
- lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
- sizeof (struct hostname));
- memcpy (&lsp->tlv_data.hostname->name, unix_hostname(),
- strlen(unix_hostname()));
- lsp->tlv_data.hostname->namelen = strlen (unix_hostname());
- }
+ if (area->dynhostname)
+ {
+ lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
+ sizeof (struct hostname));
+ memcpy (&lsp->tlv_data.hostname->name, unix_hostname (),
+ strlen (unix_hostname ()));
+ lsp->tlv_data.hostname->namelen = strlen (unix_hostname ());
+ }
#ifdef TOPOLOGY_GENERATE
/*
* If we have a topology in this area, we need to connect this lsp to
* the first topology lsp
*/
- if ((area->topology) && (level == 1)) {
- if (lsp->tlv_data.is_neighs == NULL)
- lsp->tlv_data.is_neighs = list_new ();
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
- /* connected to the first */
- is_neigh->neigh_id[ISIS_SYS_ID_LEN-1] = (0x01);
- /* this is actually the same system, why mess the SPT */
- is_neigh->metrics.metric_default = 0;
- is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
- is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
- is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ if ((area->topology) && (level == 1))
+ {
+ if (lsp->tlv_data.is_neighs == NULL)
+ lsp->tlv_data.is_neighs = list_new ();
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
+ /* connected to the first */
+ is_neigh->neigh_id[ISIS_SYS_ID_LEN - 1] = (0x01);
+ /* this is actually the same system, why mess the SPT */
+ is_neigh->metrics.metric_default = 0;
+ is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
+ is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
+ is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- }
+ }
#endif
/*
* Then add tlvs related to circuits
*/
- for (node = listhead (area->circuit_list); node; nextnode (node)) {
- circuit = getdata (node);
- if (circuit->state != C_STATE_UP)
- continue;
-
- /*
- * Add IPv4 internal reachability of this circuit
- */
- if (circuit->ip_router && circuit->ip_addrs &&
- circuit->ip_addrs->count > 0) {
- if (lsp->tlv_data.ipv4_int_reachs == NULL) {
- lsp->tlv_data.ipv4_int_reachs = list_new ();
- lsp->tlv_data.ipv4_int_reachs->del = free_tlv;
- }
- for (ipnode = listhead (circuit->ip_addrs); ipnode; nextnode (ipnode)) {
- ipv4 = getdata (ipnode);
- ipreach = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv4_reachability));
- ipreach->metrics = circuit->metrics[level - 1];
- ipreach->prefix = ipv4->prefix;
- masklen2ip (ipv4->prefixlen, &ipreach->mask);
- listnode_add (lsp->tlv_data.ipv4_int_reachs, ipreach);
- }
- }
+ for (node = listhead (area->circuit_list); node; nextnode (node))
+ {
+ circuit = getdata (node);
+ if (circuit->state != C_STATE_UP)
+ continue;
+
+ /*
+ * Add IPv4 internal reachability of this circuit
+ */
+ if (circuit->ip_router && circuit->ip_addrs &&
+ circuit->ip_addrs->count > 0)
+ {
+ if (lsp->tlv_data.ipv4_int_reachs == NULL)
+ {
+ lsp->tlv_data.ipv4_int_reachs = list_new ();
+ lsp->tlv_data.ipv4_int_reachs->del = free_tlv;
+ }
+ for (ipnode = listhead (circuit->ip_addrs); ipnode;
+ nextnode (ipnode))
+ {
+ ipv4 = getdata (ipnode);
+ ipreach =
+ XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv4_reachability));
+ ipreach->metrics = circuit->metrics[level - 1];
+ ipreach->prefix = ipv4->prefix;
+ masklen2ip (ipv4->prefixlen, &ipreach->mask);
+ listnode_add (lsp->tlv_data.ipv4_int_reachs, ipreach);
+ }
+ }
#ifdef HAVE_IPV6
- /*
- * Add IPv6 reachability of this circuit
- */
- if (circuit->ipv6_router && circuit->ipv6_non_link &&
- circuit->ipv6_non_link->count > 0) {
- if (lsp->tlv_data.ipv6_reachs == NULL) {
- lsp->tlv_data.ipv6_reachs = list_new ();
- lsp->tlv_data.ipv6_reachs->del = free_tlv;
- }
- for (ipnode = listhead (circuit->ipv6_non_link); ipnode;
- nextnode (ipnode)) {
- ipv6 = getdata (ipnode);
- ip6reach = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv6_reachability));
- memset (ip6reach, 0, sizeof (struct ipv6_reachability));
- ip6reach->metric = htonl(circuit->metrics[level - 1].metric_default);
- ip6reach->control_info = 0;
- ip6reach->prefix_len = ipv6->prefixlen;
- memcpy (&ip6reach->prefix, ipv6->prefix.s6_addr,
- (ipv6->prefixlen + 7) / 8);
- listnode_add (lsp->tlv_data.ipv6_reachs, ip6reach);
- }
- }
+ /*
+ * Add IPv6 reachability of this circuit
+ */
+ if (circuit->ipv6_router && circuit->ipv6_non_link &&
+ circuit->ipv6_non_link->count > 0)
+ {
+ if (lsp->tlv_data.ipv6_reachs == NULL)
+ {
+ lsp->tlv_data.ipv6_reachs = list_new ();
+ lsp->tlv_data.ipv6_reachs->del = free_tlv;
+ }
+ for (ipnode = listhead (circuit->ipv6_non_link); ipnode;
+ nextnode (ipnode))
+ {
+ ipv6 = getdata (ipnode);
+ ip6reach =
+ XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv6_reachability));
+ memset (ip6reach, 0, sizeof (struct ipv6_reachability));
+ ip6reach->metric =
+ htonl (circuit->metrics[level - 1].metric_default);
+ ip6reach->control_info = 0;
+ ip6reach->prefix_len = ipv6->prefixlen;
+ memcpy (&ip6reach->prefix, ipv6->prefix.s6_addr,
+ (ipv6->prefixlen + 7) / 8);
+ listnode_add (lsp->tlv_data.ipv6_reachs, ip6reach);
+ }
+ }
#endif /* HAVE_IPV6 */
-
- switch (circuit->circ_type) {
- case CIRCUIT_T_BROADCAST:
- if (level & circuit->circuit_is_type) {
- if (lsp->tlv_data.is_neighs == NULL) {
- lsp->tlv_data.is_neighs = list_new ();
- lsp->tlv_data.is_neighs->del = free_tlv;
- }
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- if (level == 1)
- memcpy (&is_neigh->neigh_id,
- circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
- else
- memcpy (&is_neigh->neigh_id,
- circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
- is_neigh->metrics = circuit->metrics[level - 1];
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- }
- break;
- case CIRCUIT_T_P2P:
- nei = circuit->u.p2p.neighbor;
- if (nei && (level & nei->circuit_t)) {
- if (lsp->tlv_data.is_neighs == NULL) {
- lsp->tlv_data.is_neighs = list_new ();
- lsp->tlv_data.is_neighs->del = free_tlv;
- }
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- memcpy (&is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
- is_neigh->metrics = circuit->metrics[level - 1];
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- }
- break;
- case CIRCUIT_T_STATIC_IN:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- case CIRCUIT_T_STATIC_OUT:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- case CIRCUIT_T_DA:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- default:
- zlog_warn ("lsp_area_create: unknown circuit type");
+
+ switch (circuit->circ_type)
+ {
+ case CIRCUIT_T_BROADCAST:
+ if (level & circuit->circuit_is_type)
+ {
+ if (lsp->tlv_data.is_neighs == NULL)
+ {
+ lsp->tlv_data.is_neighs = list_new ();
+ lsp->tlv_data.is_neighs->del = free_tlv;
+ }
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ if (level == 1)
+ memcpy (&is_neigh->neigh_id,
+ circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
+ else
+ memcpy (&is_neigh->neigh_id,
+ circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
+ is_neigh->metrics = circuit->metrics[level - 1];
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ }
+ break;
+ case CIRCUIT_T_P2P:
+ nei = circuit->u.p2p.neighbor;
+ if (nei && (level & nei->circuit_t))
+ {
+ if (lsp->tlv_data.is_neighs == NULL)
+ {
+ lsp->tlv_data.is_neighs = list_new ();
+ lsp->tlv_data.is_neighs->del = free_tlv;
+ }
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ memcpy (&is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
+ is_neigh->metrics = circuit->metrics[level - 1];
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ }
+ break;
+ case CIRCUIT_T_STATIC_IN:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ case CIRCUIT_T_STATIC_OUT:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ case CIRCUIT_T_DA:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ default:
+ zlog_warn ("lsp_area_create: unknown circuit type");
+ }
}
- }
-
+
stream_set_putp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
-
+
if (lsp->tlv_data.nlpids)
tlv_add_nlpid (lsp->tlv_data.nlpids, lsp->pdu);
if (lsp->tlv_data.hostname)
tlv_add_dynamic_hostname (lsp->tlv_data.hostname, lsp->pdu);
- if (lsp->tlv_data.area_addrs && listcount (lsp->tlv_data.area_addrs) > 0 )
+ if (lsp->tlv_data.area_addrs && listcount (lsp->tlv_data.area_addrs) > 0)
tlv_add_area_addrs (lsp->tlv_data.area_addrs, lsp->pdu);
if (lsp->tlv_data.is_neighs && listcount (lsp->tlv_data.is_neighs) > 0)
tlv_add_is_neighs (lsp->tlv_data.is_neighs, lsp->pdu);
- if (lsp->tlv_data.ipv4_int_reachs &&
+ if (lsp->tlv_data.ipv4_int_reachs &&
listcount (lsp->tlv_data.ipv4_int_reachs) > 0)
tlv_add_ipv4_reachs (lsp->tlv_data.ipv4_int_reachs, lsp->pdu);
-#ifdef HAVE_IPV6
- if (lsp->tlv_data.ipv6_reachs &&
- listcount (lsp->tlv_data.ipv6_reachs) > 0)
+#ifdef HAVE_IPV6
+ if (lsp->tlv_data.ipv6_reachs && listcount (lsp->tlv_data.ipv6_reachs) > 0)
tlv_add_ipv6_reachs (lsp->tlv_data.ipv6_reachs, lsp->pdu);
#endif /* HAVE_IPV6 */
@@ -1245,73 +1279,79 @@
void
lsp_tlv_fit (struct isis_lsp *lsp, struct list **from, struct list **to,
- int tlvsize, int frag_thold,
- int tlv_build_func(struct list *, struct stream *))
+ int tlvsize, int frag_thold,
+ int tlv_build_func (struct list *, struct stream *))
{
int count, i;
-
+
/* can we fit all ? */
- if (!FRAG_NEEDED(lsp->pdu, frag_thold,
- listcount(*from) * tlvsize + 2)) {
- tlv_build_func (*from, lsp->pdu);
- *to = *from;
- *from = NULL;
- } else if (!FRAG_NEEDED(lsp->pdu, frag_thold, tlvsize + 2)) {
- /* fit all we can */
- count = FRAG_THOLD(lsp->pdu,frag_thold) - 2 -
- (STREAM_SIZE(lsp->pdu) - STREAM_REMAIN(lsp->pdu));
- if (count)
- count = count / tlvsize;
- for (i = 0; i < count; i++) {
- listnode_add (*to, getdata(listhead(*from)));
- listnode_delete(*from, getdata(listhead(*from)));
+ if (!FRAG_NEEDED (lsp->pdu, frag_thold, listcount (*from) * tlvsize + 2))
+ {
+ tlv_build_func (*from, lsp->pdu);
+ *to = *from;
+ *from = NULL;
}
- tlv_build_func (*to, lsp->pdu);
- }
- lsp->lsp_header->pdu_len = htons (stream_get_putp (lsp->pdu));
+ else if (!FRAG_NEEDED (lsp->pdu, frag_thold, tlvsize + 2))
+ {
+ /* fit all we can */
+ count = FRAG_THOLD (lsp->pdu, frag_thold) - 2 -
+ (STREAM_SIZE (lsp->pdu) - STREAM_REMAIN (lsp->pdu));
+ if (count)
+ count = count / tlvsize;
+ for (i = 0; i < count; i++)
+ {
+ listnode_add (*to, getdata (listhead (*from)));
+ listnode_delete (*from, getdata (listhead (*from)));
+ }
+ tlv_build_func (*to, lsp->pdu);
+ }
+ lsp->lsp_header->pdu_len = htons (stream_get_putp (lsp->pdu));
return;
}
-struct isis_lsp *
-lsp_next_frag (u_char frag_num, struct isis_lsp *lsp0, struct isis_area *area,
- int level )
+struct isis_lsp *
+lsp_next_frag (u_char frag_num, struct isis_lsp *lsp0, struct isis_area *area,
+ int level)
{
struct isis_lsp *lsp;
- u_char frag_id[ISIS_SYS_ID_LEN + 2];
-
+ u_char frag_id[ISIS_SYS_ID_LEN + 2];
+
memcpy (frag_id, lsp0->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 1);
LSP_FRAGMENT (frag_id) = frag_num;
lsp = lsp_search (frag_id, area->lspdb[level - 1]);
- if (lsp) {
- /*
- * Clear the TLVs, but inherit the authinfo
- */
- lsp_clear_data (lsp);
- if (lsp0->tlv_data.auth_info.type) {
- memcpy (&lsp->tlv_data.auth_info, &lsp->tlv_data.auth_info,
- sizeof (struct isis_passwd));
- tlv_add_authinfo (lsp->tlv_data.auth_info.type,
- lsp->tlv_data.auth_info.len,
- lsp->tlv_data.auth_info.passwd, lsp->pdu);
+ if (lsp)
+ {
+ /*
+ * Clear the TLVs, but inherit the authinfo
+ */
+ lsp_clear_data (lsp);
+ if (lsp0->tlv_data.auth_info.type)
+ {
+ memcpy (&lsp->tlv_data.auth_info, &lsp->tlv_data.auth_info,
+ sizeof (struct isis_passwd));
+ tlv_add_authinfo (lsp->tlv_data.auth_info.type,
+ lsp->tlv_data.auth_info.len,
+ lsp->tlv_data.auth_info.passwd, lsp->pdu);
+ }
+ return lsp;
}
- return lsp;
- }
lsp = lsp_new (frag_id, area->max_lsp_lifetime[level - 1], 0, area->is_type,
- 0, level);
+ 0, level);
lsp->own_lsp = 1;
- lsp_insert (lsp, area->lspdb[level-1]);
+ lsp_insert (lsp, area->lspdb[level - 1]);
listnode_add (lsp0->lspu.frags, lsp);
lsp->lspu.zero_lsp = lsp0;
/*
* Copy the authinfo from zero LSP
*/
- if (lsp0->tlv_data.auth_info.type) {
- memcpy (&lsp->tlv_data.auth_info, &lsp->tlv_data.auth_info,
- sizeof (struct isis_passwd));
- tlv_add_authinfo (lsp->tlv_data.auth_info.type,
- lsp->tlv_data.auth_info.len,
- lsp->tlv_data.auth_info.passwd, lsp->pdu);
- }
+ if (lsp0->tlv_data.auth_info.type)
+ {
+ memcpy (&lsp->tlv_data.auth_info, &lsp->tlv_data.auth_info,
+ sizeof (struct isis_passwd));
+ tlv_add_authinfo (lsp->tlv_data.auth_info.type,
+ lsp->tlv_data.auth_info.len,
+ lsp->tlv_data.auth_info.passwd, lsp->pdu);
+ }
return lsp;
}
@@ -1341,200 +1381,221 @@
/*
* First add the tlvs related to area
*/
-
+
/* Area addresses */
if (lsp->tlv_data.area_addrs == NULL)
lsp->tlv_data.area_addrs = list_new ();
list_add_list (lsp->tlv_data.area_addrs, area->area_addrs);
/* Protocols Supported */
- if (area->ip_circuits > 0
+ if (area->ip_circuits > 0
#ifdef HAVE_IPV6
|| area->ipv6_circuits > 0
#endif /* HAVE_IPV6 */
- )
+ )
{
lsp->tlv_data.nlpids = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct nlpids));
lsp->tlv_data.nlpids->count = 0;
- if (area->ip_circuits > 0) {
- lsp->tlv_data.nlpids->count++;
- lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
- }
+ if (area->ip_circuits > 0)
+ {
+ lsp->tlv_data.nlpids->count++;
+ lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
+ }
#ifdef HAVE_IPV6
- if (area->ipv6_circuits > 0) {
- lsp->tlv_data.nlpids->count++;
- lsp->tlv_data.nlpids->nlpids[lsp->tlv_data.nlpids->count - 1] =
- NLPID_IPV6;
- }
+ if (area->ipv6_circuits > 0)
+ {
+ lsp->tlv_data.nlpids->count++;
+ lsp->tlv_data.nlpids->nlpids[lsp->tlv_data.nlpids->count - 1] =
+ NLPID_IPV6;
+ }
#endif /* HAVE_IPV6 */
}
/* Dynamic Hostname */
- if (area->dynhostname) {
- lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
- sizeof (struct hostname));
+ if (area->dynhostname)
+ {
+ lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
+ sizeof (struct hostname));
- memcpy (lsp->tlv_data.hostname->name, unix_hostname(),
- strlen (unix_hostname()));
- lsp->tlv_data.hostname->namelen = strlen (unix_hostname());
- }
+ memcpy (lsp->tlv_data.hostname->name, unix_hostname (),
+ strlen (unix_hostname ()));
+ lsp->tlv_data.hostname->namelen = strlen (unix_hostname ());
+ }
/*
* Building the zero lsp
*/
- stream_set_putp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
+ stream_set_putp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
/*
* Add the authentication info if its present
*/
- (level == 1) ? (passwd = &area->area_passwd) :
- (passwd = &area->domain_passwd);
- if (passwd->type) {
- memcpy (&lsp->tlv_data.auth_info, passwd, sizeof (struct isis_passwd));
- tlv_add_authinfo (passwd->type, passwd->len,
- passwd->passwd, lsp->pdu);
- }
+ (level == 1) ? (passwd = &area->area_passwd) :
+ (passwd = &area->domain_passwd);
+ if (passwd->type)
+ {
+ memcpy (&lsp->tlv_data.auth_info, passwd, sizeof (struct isis_passwd));
+ tlv_add_authinfo (passwd->type, passwd->len, passwd->passwd, lsp->pdu);
+ }
if (lsp->tlv_data.nlpids)
tlv_add_nlpid (lsp->tlv_data.nlpids, lsp->pdu);
if (lsp->tlv_data.hostname)
tlv_add_dynamic_hostname (lsp->tlv_data.hostname, lsp->pdu);
- if (lsp->tlv_data.area_addrs && listcount (lsp->tlv_data.area_addrs) > 0 )
+ if (lsp->tlv_data.area_addrs && listcount (lsp->tlv_data.area_addrs) > 0)
tlv_add_area_addrs (lsp->tlv_data.area_addrs, lsp->pdu);
-
+
memset (&tlv_data, 0, sizeof (struct tlvs));
/*
* Then build lists of tlvs related to circuits
*/
- for (node = listhead (area->circuit_list); node; nextnode (node)) {
- circuit = getdata (node);
- if (circuit->state != C_STATE_UP)
- continue;
-
- /*
- * Add IPv4 internal reachability of this circuit
- */
- if (circuit->ip_router && circuit->ip_addrs &&
- circuit->ip_addrs->count > 0) {
- if (tlv_data.ipv4_int_reachs == NULL) {
- tlv_data.ipv4_int_reachs = list_new ();
- }
- for (ipnode = listhead (circuit->ip_addrs); ipnode; nextnode (ipnode)) {
- ipv4 = getdata (ipnode);
- ipreach = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv4_reachability));
- ipreach->metrics = circuit->metrics[level - 1];
- ipreach->prefix = ipv4->prefix;
- masklen2ip (ipv4->prefixlen, &ipreach->mask);
- listnode_add (tlv_data.ipv4_int_reachs, ipreach);
- }
+ for (node = listhead (area->circuit_list); node; nextnode (node))
+ {
+ circuit = getdata (node);
+ if (circuit->state != C_STATE_UP)
+ continue;
- }
+ /*
+ * Add IPv4 internal reachability of this circuit
+ */
+ if (circuit->ip_router && circuit->ip_addrs &&
+ circuit->ip_addrs->count > 0)
+ {
+ if (tlv_data.ipv4_int_reachs == NULL)
+ {
+ tlv_data.ipv4_int_reachs = list_new ();
+ }
+ for (ipnode = listhead (circuit->ip_addrs); ipnode;
+ nextnode (ipnode))
+ {
+ ipv4 = getdata (ipnode);
+ ipreach =
+ XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv4_reachability));
+ ipreach->metrics = circuit->metrics[level - 1];
+ ipreach->prefix = ipv4->prefix;
+ masklen2ip (ipv4->prefixlen, &ipreach->mask);
+ listnode_add (tlv_data.ipv4_int_reachs, ipreach);
+ }
+
+ }
#ifdef HAVE_IPV6
- /*
- * Add IPv6 reachability of this circuit
- */
- if (circuit->ipv6_router && circuit->ipv6_non_link &&
- circuit->ipv6_non_link->count > 0) {
-
- if (tlv_data.ipv6_reachs == NULL) {
- tlv_data.ipv6_reachs = list_new ();
- }
- for (ipnode = listhead (circuit->ipv6_non_link); ipnode;
- nextnode (ipnode)) {
- ipv6 = getdata (ipnode);
- ip6reach = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv6_reachability));
- memset (ip6reach, 0, sizeof (struct ipv6_reachability));
- ip6reach->metric = htonl(circuit->metrics[level - 1].metric_default);
- ip6reach->control_info = 0;
- ip6reach->prefix_len = ipv6->prefixlen;
- memcpy (ip6reach->prefix, ipv6->prefix.s6_addr,
- (ipv6->prefixlen + 7) / 8);
- listnode_add (tlv_data.ipv6_reachs, ip6reach);
- }
+ /*
+ * Add IPv6 reachability of this circuit
+ */
+ if (circuit->ipv6_router && circuit->ipv6_non_link &&
+ circuit->ipv6_non_link->count > 0)
+ {
+
+ if (tlv_data.ipv6_reachs == NULL)
+ {
+ tlv_data.ipv6_reachs = list_new ();
+ }
+ for (ipnode = listhead (circuit->ipv6_non_link); ipnode;
+ nextnode (ipnode))
+ {
+ ipv6 = getdata (ipnode);
+ ip6reach =
+ XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv6_reachability));
+ memset (ip6reach, 0, sizeof (struct ipv6_reachability));
+ ip6reach->metric =
+ htonl (circuit->metrics[level - 1].metric_default);
+ ip6reach->control_info = 0;
+ ip6reach->prefix_len = ipv6->prefixlen;
+ memcpy (ip6reach->prefix, ipv6->prefix.s6_addr,
+ (ipv6->prefixlen + 7) / 8);
+ listnode_add (tlv_data.ipv6_reachs, ip6reach);
+ }
+ }
+#endif /* HAVE_IPV6 */
+
+ switch (circuit->circ_type)
+ {
+ case CIRCUIT_T_BROADCAST:
+ if (level & circuit->circuit_is_type)
+ {
+ if (tlv_data.is_neighs == NULL)
+ {
+ tlv_data.is_neighs = list_new ();
+ }
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ if (level == 1)
+ memcpy (is_neigh->neigh_id,
+ circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
+ else
+ memcpy (is_neigh->neigh_id,
+ circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
+ is_neigh->metrics = circuit->metrics[level - 1];
+ listnode_add (tlv_data.is_neighs, is_neigh);
+ }
+ break;
+ case CIRCUIT_T_P2P:
+ nei = circuit->u.p2p.neighbor;
+ if (nei && (level & nei->circuit_t))
+ {
+ if (tlv_data.is_neighs == NULL)
+ {
+ tlv_data.is_neighs = list_new ();
+ tlv_data.is_neighs->del = free_tlv;
+ }
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ memcpy (is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
+ is_neigh->metrics = circuit->metrics[level - 1];
+ listnode_add (tlv_data.is_neighs, is_neigh);
+ }
+ break;
+ case CIRCUIT_T_STATIC_IN:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ case CIRCUIT_T_STATIC_OUT:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ case CIRCUIT_T_DA:
+ zlog_warn ("lsp_area_create: unsupported circuit type");
+ break;
+ default:
+ zlog_warn ("lsp_area_create: unknown circuit type");
+ }
+ }
+
+ while (tlv_data.ipv4_int_reachs && listcount (tlv_data.ipv4_int_reachs))
+ {
+ if (lsp->tlv_data.ipv4_int_reachs == NULL)
+ lsp->tlv_data.ipv4_int_reachs = list_new ();
+ lsp_tlv_fit (lsp, &tlv_data.ipv4_int_reachs,
+ &lsp->tlv_data.ipv4_int_reachs,
+ IPV4_REACH_LEN, area->lsp_frag_threshold,
+ tlv_add_ipv4_reachs);
+ if (tlv_data.ipv4_int_reachs && listcount (tlv_data.ipv4_int_reachs))
+ lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
+ lsp0, area, level);
+ }
+
+#ifdef HAVE_IPV6
+ while (tlv_data.ipv6_reachs && listcount (tlv_data.ipv6_reachs))
+ {
+ if (lsp->tlv_data.ipv6_reachs == NULL)
+ lsp->tlv_data.ipv6_reachs = list_new ();
+ lsp_tlv_fit (lsp, &tlv_data.ipv6_reachs,
+ &lsp->tlv_data.ipv6_reachs,
+ IPV6_REACH_LEN, area->lsp_frag_threshold,
+ tlv_add_ipv6_reachs);
+ if (tlv_data.ipv6_reachs && listcount (tlv_data.ipv6_reachs))
+ lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
+ lsp0, area, level);
}
#endif /* HAVE_IPV6 */
-
- switch (circuit->circ_type) {
- case CIRCUIT_T_BROADCAST:
- if (level & circuit->circuit_is_type) {
- if (tlv_data.is_neighs == NULL) {
- tlv_data.is_neighs = list_new ();
- }
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- if (level == 1)
- memcpy (is_neigh->neigh_id,
- circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
- else
- memcpy (is_neigh->neigh_id,
- circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
- is_neigh->metrics = circuit->metrics[level - 1];
- listnode_add (tlv_data.is_neighs, is_neigh);
- }
- break;
- case CIRCUIT_T_P2P:
- nei = circuit->u.p2p.neighbor;
- if (nei && (level & nei->circuit_t)) {
- if (tlv_data.is_neighs == NULL) {
- tlv_data.is_neighs = list_new ();
- tlv_data.is_neighs->del = free_tlv;
- }
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- memcpy (is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
- is_neigh->metrics = circuit->metrics[level - 1];
- listnode_add (tlv_data.is_neighs, is_neigh);
- }
- break;
- case CIRCUIT_T_STATIC_IN:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- case CIRCUIT_T_STATIC_OUT:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- case CIRCUIT_T_DA:
- zlog_warn ("lsp_area_create: unsupported circuit type");
- break;
- default:
- zlog_warn ("lsp_area_create: unknown circuit type");
+
+ while (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
+ {
+ if (lsp->tlv_data.is_neighs == NULL)
+ lsp->tlv_data.is_neighs = list_new ();
+ lsp_tlv_fit (lsp, &tlv_data.is_neighs,
+ &lsp->tlv_data.is_neighs,
+ IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
+ tlv_add_is_neighs);
+ if (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
+ lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
+ lsp0, area, level);
}
- }
-
- while (tlv_data.ipv4_int_reachs && listcount(tlv_data.ipv4_int_reachs)) {
- if (lsp->tlv_data.ipv4_int_reachs == NULL)
- lsp->tlv_data.ipv4_int_reachs = list_new ();
- lsp_tlv_fit (lsp, &tlv_data.ipv4_int_reachs,
- &lsp->tlv_data.ipv4_int_reachs,
- IPV4_REACH_LEN, area->lsp_frag_threshold,
- tlv_add_ipv4_reachs);
- if (tlv_data.ipv4_int_reachs && listcount(tlv_data.ipv4_int_reachs))
- lsp = lsp_next_frag (LSP_FRAGMENT(lsp->lsp_header->lsp_id) + 1,
- lsp0, area, level);
- }
-#ifdef HAVE_IPV6
- while (tlv_data.ipv6_reachs && listcount(tlv_data.ipv6_reachs)) {
- if (lsp->tlv_data.ipv6_reachs == NULL)
- lsp->tlv_data.ipv6_reachs = list_new ();
- lsp_tlv_fit (lsp, &tlv_data.ipv6_reachs,
- &lsp->tlv_data.ipv6_reachs,
- IPV6_REACH_LEN, area->lsp_frag_threshold,
- tlv_add_ipv6_reachs);
- if (tlv_data.ipv6_reachs && listcount(tlv_data.ipv6_reachs))
- lsp = lsp_next_frag (LSP_FRAGMENT(lsp->lsp_header->lsp_id) + 1,
- lsp0, area, level);
- }
-#endif /* HAVE_IPV6 */
-
- while (tlv_data.is_neighs && listcount(tlv_data.is_neighs)) {
- if (lsp->tlv_data.is_neighs == NULL)
- lsp->tlv_data.is_neighs = list_new ();
- lsp_tlv_fit (lsp, &tlv_data.is_neighs,
- &lsp->tlv_data.is_neighs,
- IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
- tlv_add_is_neighs);
- if (tlv_data.is_neighs && listcount(tlv_data.is_neighs))
- lsp = lsp_next_frag (LSP_FRAGMENT(lsp->lsp_header->lsp_id) + 1,
- lsp0, area, level);
- }
-
-
return;
}
#endif
@@ -1547,57 +1608,58 @@
u_char *tlv_ptr;
struct is_neigh *is_neigh;
-
+
/* add our nlpids */
- /* the 2 is for the TL plus 1 for the nlpid*/
- tlv_ptr = lsppdu_realloc (lsp,MTYPE_ISIS_TLV, 3);
- *tlv_ptr = PROTOCOLS_SUPPORTED; /* Type */
- *(tlv_ptr+1) = 1; /* one protocol */
-#ifdef HAVE_IPV6 /*dunno if its right*/
- *(tlv_ptr+2) = NLPID_IPV6;
+ /* the 2 is for the TL plus 1 for the nlpid */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 3);
+ *tlv_ptr = PROTOCOLS_SUPPORTED; /* Type */
+ *(tlv_ptr + 1) = 1; /* one protocol */
+#ifdef HAVE_IPV6 /*dunno if its right */
+ *(tlv_ptr + 2) = NLPID_IPV6;
#else
- *(tlv_ptr+2) = NLPID_IP;
+ *(tlv_ptr + 2) = NLPID_IP;
#endif /* HAVE_IPV6 */
/* we should add our areas here
* FIXME: we need to figure out which should be added? Adj? All? First? */
/* first, lets add ourselves to the IS neighbours info */
- /* the 2 is for the TL plus 1 for the virtual field*/
- tlv_ptr = lsppdu_realloc(lsp,MTYPE_ISIS_TLV, 3);
- *tlv_ptr = IS_NEIGHBOURS; /* Type */
- *(tlv_ptr+2) = 0; /* virtual is zero */
- lsp->tlv_data.is_neighs = list_new (); /* new list of is_neighbours */
+ /* the 2 is for the TL plus 1 for the virtual field */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 3);
+ *tlv_ptr = IS_NEIGHBOURS; /* Type */
+ *(tlv_ptr + 2) = 0; /* virtual is zero */
+ lsp->tlv_data.is_neighs = list_new (); /* new list of is_neighbours */
/* assign space for the is_neigh at the pdu end */
- is_neigh = (struct is_neigh*) lsppdu_realloc(lsp,MTYPE_ISIS_TLV,
- sizeof(struct is_neigh));
+ is_neigh = (struct is_neigh *) lsppdu_realloc (lsp, MTYPE_ISIS_TLV,
+ sizeof (struct is_neigh));
/* add this node to our list */
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
/* FIXME: Do we need our designated address here? */
- memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN + 1);
+ memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN + 1);
/* FIXME: Where should we really get our own LSPs metrics from? */
- circuit = (struct isis_circuit*)listhead(circuit_list);
- /* is_neigh->metrics = circuit->metrics[lsp->level -1];*/
+ circuit = (struct isis_circuit *) listhead (circuit_list);
+ /* is_neigh->metrics = circuit->metrics[lsp->level -1]; */
/* Length */
- *(tlv_ptr+1)=(lsp->tlv_data.is_neighs->count * sizeof(struct is_neigh) +1);
+ *(tlv_ptr + 1) =
+ (lsp->tlv_data.is_neighs->count * sizeof (struct is_neigh) + 1);
/* FIXME: scan for adjencecies and add them */
/* FIXME: add reachability info */
- /* adding dynamic hostname if needed*/
- if (area->dynhostname) {
- tlv_ptr = lsppdu_realloc (lsp,MTYPE_ISIS_TLV, 2); /* the 2 is for the TL */
- *tlv_ptr = DYNAMIC_HOSTNAME; /* Type */
- *(tlv_ptr+1) = strlen (unix_hostname()); /* Length */
- lsp->tlv_data.hostname = (struct hostname *)
- (lsppdu_realloc(lsp,
- MTYPE_ISIS_TLV,
- /* the -1 is to fit the length in the struct */
- strlen (unix_hostname())) - 1);
- memcpy (lsp->tlv_data.hostname->name, unix_hostname(),
- strlen(unix_hostname()));
- }
+ /* adding dynamic hostname if needed */
+ if (area->dynhostname)
+ {
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 2); /* the 2 is for the TL */
+ *tlv_ptr = DYNAMIC_HOSTNAME; /* Type */
+ *(tlv_ptr + 1) = strlen (unix_hostname ()); /* Length */
+ lsp->tlv_data.hostname = (struct hostname *)
+ (lsppdu_realloc (lsp, MTYPE_ISIS_TLV,
+ /* the -1 is to fit the length in the struct */
+ strlen (unix_hostname ())) - 1);
+ memcpy (lsp->tlv_data.hostname->name, unix_hostname (),
+ strlen (unix_hostname ()));
+ }
}
@@ -1605,8 +1667,8 @@
* 7.3.7 Generation on non-pseudonode LSPs
*/
int
-lsp_generate_non_pseudo (struct isis_area *area, int level) {
-
+lsp_generate_non_pseudo (struct isis_area *area, int level)
+{
struct isis_lsp *oldlsp, *newlsp;
u_int32_t seq_num = 0;
u_char lspid[ISIS_SYS_ID_LEN + 2];
@@ -1615,32 +1677,33 @@
memcpy (&lspid, isis->sysid, ISIS_SYS_ID_LEN);
/* only builds the lsp if the area shares the level */
- if ((area->is_type & level) == level) {
- oldlsp = lsp_search (lspid, area->lspdb[level-1]);
- if (oldlsp) {
- seq_num = ntohl (oldlsp->lsp_header->seq_num);
- lsp_search_and_destroy (oldlsp->lsp_header->lsp_id,
- area->lspdb[level-1]);
- /* FIXME: we should actually initiate a purge */
- }
- newlsp = lsp_new (lspid, area->max_lsp_lifetime[level-1], seq_num,
- area->is_type, 0, level);
- newlsp->own_lsp = 1;
-
- lsp_insert (newlsp, area->lspdb[level-1]);
- /* build_lsp_data (newlsp, area); */
- lsp_build_nonpseudo (newlsp, area);
- /* time to calculate our checksum */
- lsp_seqnum_update (newlsp);
- }
+ if ((area->is_type & level) == level)
+ {
+ oldlsp = lsp_search (lspid, area->lspdb[level - 1]);
+ if (oldlsp)
+ {
+ seq_num = ntohl (oldlsp->lsp_header->seq_num);
+ lsp_search_and_destroy (oldlsp->lsp_header->lsp_id,
+ area->lspdb[level - 1]);
+ /* FIXME: we should actually initiate a purge */
+ }
+ newlsp = lsp_new (lspid, area->max_lsp_lifetime[level - 1], seq_num,
+ area->is_type, 0, level);
+ newlsp->own_lsp = 1;
+ lsp_insert (newlsp, area->lspdb[level - 1]);
+ /* build_lsp_data (newlsp, area); */
+ lsp_build_nonpseudo (newlsp, area);
+ /* time to calculate our checksum */
+ lsp_seqnum_update (newlsp);
+ }
/* DEBUG_ADJ_PACKETS */
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- /* FIXME: is this place right? fix missing info */
- zlog_info ("ISIS-Upd (%s): Building L%d LSP",
- area->area_tag, level);
- }
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ /* FIXME: is this place right? fix missing info */
+ zlog_info ("ISIS-Upd (%s): Building L%d LSP", area->area_tag, level);
+ }
return ISIS_OK;
}
@@ -1651,21 +1714,20 @@
int
lsp_l1_generate (struct isis_area *area)
{
- THREAD_TIMER_ON(master, area->t_lsp_refresh[0], lsp_refresh_l1, area,
- MAX_LSP_GEN_INTERVAL);
+ THREAD_TIMER_ON (master, area->t_lsp_refresh[0], lsp_refresh_l1, area,
+ MAX_LSP_GEN_INTERVAL);
return lsp_generate_non_pseudo (area, 1);
}
-
/*
* 7.3.9 Generation of level 2 LSPs (non-pseudonode)
*/
int
lsp_l2_generate (struct isis_area *area)
{
- THREAD_TIMER_ON(master, area->t_lsp_refresh[1], lsp_refresh_l2, area,
- MAX_LSP_GEN_INTERVAL);
+ THREAD_TIMER_ON (master, area->t_lsp_refresh[1], lsp_refresh_l2, area,
+ MAX_LSP_GEN_INTERVAL);
return lsp_generate_non_pseudo (area, 2);
}
@@ -1680,45 +1742,49 @@
memset (lspid, 0, ISIS_SYS_ID_LEN + 2);
memcpy (lspid, isis->sysid, ISIS_SYS_ID_LEN);
-
+
lsp = lsp_search (lspid, lspdb);
-
- if (!lsp) {
- zlog_err ("ISIS-Upd (%s): lsp_non_pseudo_regenerate(): no L%d LSP found!",
- area->area_tag,
- level);
- return ISIS_ERROR;
- }
+ if (!lsp)
+ {
+ zlog_err
+ ("ISIS-Upd (%s): lsp_non_pseudo_regenerate(): no L%d LSP found!",
+ area->area_tag, level);
- lsp_clear_data (lsp);
+ return ISIS_ERROR;
+ }
+
+ lsp_clear_data (lsp);
lsp_build_nonpseudo (lsp, area);
- lsp->lsp_header->rem_lifetime = htons (isis_jitter
- (area->max_lsp_lifetime[level-1],
- MAX_AGE_JITTER));
+ lsp->lsp_header->rem_lifetime = htons (isis_jitter
+ (area->max_lsp_lifetime[level - 1],
+ MAX_AGE_JITTER));
lsp_seqnum_update (lsp);
-
- if (isis->debugs & DEBUG_UPDATE_PACKETS) {
- zlog_info ("ISIS-Upd (%s): refreshing our L%d LSP %s, "
- "seq 0x%08x, cksum 0x%04x lifetime %us",
- area->area_tag,
- level,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(lsp->lsp_header->seq_num),
- ntohs(lsp->lsp_header->checksum),
- ntohs(lsp->lsp_header->rem_lifetime));
- }
+
+ if (isis->debugs & DEBUG_UPDATE_PACKETS)
+ {
+ zlog_info ("ISIS-Upd (%s): refreshing our L%d LSP %s, "
+ "seq 0x%08x, cksum 0x%04x lifetime %us",
+ area->area_tag,
+ level,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ }
lsp->last_generated = time (NULL);
area->lsp_regenerate_pending[level - 1] = 0;
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- for (node = listhead (lsp->lspu.frags); node; nextnode(node)) {
- frag = getdata (node);
- frag->lsp_header->rem_lifetime = htons (isis_jitter
- (area->max_lsp_lifetime[level-1],
- MAX_AGE_JITTER));
- ISIS_FLAGS_SET_ALL (frag->SRMflags);
- }
+ for (node = listhead (lsp->lspu.frags); node; nextnode (node))
+ {
+ frag = getdata (node);
+ frag->lsp_header->rem_lifetime = htons (isis_jitter
+ (area->
+ max_lsp_lifetime[level - 1],
+ MAX_AGE_JITTER));
+ ISIS_FLAGS_SET_ALL (frag->SRMflags);
+ }
if (area->ip_circuits)
isis_spf_schedule (area, level);
@@ -1729,12 +1795,11 @@
return ISIS_OK;
}
-
/*
* Done at least every MAX_LSP_GEN_INTERVAL. Search own LSPs, update holding
* time and set SRM
*/
-int
+int
lsp_refresh_l1 (struct thread *thread)
{
struct isis_area *area;
@@ -1742,21 +1807,21 @@
area = THREAD_ARG (thread);
assert (area);
-
+
area->t_lsp_refresh[0] = NULL;
- if (area->is_type & IS_LEVEL_1)
+ if (area->is_type & IS_LEVEL_1)
lsp_non_pseudo_regenerate (area, 1);
-
- ref_time = area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
+
+ ref_time = area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : area->lsp_refresh[0];
- THREAD_TIMER_ON(master, area->t_lsp_refresh[0], lsp_refresh_l1, area,
- isis_jitter(ref_time, MAX_AGE_JITTER));
+ THREAD_TIMER_ON (master, area->t_lsp_refresh[0], lsp_refresh_l1, area,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
return ISIS_OK;
}
-int
+int
lsp_refresh_l2 (struct thread *thread)
{
struct isis_area *area;
@@ -1764,21 +1829,20 @@
area = THREAD_ARG (thread);
assert (area);
-
+
area->t_lsp_refresh[1] = NULL;
- if (area->is_type & IS_LEVEL_2)
+ if (area->is_type & IS_LEVEL_2)
lsp_non_pseudo_regenerate (area, 2);
- ref_time = area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
+ ref_time = area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : area->lsp_refresh[1];
- THREAD_TIMER_ON(master, area->t_lsp_refresh[1], lsp_refresh_l2, area,
- isis_jitter(ref_time, MAX_AGE_JITTER));
+ THREAD_TIMER_ON (master, area->t_lsp_refresh[1], lsp_refresh_l2, area,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
return ISIS_OK;
}
-
/*
* Something has changed -> regenerate LSP
*/
@@ -1801,60 +1865,66 @@
area = THREAD_ARG (thread);
area->lsp_regenerate_pending[1] = 0;
-
+
return lsp_non_pseudo_regenerate (area, 2);
}
-int
+int
lsp_regenerate_schedule (struct isis_area *area)
{
struct isis_lsp *lsp;
u_char id[ISIS_SYS_ID_LEN + 2];
time_t now, diff;
- memcpy(id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID(id) = LSP_FRAGMENT(id) = 0;
+ memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
+ LSP_PSEUDO_ID (id) = LSP_FRAGMENT (id) = 0;
now = time (NULL);
/*
* First level 1
*/
- if (area->is_type & IS_LEVEL_1) {
- lsp = lsp_search (id, area->lspdb[0]);
- if (!lsp || area->lsp_regenerate_pending[0])
- goto L2;
- /*
- * Throttle avoidance
- */
- diff = now - lsp->last_generated;
- if (diff < MIN_LSP_GEN_INTERVAL) {
- area->lsp_regenerate_pending[0] = 1;
- thread_add_timer (master, lsp_l1_regenerate, area,
- MIN_LSP_GEN_INTERVAL - diff);
- return ISIS_OK;
- } else
- lsp_non_pseudo_regenerate (area, 1);
- }
+ if (area->is_type & IS_LEVEL_1)
+ {
+ lsp = lsp_search (id, area->lspdb[0]);
+ if (!lsp || area->lsp_regenerate_pending[0])
+ goto L2;
+ /*
+ * Throttle avoidance
+ */
+ diff = now - lsp->last_generated;
+ if (diff < MIN_LSP_GEN_INTERVAL)
+ {
+ area->lsp_regenerate_pending[0] = 1;
+ thread_add_timer (master, lsp_l1_regenerate, area,
+ MIN_LSP_GEN_INTERVAL - diff);
+ return ISIS_OK;
+ }
+ else
+ lsp_non_pseudo_regenerate (area, 1);
+ }
/*
* then 2
*/
- L2:
- if (area->is_type & IS_LEVEL_2) {
- lsp = lsp_search (id, area->lspdb[1]);
- if (!lsp || area->lsp_regenerate_pending[1])
- return ISIS_OK;
- /*
- * Throttle avoidance
- */
- diff = now - lsp->last_generated;
- if (diff < MIN_LSP_GEN_INTERVAL) {
- area->lsp_regenerate_pending[1] = 1;
- thread_add_timer (master, lsp_l2_regenerate, area,
- MIN_LSP_GEN_INTERVAL - diff);
- return ISIS_OK;
- } else
- lsp_non_pseudo_regenerate (area, 2);
- }
-
- return ISIS_OK;
+L2:
+ if (area->is_type & IS_LEVEL_2)
+ {
+ lsp = lsp_search (id, area->lspdb[1]);
+ if (!lsp || area->lsp_regenerate_pending[1])
+ return ISIS_OK;
+ /*
+ * Throttle avoidance
+ */
+ diff = now - lsp->last_generated;
+ if (diff < MIN_LSP_GEN_INTERVAL)
+ {
+ area->lsp_regenerate_pending[1] = 1;
+ thread_add_timer (master, lsp_l2_regenerate, area,
+ MIN_LSP_GEN_INTERVAL - diff);
+ return ISIS_OK;
+ }
+ else
+ lsp_non_pseudo_regenerate (area, 2);
+ }
+
+ return ISIS_OK;
}
/*
@@ -1865,8 +1935,8 @@
* 7.3.8 and 7.3.10 Generation of level 1 and 2 pseudonode LSPs
*/
void
-lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit,
- int level)
+lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit,
+ int level)
{
struct isis_adjacency *adj;
struct is_neigh *is_neigh;
@@ -1877,10 +1947,10 @@
assert (circuit);
assert (circuit->circ_type == CIRCUIT_T_BROADCAST);
-
+
if (!circuit->u.bc.is_dr[level - 1])
- return; /* we are not DIS on this circuit */
-
+ return; /* we are not DIS on this circuit */
+
lsp->level = level;
if (level == 1)
lsp->lsp_header->lsp_bits |= IS_LEVEL_1;
@@ -1890,56 +1960,63 @@
/*
* add self to IS neighbours
*/
- if (lsp->tlv_data.is_neighs == NULL) {
- lsp->tlv_data.is_neighs = list_new ();
- lsp->tlv_data.is_neighs->del = free_tlv;
- }
+ if (lsp->tlv_data.is_neighs == NULL)
+ {
+ lsp->tlv_data.is_neighs = list_new ();
+ lsp->tlv_data.is_neighs->del = free_tlv;
+ }
is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
memset (is_neigh, 0, sizeof (struct is_neigh));
memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
listnode_add (lsp->tlv_data.is_neighs, is_neigh);
-
- adj_list = list_new();
- isis_adj_build_up_list (circuit->u.bc.adjdb[level-1], adj_list);
-
- for (node = listhead (adj_list); node; nextnode (node)){
- adj = getdata (node);
- if (adj->circuit_t & level) {
- if ((level == 1 && adj->sys_type == ISIS_SYSTYPE_L1_IS) ||
- (level == 1 && adj->sys_type == ISIS_SYSTYPE_L2_IS &&
- adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
- (level == 2 && adj->sys_type == ISIS_SYSTYPE_L2_IS)) {
- /* an IS neighbour -> add it */
- is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
- memset (is_neigh, 0, sizeof (struct is_neigh));
- memcpy (&is_neigh->neigh_id, adj->sysid, ISIS_SYS_ID_LEN);
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- } else if (level == 1 && adj->sys_type == ISIS_SYSTYPE_ES) {
- /* an ES neigbour add it, if we are building level 1 LSP */
- /* FIXME: the tlv-format is hard to use here */
- if (lsp->tlv_data.es_neighs == NULL) {
- lsp->tlv_data.es_neighs = list_new ();
- lsp->tlv_data.es_neighs->del = free_tlv;
- }
- es_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct es_neigh));
- memset (es_neigh, 0, sizeof (struct es_neigh));
- memcpy (&es_neigh->first_es_neigh, adj->sysid, ISIS_SYS_ID_LEN);
- listnode_add (lsp->tlv_data.es_neighs, is_neigh);
- }
+
+ adj_list = list_new ();
+ isis_adj_build_up_list (circuit->u.bc.adjdb[level - 1], adj_list);
+
+ for (node = listhead (adj_list); node; nextnode (node))
+ {
+ adj = getdata (node);
+ if (adj->circuit_t & level)
+ {
+ if ((level == 1 && adj->sys_type == ISIS_SYSTYPE_L1_IS) ||
+ (level == 1 && adj->sys_type == ISIS_SYSTYPE_L2_IS &&
+ adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
+ (level == 2 && adj->sys_type == ISIS_SYSTYPE_L2_IS))
+ {
+ /* an IS neighbour -> add it */
+ is_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
+ memset (is_neigh, 0, sizeof (struct is_neigh));
+ memcpy (&is_neigh->neigh_id, adj->sysid, ISIS_SYS_ID_LEN);
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ }
+ else if (level == 1 && adj->sys_type == ISIS_SYSTYPE_ES)
+ {
+ /* an ES neigbour add it, if we are building level 1 LSP */
+ /* FIXME: the tlv-format is hard to use here */
+ if (lsp->tlv_data.es_neighs == NULL)
+ {
+ lsp->tlv_data.es_neighs = list_new ();
+ lsp->tlv_data.es_neighs->del = free_tlv;
+ }
+ es_neigh = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct es_neigh));
+ memset (es_neigh, 0, sizeof (struct es_neigh));
+ memcpy (&es_neigh->first_es_neigh, adj->sysid, ISIS_SYS_ID_LEN);
+ listnode_add (lsp->tlv_data.es_neighs, is_neigh);
+ }
+ }
}
- }
-
+
stream_set_putp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
/*
* Add the authentication info if it's present
*/
- (level == 1) ? (passwd = &circuit->area->area_passwd) :
- (passwd = &circuit->area->domain_passwd);
- if (passwd->type) {
- memcpy (&lsp->tlv_data.auth_info, passwd, sizeof (struct isis_passwd));
- tlv_add_authinfo (passwd->type, passwd->len,
- passwd->passwd, lsp->pdu);
- }
+ (level == 1) ? (passwd = &circuit->area->area_passwd) :
+ (passwd = &circuit->area->domain_passwd);
+ if (passwd->type)
+ {
+ memcpy (&lsp->tlv_data.auth_info, passwd, sizeof (struct isis_passwd));
+ tlv_add_authinfo (passwd->type, passwd->len, passwd->passwd, lsp->pdu);
+ }
if (lsp->tlv_data.is_neighs && listcount (lsp->tlv_data.is_neighs) > 0)
tlv_add_is_neighs (lsp->tlv_data.is_neighs, lsp->pdu);
@@ -1948,9 +2025,9 @@
tlv_add_is_neighs (lsp->tlv_data.es_neighs, lsp->pdu);
lsp->lsp_header->pdu_len = htons (stream_get_putp (lsp->pdu));
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
-
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+
list_delete (adj_list);
return;
@@ -1962,41 +2039,42 @@
dict_t *lspdb = circuit->area->lspdb[level - 1];
struct isis_lsp *lsp;
u_char lsp_id[ISIS_SYS_ID_LEN + 2];
-
+
memcpy (lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID(lsp_id) = circuit->circuit_id;
- LSP_FRAGMENT(lsp_id) = 0;
-
+ LSP_PSEUDO_ID (lsp_id) = circuit->circuit_id;
+ LSP_FRAGMENT (lsp_id) = 0;
+
lsp = lsp_search (lsp_id, lspdb);
-
- if (!lsp) {
- zlog_err ("lsp_pseudo_regenerate(): no l%d LSP %s found!", level,
- rawlspid_print(lsp_id));
- return ISIS_ERROR;
- }
- lsp_clear_data (lsp);
+
+ if (!lsp)
+ {
+ zlog_err ("lsp_pseudo_regenerate(): no l%d LSP %s found!", level,
+ rawlspid_print (lsp_id));
+ return ISIS_ERROR;
+ }
+ lsp_clear_data (lsp);
lsp_build_pseudo (lsp, circuit, level);
- lsp->lsp_header->rem_lifetime =
+ lsp->lsp_header->rem_lifetime =
htons (isis_jitter (circuit->area->max_lsp_lifetime[level - 1],
- MAX_AGE_JITTER));
+ MAX_AGE_JITTER));
lsp_inc_seqnum (lsp, 0);
-
- if (isis->debugs & DEBUG_UPDATE_PACKETS) {
- zlog_info ("ISIS-Upd (%s): refreshing pseudo LSP L%d %s",
- circuit->area->area_tag, level,
- rawlspid_print (lsp->lsp_header->lsp_id));
- }
+
+ if (isis->debugs & DEBUG_UPDATE_PACKETS)
+ {
+ zlog_info ("ISIS-Upd (%s): refreshing pseudo LSP L%d %s",
+ circuit->area->area_tag, level,
+ rawlspid_print (lsp->lsp_header->lsp_id));
+ }
lsp->last_generated = time (NULL);
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
-
+
return ISIS_OK;
}
-
int
lsp_l1_refresh_pseudo (struct thread *thread)
{
@@ -2004,32 +2082,33 @@
int retval;
unsigned long ref_time;
- circuit = THREAD_ARG(thread);
-
+ circuit = THREAD_ARG (thread);
+
if (!circuit->u.bc.is_dr[0])
- return ISIS_ERROR; /* FIXME: purge and such */
-
+ return ISIS_ERROR; /* FIXME: purge and such */
+
retval = lsp_pseudo_regenerate (circuit, 1);
-
- ref_time = circuit->area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
+
+ ref_time = circuit->area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : circuit->area->lsp_refresh[0];
- THREAD_TIMER_ON(master, circuit->u.bc.t_refresh_pseudo_lsp[0],
- lsp_l1_refresh_pseudo, circuit, isis_jitter (ref_time, MAX_AGE_JITTER));
-
+ THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[0],
+ lsp_l1_refresh_pseudo, circuit,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
+
return retval;
}
-int
+int
lsp_l1_pseudo_generate (struct isis_circuit *circuit)
{
struct isis_lsp *lsp;
u_char id[ISIS_SYS_ID_LEN + 2];
unsigned long ref_time;
- memcpy(id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_FRAGMENT(id) = 0;
- LSP_PSEUDO_ID(id) = circuit->circuit_id;
+ memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
+ LSP_FRAGMENT (id) = 0;
+ LSP_PSEUDO_ID (id) = circuit->circuit_id;
/*
* If for some reason have a pseudo LSP in the db already -> regenerate
@@ -2037,19 +2116,20 @@
if (lsp_search (id, circuit->area->lspdb[0]))
return lsp_pseudo_regenerate (circuit, 1);
lsp = lsp_new (id, circuit->area->max_lsp_lifetime[0],
- 1, circuit->area->is_type, 0, 1);
-
+ 1, circuit->area->is_type, 0, 1);
+
lsp_build_pseudo (lsp, circuit, 1);
-
+
lsp->own_lsp = 1;
lsp_insert (lsp, circuit->area->lspdb[0]);
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- ref_time = circuit->area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
+ ref_time = circuit->area->lsp_refresh[0] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : circuit->area->lsp_refresh[0];
- THREAD_TIMER_ON(master, circuit->u.bc.t_refresh_pseudo_lsp[0],
- lsp_l1_refresh_pseudo, circuit, isis_jitter (ref_time, MAX_AGE_JITTER));
+ THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[0],
+ lsp_l1_refresh_pseudo, circuit,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
return lsp_regenerate_schedule (circuit->area);
}
@@ -2060,64 +2140,63 @@
struct isis_circuit *circuit;
int retval;
unsigned long ref_time;
- circuit = THREAD_ARG(thread);
-
+ circuit = THREAD_ARG (thread);
+
if (!circuit->u.bc.is_dr[1])
- return ISIS_ERROR; /* FIXME: purge and such */
-
+ return ISIS_ERROR; /* FIXME: purge and such */
+
retval = lsp_pseudo_regenerate (circuit, 2);
- ref_time = circuit->area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
+ ref_time = circuit->area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : circuit->area->lsp_refresh[1];
- THREAD_TIMER_ON(master, circuit->u.bc.t_refresh_pseudo_lsp[1],
- lsp_l2_refresh_pseudo, circuit, isis_jitter (ref_time, MAX_AGE_JITTER));
+ THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[1],
+ lsp_l2_refresh_pseudo, circuit,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
return retval;
}
-
-int
+int
lsp_l2_pseudo_generate (struct isis_circuit *circuit)
{
struct isis_lsp *lsp;
u_char id[ISIS_SYS_ID_LEN + 2];
unsigned long ref_time;
- memcpy(id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_FRAGMENT(id) = 0;
- LSP_PSEUDO_ID(id) = circuit->circuit_id;
+ memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
+ LSP_FRAGMENT (id) = 0;
+ LSP_PSEUDO_ID (id) = circuit->circuit_id;
if (lsp_search (id, circuit->area->lspdb[1]))
return lsp_pseudo_regenerate (circuit, 2);
lsp = lsp_new (id, circuit->area->max_lsp_lifetime[1],
- 1, circuit->area->is_type, 0, 2);
+ 1, circuit->area->is_type, 0, 2);
lsp_build_pseudo (lsp, circuit, 2);
-
- ref_time = circuit->area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
+
+ ref_time = circuit->area->lsp_refresh[1] > MAX_LSP_GEN_INTERVAL ?
MAX_LSP_GEN_INTERVAL : circuit->area->lsp_refresh[1];
lsp->own_lsp = 1;
lsp_insert (lsp, circuit->area->lspdb[1]);
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
-
- THREAD_TIMER_ON(master, circuit->u.bc.t_refresh_pseudo_lsp[1],
- lsp_l2_refresh_pseudo, circuit, isis_jitter (ref_time, MAX_AGE_JITTER));
-
+
+ THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[1],
+ lsp_l2_refresh_pseudo, circuit,
+ isis_jitter (ref_time, MAX_AGE_JITTER));
+
return lsp_regenerate_schedule (circuit->area);
}
-
-
/*
* Walk through LSPs for an area
* - set remaining lifetime
* - set LSPs with SRMflag set for sending
*/
-int
+int
lsp_tick (struct thread *thread)
{
struct isis_area *area;
@@ -2129,80 +2208,92 @@
int level;
lsp_list = list_new ();
-
+
area = THREAD_ARG (thread);
assert (area);
- THREAD_TIMER_ON(master, area->t_tick, lsp_tick, area, 1);
+ THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
/*
* Build a list of LSPs with (any) SRMflag set
* and removed the ones that have aged out
*/
- for (level = 0; level < ISIS_LEVELS; level++) {
- if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0) {
- dnode = dict_first (area->lspdb[level]);
- while (dnode != NULL) {
- dnode_next = dict_next (area->lspdb[level], dnode);
- lsp = dnode_get (dnode);
- lsp_set_time (lsp);
- if (lsp->age_out == 0) {
+ for (level = 0; level < ISIS_LEVELS; level++)
+ {
+ if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)
+ {
+ dnode = dict_first (area->lspdb[level]);
+ while (dnode != NULL)
+ {
+ dnode_next = dict_next (area->lspdb[level], dnode);
+ lsp = dnode_get (dnode);
+ lsp_set_time (lsp);
+ if (lsp->age_out == 0)
+ {
- zlog_info ("ISIS-Upd (%s): L%u LSP %s seq 0x%08x aged out",
- area->area_tag,
- lsp->level,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(lsp->lsp_header->seq_num));
+ zlog_info ("ISIS-Upd (%s): L%u LSP %s seq 0x%08x aged out",
+ area->area_tag,
+ lsp->level,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num));
- lsp_destroy (lsp);
- dict_delete (area->lspdb[level], dnode);
- } else if (flags_any_set (lsp->SRMflags))
- listnode_add (lsp_list, lsp);
- dnode = dnode_next;
- }
+ lsp_destroy (lsp);
+ dict_delete (area->lspdb[level], dnode);
+ }
+ else if (flags_any_set (lsp->SRMflags))
+ listnode_add (lsp_list, lsp);
+ dnode = dnode_next;
+ }
- /*
- * Send LSPs on circuits indicated by the SRMflags
- */
- if (listcount (lsp_list) > 0) {
- for (cnode = listhead (area->circuit_list); cnode; nextnode (cnode)) {
- circuit = getdata (cnode);
- for (lspnode = listhead (lsp_list); lspnode; nextnode (lspnode)) {
- lsp = getdata (lspnode);
- if (ISIS_CHECK_FLAG (lsp->SRMflags, circuit)) {
- /* FIXME: if same or elder lsp is already in lsp queue */
- listnode_add (circuit->lsp_queue, lsp);
- thread_add_event (master, send_lsp, circuit, 0);
- }
- }
- }
- }
- list_delete_all_node (lsp_list);
+ /*
+ * Send LSPs on circuits indicated by the SRMflags
+ */
+ if (listcount (lsp_list) > 0)
+ {
+ for (cnode = listhead (area->circuit_list); cnode;
+ nextnode (cnode))
+ {
+ circuit = getdata (cnode);
+ for (lspnode = listhead (lsp_list); lspnode;
+ nextnode (lspnode))
+ {
+ lsp = getdata (lspnode);
+ if (ISIS_CHECK_FLAG (lsp->SRMflags, circuit))
+ {
+ /* FIXME: if same or elder lsp is already in lsp
+ * queue */
+ listnode_add (circuit->lsp_queue, lsp);
+ thread_add_event (master, send_lsp, circuit, 0);
+ }
+ }
+ }
+ }
+ list_delete_all_node (lsp_list);
+ }
}
- }
list_delete (lsp_list);
return ISIS_OK;
}
-
void
-lsp_purge_dr (u_char *id, struct isis_circuit *circuit, int level)
+lsp_purge_dr (u_char * id, struct isis_circuit *circuit, int level)
{
struct isis_lsp *lsp;
-
+
lsp = lsp_search (id, circuit->area->lspdb[level - 1]);
-
- if (lsp && lsp->purged == 0) {
- lsp->lsp_header->rem_lifetime = htons (0);
- lsp->lsp_header->pdu_len = htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
- lsp->purged = 0;
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
- ISIS_FLAGS_SET_ALL(lsp->SRMflags);
- }
-
-
+
+ if (lsp && lsp->purged == 0)
+ {
+ lsp->lsp_header->rem_lifetime = htons (0);
+ lsp->lsp_header->pdu_len =
+ htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
+ lsp->purged = 0;
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ }
+
return;
}
@@ -2211,8 +2302,8 @@
* -> Do as in 7.3.16.4
*/
void
-lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr,
- struct isis_area *area)
+lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr,
+ struct isis_area *area)
{
struct isis_lsp *lsp;
@@ -2222,17 +2313,17 @@
zlog_info ("LSP PURGE NON EXIST");
lsp = XMALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
memset (lsp, 0, sizeof (struct isis_lsp));
- /*FIXME: BUG BUG BUG! the lsp doesn't exist here!*/
- /*did smt here, maybe good probably not*/
+ /*FIXME: BUG BUG BUG! the lsp doesn't exist here! */
+ /*did smt here, maybe good probably not */
lsp->level = ((lsp_hdr->lsp_bits & LSPBIT_IST) == IS_LEVEL_1) ? 1 : 2;
lsp->pdu = stream_new (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
- lsp->isis_header = (struct isis_fixed_hdr*)STREAM_DATA(lsp->pdu);
+ lsp->isis_header = (struct isis_fixed_hdr *) STREAM_DATA (lsp->pdu);
fill_fixed_hdr (lsp->isis_header, (lsp->level == 1) ? L1_LINK_STATE
- : L2_LINK_STATE);
- lsp->lsp_header = (struct isis_link_state_hdr*)(STREAM_DATA(lsp->pdu) +
- ISIS_FIXED_HDR_LEN);
+ : L2_LINK_STATE);
+ lsp->lsp_header = (struct isis_link_state_hdr *) (STREAM_DATA (lsp->pdu) +
+ ISIS_FIXED_HDR_LEN);
memcpy (lsp->lsp_header, lsp_hdr, ISIS_LSP_HDR_LEN);
-
+
/*
* Retain only LSP header
*/
@@ -2244,13 +2335,13 @@
/*
* Put the lsp into LSPdb
*/
- lsp_insert (lsp, area->lspdb[lsp->level-1]);
+ lsp_insert (lsp, area->lspdb[lsp->level - 1]);
/*
* Send in to whole area
*/
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
-
+
return;
}
@@ -2258,27 +2349,29 @@
int
top_lsp_refresh (struct thread *thread)
{
- struct isis_lsp *lsp;
+ struct isis_lsp *lsp;
lsp = THREAD_ARG (thread);
assert (lsp);
lsp->t_lsp_top_ref = NULL;
- lsp->lsp_header->rem_lifetime = htons (isis_jitter(MAX_AGE,MAX_AGE_JITTER));
- lsp->lsp_header->seq_num = htonl(ntohl(lsp->lsp_header->seq_num) +1);
+ lsp->lsp_header->rem_lifetime =
+ htons (isis_jitter (MAX_AGE, MAX_AGE_JITTER));
+ lsp->lsp_header->seq_num = htonl (ntohl (lsp->lsp_header->seq_num) + 1);
ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- if (isis->debugs & DEBUG_UPDATE_PACKETS) {
- zlog_info ("ISIS-Upd (): refreshing Topology L1 %s",
- rawlspid_print (lsp->lsp_header->lsp_id));
- }
+ if (isis->debugs & DEBUG_UPDATE_PACKETS)
+ {
+ zlog_info ("ISIS-Upd (): refreshing Topology L1 %s",
+ rawlspid_print (lsp->lsp_header->lsp_id));
+ }
/* time to calculate our checksum */
iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
- THREAD_TIMER_ON(master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
- isis_jitter (MAX_LSP_GEN_INTERVAL, MAX_LSP_GEN_JITTER));
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+ THREAD_TIMER_ON (master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
+ isis_jitter (MAX_LSP_GEN_INTERVAL, MAX_LSP_GEN_JITTER));
return ISIS_OK;
}
@@ -2293,34 +2386,39 @@
struct isis_lsp *lsp;
/* first we find the maximal node */
- LIST_LOOP (area->topology, arc, node) {
- if (arc->from_node > max) max = arc->from_node;
- if (arc->to_node > max) max = arc->to_node;
+ LIST_LOOP (area->topology, arc, node)
+ {
+ if (arc->from_node > max)
+ max = arc->from_node;
+ if (arc->to_node > max)
+ max = arc->to_node;
}
+ for (i = 1; i < (max + 1); i++)
+ {
+ memcpy (lspid, area->topology_baseis, ISIS_SYS_ID_LEN);
+ LSP_PSEUDO_ID (lspid) = 0x00;
+ LSP_FRAGMENT (lspid) = 0x00;
+ lspid[ISIS_SYS_ID_LEN - 1] = (i & 0xFF);
+ lspid[ISIS_SYS_ID_LEN - 2] = ((i >> 8) & 0xFF);
- for (i = 1; i < (max+1); i++) {
- memcpy (lspid,area->topology_baseis,ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID (lspid) = 0x00;
- LSP_FRAGMENT (lspid) = 0x00;
- lspid[ISIS_SYS_ID_LEN-1] = (i & 0xFF);
- lspid[ISIS_SYS_ID_LEN-2] = ((i >> 8) & 0xFF);
+ lsp = lsp_new (lspid, isis_jitter (area->max_lsp_lifetime[0],
+ MAX_AGE_JITTER), 1, IS_LEVEL_1, 0,
+ 1);
+ lsp->from_topology = 1;
+ /* creating data based on topology */
+ build_topology_lsp_data (lsp, area, i);
+ /* time to calculate our checksum */
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+ THREAD_TIMER_ON (master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
+ isis_jitter (MAX_LSP_GEN_INTERVAL,
+ MAX_LSP_GEN_JITTER));
- lsp = lsp_new (lspid, isis_jitter (area->max_lsp_lifetime[0],
- MAX_AGE_JITTER), 1, IS_LEVEL_1, 0, 1);
- lsp->from_topology = 1;
- /* creating data based on topology */
- build_topology_lsp_data (lsp,area,i);
- /* time to calculate our checksum */
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
- THREAD_TIMER_ON(master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
- isis_jitter(MAX_LSP_GEN_INTERVAL, MAX_LSP_GEN_JITTER));
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ lsp_insert (lsp, area->lspdb[0]);
- ISIS_FLAGS_SET_ALL(lsp->SRMflags);
- lsp_insert (lsp,area->lspdb[0]);
-
- }
+ }
}
void
@@ -2330,20 +2428,22 @@
dnode_t *dnode, *dnode_next;
dnode = dict_first (area->lspdb[0]);
- while (dnode != NULL) {
- dnode_next = dict_next (area->lspdb[0], dnode);
- lsp = dnode_get (dnode);
- if (lsp->from_topology) {
- THREAD_TIMER_OFF(lsp->t_lsp_top_ref);
- lsp_destroy (lsp);
- dict_delete (area->lspdb[0], dnode);
+ while (dnode != NULL)
+ {
+ dnode_next = dict_next (area->lspdb[0], dnode);
+ lsp = dnode_get (dnode);
+ if (lsp->from_topology)
+ {
+ THREAD_TIMER_OFF (lsp->t_lsp_top_ref);
+ lsp_destroy (lsp);
+ dict_delete (area->lspdb[0], dnode);
+ }
+ dnode = dnode_next;
}
- dnode = dnode_next;
- }
}
void
-build_topology_lsp_data (struct isis_lsp *lsp, struct isis_area *area,
+build_topology_lsp_data (struct isis_lsp *lsp, struct isis_area *area,
int lsp_top_num)
{
struct listnode *node;
@@ -2354,89 +2454,98 @@
char buff[200];
/* add our nlpids */
- /* the 2 is for the TL plus 1 for the nlpid*/
- tlv_ptr = lsppdu_realloc (lsp,MTYPE_ISIS_TLV, 3);
- *tlv_ptr = PROTOCOLS_SUPPORTED; /* Type */
- *(tlv_ptr+1) = 1; /* one protocol */
- *(tlv_ptr+2) = NLPID_IP;
- lsp->tlv_data.nlpids = (struct nlpids*)(tlv_ptr+1);
+ /* the 2 is for the TL plus 1 for the nlpid */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 3);
+ *tlv_ptr = PROTOCOLS_SUPPORTED; /* Type */
+ *(tlv_ptr + 1) = 1; /* one protocol */
+ *(tlv_ptr + 2) = NLPID_IP;
+ lsp->tlv_data.nlpids = (struct nlpids *) (tlv_ptr + 1);
/* first, lets add the tops */
- /* the 2 is for the TL plus 1 for the virtual field*/
- tlv_ptr = lsppdu_realloc (lsp ,MTYPE_ISIS_TLV, 3);
- *tlv_ptr = IS_NEIGHBOURS; /* Type */
- *(tlv_ptr+1) = 1; /* this is the virtual char len*/
- *(tlv_ptr+2) = 0; /* virtual is zero */
- lsp->tlv_data.is_neighs = list_new (); /* new list of is_neighbours */
+ /* the 2 is for the TL plus 1 for the virtual field */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 3);
+ *tlv_ptr = IS_NEIGHBOURS; /* Type */
+ *(tlv_ptr + 1) = 1; /* this is the virtual char len */
+ *(tlv_ptr + 2) = 0; /* virtual is zero */
+ lsp->tlv_data.is_neighs = list_new (); /* new list of is_neighbours */
/* add reachability for this IS for simulated 1 */
- if (lsp_top_num == 1) {
- /* assign space for the is_neigh at the pdu end */
- is_neigh = (struct is_neigh*) lsppdu_realloc(lsp, MTYPE_ISIS_TLV,
- sizeof(struct is_neigh));
- /* add this node to our list */
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID (is_neigh->neigh_id) = 0x00;
- is_neigh->metrics.metric_default = 0x00; /* no special reason */
- is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
- is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
- is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
- /* don't forget the length */
- *(tlv_ptr+1) += IS_NEIGHBOURS_LEN; /* the -1 is the virtual */
- /* no need to check for fragging here, it is a lonely is_reach */
- }
-
- /* addding is reachabilities */
- LIST_LOOP (area->topology, arc, node) {
- if ((arc->from_node == lsp_top_num) ||
- (arc->to_node == lsp_top_num)) {
- if (arc->to_node == lsp_top_num) to_lsp = arc->from_node;
- if (arc->from_node == lsp_top_num) to_lsp = arc->to_node;
-
- /* if the length here is about to cross the FF limit, we reTLV */
- if (*(tlv_ptr+1) >= (0xFF - IS_NEIGHBOURS_LEN)) {
- /* retlv */
- /* the 2 is for the TL plus 1 for the virtual field*/
- tlv_ptr = lsppdu_realloc(lsp,MTYPE_ISIS_TLV, 3);
- *tlv_ptr = IS_NEIGHBOURS; /* Type */
- *(tlv_ptr+1) = 1; /* this is the virtual char len*/
- *(tlv_ptr+2) = 0; /* virtual is zero */
- }
- /* doing this here assures us that we won't add an "empty" tlv */
+ if (lsp_top_num == 1)
+ {
/* assign space for the is_neigh at the pdu end */
- is_neigh = (struct is_neigh*) lsppdu_realloc (lsp, MTYPE_ISIS_TLV,
- sizeof(struct is_neigh));
+ is_neigh = (struct is_neigh *) lsppdu_realloc (lsp, MTYPE_ISIS_TLV,
+ sizeof (struct
+ is_neigh));
/* add this node to our list */
- listnode_add (lsp->tlv_data.is_neighs, is_neigh);
- memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
LSP_PSEUDO_ID (is_neigh->neigh_id) = 0x00;
- is_neigh->neigh_id[ISIS_SYS_ID_LEN-1] = (to_lsp & 0xFF);
- is_neigh->neigh_id[ISIS_SYS_ID_LEN-2] = ((to_lsp >> 8) & 0xFF);
- is_neigh->metrics.metric_default = arc->distance;
+ is_neigh->metrics.metric_default = 0x00; /* no special reason */
is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
/* don't forget the length */
- *(tlv_ptr+1) += IS_NEIGHBOURS_LEN; /* the -1 is the virtual */
+ *(tlv_ptr + 1) += IS_NEIGHBOURS_LEN; /* the -1 is the virtual */
+ /* no need to check for fragging here, it is a lonely is_reach */
}
+
+ /* addding is reachabilities */
+ LIST_LOOP (area->topology, arc, node)
+ {
+ if ((arc->from_node == lsp_top_num) || (arc->to_node == lsp_top_num))
+ {
+ if (arc->to_node == lsp_top_num)
+ to_lsp = arc->from_node;
+ if (arc->from_node == lsp_top_num)
+ to_lsp = arc->to_node;
+
+ /* if the length here is about to cross the FF limit, we reTLV */
+ if (*(tlv_ptr + 1) >= (0xFF - IS_NEIGHBOURS_LEN))
+ {
+ /* retlv */
+ /* the 2 is for the TL plus 1 for the virtual field */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 3);
+ *tlv_ptr = IS_NEIGHBOURS; /* Type */
+ *(tlv_ptr + 1) = 1; /* this is the virtual char len */
+ *(tlv_ptr + 2) = 0; /* virtual is zero */
+ }
+ /* doing this here assures us that we won't add an "empty" tlv */
+ /* assign space for the is_neigh at the pdu end */
+ is_neigh = (struct is_neigh *) lsppdu_realloc (lsp, MTYPE_ISIS_TLV,
+ sizeof (struct
+ is_neigh));
+ /* add this node to our list */
+ listnode_add (lsp->tlv_data.is_neighs, is_neigh);
+ memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
+ LSP_PSEUDO_ID (is_neigh->neigh_id) = 0x00;
+ is_neigh->neigh_id[ISIS_SYS_ID_LEN - 1] = (to_lsp & 0xFF);
+ is_neigh->neigh_id[ISIS_SYS_ID_LEN - 2] = ((to_lsp >> 8) & 0xFF);
+ is_neigh->metrics.metric_default = arc->distance;
+ is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
+ is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
+ is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
+ /* don't forget the length */
+ *(tlv_ptr + 1) += IS_NEIGHBOURS_LEN; /* the -1 is the virtual */
+ }
}
- /* adding dynamic hostname if needed*/
- if (area->dynhostname) {
- memset (buff,0x00,200);
- sprintf (buff,"feedme%d",lsp_top_num);
- tlv_ptr = lsppdu_realloc (lsp,MTYPE_ISIS_TLV, 2); /* the 2 is for the TL */
- *tlv_ptr = DYNAMIC_HOSTNAME; /* Type */
- *(tlv_ptr+1) = strlen (buff); /* Length */
- /* the -1 is to fit the length in the struct */
- lsp->tlv_data.hostname = (struct hostname *)
- (lsppdu_realloc (lsp, MTYPE_ISIS_TLV, strlen(buff)) - 1);
- memcpy (lsp->tlv_data.hostname->name, buff, strlen(buff));
- }
+ /* adding dynamic hostname if needed */
+ if (area->dynhostname)
+ {
+ memset (buff, 0x00, 200);
+ sprintf (buff, "feedme%d", lsp_top_num);
+ /* the 2 is for the TL */
+ tlv_ptr = lsppdu_realloc (lsp, MTYPE_ISIS_TLV, 2);
+ *tlv_ptr = DYNAMIC_HOSTNAME; /* Type */
+ *(tlv_ptr + 1) = strlen (buff); /* Length */
+ /* the -1 is to fit the length in the struct */
+ lsp->tlv_data.hostname = (struct hostname *)
+ (lsppdu_realloc (lsp, MTYPE_ISIS_TLV, strlen (buff)) - 1);
+ memcpy (lsp->tlv_data.hostname->name, buff, strlen (buff));
+ }
/* thanks to hannes, another bug bites the dust */
- lsp->pdu->putp = ntohs(lsp->lsp_header->pdu_len);
- lsp->pdu->endp = ntohs(lsp->lsp_header->pdu_len);
+ lsp->pdu->putp = ntohs (lsp->lsp_header->pdu_len);
+ lsp->pdu->endp = ntohs (lsp->lsp_header->pdu_len);
}
#endif /* TOPOLOGY_GENERATE */
diff --git a/isisd/isis_lsp.h b/isisd/isis_lsp.h
index 71a7508..c6eb7c2 100644
--- a/isisd/isis_lsp.h
+++ b/isisd/isis_lsp.h
@@ -26,7 +26,7 @@
/* The grand plan is to support 1024 circuits so we have 32*32 bit flags
* the support will be achived using the newest drafts */
-#define ISIS_MAX_CIRCUITS 32 /* = 1024 */ /*FIXME:defined in flags.h as well*/
+#define ISIS_MAX_CIRCUITS 32 /* = 1024 - FIXME:defined in flags.h as well */
/* Structure for isis_lsp, this structure will only support the fixed
* System ID (Currently 6) (atleast for now). In order to support more
@@ -34,19 +34,20 @@
* sake it should better be avoided */
struct isis_lsp
{
- struct isis_fixed_hdr *isis_header; /* normally equals pdu */
- struct isis_link_state_hdr *lsp_header; /* pdu + isis_header_len */
- struct stream *pdu; /* full pdu lsp */
- union {
+ struct isis_fixed_hdr *isis_header; /* normally equals pdu */
+ struct isis_link_state_hdr *lsp_header; /* pdu + isis_header_len */
+ struct stream *pdu; /* full pdu lsp */
+ union
+ {
struct list *frags;
struct isis_lsp *zero_lsp;
} lspu;
u_int32_t SRMflags[ISIS_MAX_CIRCUITS];
u_int32_t SSNflags[ISIS_MAX_CIRCUITS];
u_int32_t rexmit_queue[ISIS_MAX_CIRCUITS];
- int level; /* L1 or L2? */
- int purged; /* have purged this one */
- int scheduled; /* scheduled for sending */
+ int level; /* L1 or L2? */
+ int purged; /* have purged this one */
+ int scheduled; /* scheduled for sending */
time_t installed;
time_t last_generated;
time_t last_sent;
@@ -56,13 +57,13 @@
struct thread *t_lsp_top_ref;
#endif
/* used for 60 second counting when rem_lifetime is zero */
- int age_out;
+ int age_out;
struct isis_adjacency *adj;
- struct tlvs tlv_data; /* Simplifies TLV access */
+ struct tlvs tlv_data; /* Simplifies TLV access */
};
dict_t *lsp_db_init (void);
-void lsp_db_destroy (dict_t *lspdb);
+void lsp_db_destroy (dict_t * lspdb);
int lsp_tick (struct thread *thread);
int lsp_l1_generate (struct isis_area *area);
@@ -73,31 +74,31 @@
int lsp_l1_pseudo_generate (struct isis_circuit *circuit);
int lsp_l2_pseudo_generate (struct isis_circuit *circuit);
-int lsp_l1_refresh_pseudo (struct thread *thread);
-int lsp_l2_refresh_pseudo (struct thread *thread);
+int lsp_l1_refresh_pseudo (struct thread *thread);
+int lsp_l2_refresh_pseudo (struct thread *thread);
int isis_lsp_authinfo_check (struct stream *stream, struct isis_area *area,
- int pdulen, struct isis_passwd *passwd);
-struct isis_lsp *lsp_new (u_char *lsp_id, u_int16_t rem_lifetime,
- u_int32_t seq_num, u_int8_t lsp_bits,
- u_int16_t checksum, int level);
-struct isis_lsp *lsp_new_from_stream_ptr (struct stream *stream,
- u_int16_t pdu_len,
- struct isis_lsp *lsp0,
- struct isis_area *area);
-void lsp_insert (struct isis_lsp *lsp, dict_t *lspdb);
-struct isis_lsp *lsp_search (u_char *id, dict_t *lspdb);
+ int pdulen, struct isis_passwd *passwd);
+struct isis_lsp *lsp_new (u_char * lsp_id, u_int16_t rem_lifetime,
+ u_int32_t seq_num, u_int8_t lsp_bits,
+ u_int16_t checksum, int level);
+struct isis_lsp *lsp_new_from_stream_ptr (struct stream *stream,
+ u_int16_t pdu_len,
+ struct isis_lsp *lsp0,
+ struct isis_area *area);
+void lsp_insert (struct isis_lsp *lsp, dict_t * lspdb);
+struct isis_lsp *lsp_search (u_char * id, dict_t * lspdb);
-void lsp_build_list (u_char *start_id, u_char *stop_id,
- struct list *list, dict_t *lspdb);
-void lsp_build_list_nonzero_ht (u_char *start_id, u_char *stop_id,
- struct list *list, dict_t *lspdb);
-void lsp_build_list_ssn (struct isis_circuit *circuit, struct list *list,
- dict_t *lspdb);
+void lsp_build_list (u_char * start_id, u_char * stop_id,
+ struct list *list, dict_t * lspdb);
+void lsp_build_list_nonzero_ht (u_char * start_id, u_char * stop_id,
+ struct list *list, dict_t * lspdb);
+void lsp_build_list_ssn (struct isis_circuit *circuit, struct list *list,
+ dict_t * lspdb);
-void lsp_search_and_destroy (u_char *id, dict_t *lspdb);
-void lsp_purge_dr (u_char *id, struct isis_circuit *circuit, int level);
-void lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr,
- struct isis_area *area);
+void lsp_search_and_destroy (u_char * id, dict_t * lspdb);
+void lsp_purge_dr (u_char * id, struct isis_circuit *circuit, int level);
+void lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr,
+ struct isis_area *area);
#define LSP_EQUAL 1
#define LSP_NEWER 2
@@ -109,24 +110,24 @@
memcpy ((I), isis->sysid, ISIS_SYS_ID_LEN);\
(I)[ISIS_SYS_ID_LEN] = 0;\
(I)[ISIS_SYS_ID_LEN + 1] = 0
-int lsp_id_cmp (u_char *id1, u_char *id2);
-int lsp_compare (char *areatag, struct isis_lsp *lsp, u_int32_t seq_num,
- u_int16_t checksum, u_int16_t rem_lifetime);
+int lsp_id_cmp (u_char * id1, u_char * id2);
+int lsp_compare (char *areatag, struct isis_lsp *lsp, u_int32_t seq_num,
+ u_int16_t checksum, u_int16_t rem_lifetime);
void lsp_update (struct isis_lsp *lsp, struct isis_link_state_hdr *lsp_hdr,
- struct stream *stream, struct isis_area *area);
+ struct stream *stream, struct isis_area *area);
void lsp_inc_seqnum (struct isis_lsp *lsp, u_int32_t seq_num);
-int lsp_print_all (struct vty *vty, dict_t *lspdb, char detail, char dynhost);
+int lsp_print_all (struct vty *vty, dict_t * lspdb, char detail,
+ char dynhost);
char *lsp_bits2string (u_char *);
/* staticly assigned vars for printing purposes */
-char lsp_bits_string[200]; /* FIXME: enough ? */
+char lsp_bits_string[200]; /* FIXME: enough ? */
#ifdef TOPOLOGY_GENERATE
void generate_topology_lsps (struct isis_area *area);
void remove_topology_lsps (struct isis_area *area);
void build_topology_lsp_data (struct isis_lsp *lsp,
- struct isis_area *area, int lsp_top_num);
+ struct isis_area *area, int lsp_top_num);
#endif /* TOPOLOGY_GENERATE */
#endif /* ISIS_LSP */
-
diff --git a/isisd/isis_main.c b/isisd/isis_main.c
index a2a7e51..d9bdd47 100644
--- a/isisd/isis_main.c
+++ b/isisd/isis_main.c
@@ -50,14 +50,12 @@
#define ISISD_VTY_PORT 2608
/* isisd privileges */
-zebra_capabilities_t _caps_p [] =
-{
+zebra_capabilities_t _caps_p[] = {
ZCAP_RAW,
ZCAP_BIND
};
-struct zebra_privs_t isisd_privs =
-{
+struct zebra_privs_t isisd_privs = {
#if defined(QUAGGA_USER)
.user = QUAGGA_USER,
#endif
@@ -73,17 +71,16 @@
};
/* isisd options */
-struct option longopts[] =
-{
- { "daemon", no_argument, NULL, 'd'},
- { "config_file", required_argument, NULL, 'f'},
- { "pid_file", required_argument, NULL, 'i'},
- { "vty_addr", required_argument, NULL, 'A'},
- { "vty_port", required_argument, NULL, 'P'},
- { "user", required_argument, NULL, 'u'},
- { "version", no_argument, NULL, 'v'},
- { "help", no_argument, NULL, 'h'},
- { 0 }
+struct option longopts[] = {
+ {"daemon", no_argument, NULL, 'd'},
+ {"config_file", required_argument, NULL, 'f'},
+ {"pid_file", required_argument, NULL, 'i'},
+ {"vty_addr", required_argument, NULL, 'A'},
+ {"vty_port", required_argument, NULL, 'P'},
+ {"user", required_argument, NULL, 'u'},
+ {"version", no_argument, NULL, 'v'},
+ {"help", no_argument, NULL, 'h'},
+ {0}
};
/* Configuration file and directory. */
@@ -108,7 +105,6 @@
char **_argv;
char **_envp;
-
/* Help information display. */
static void
usage (int status)
@@ -116,7 +112,7 @@
if (status != 0)
fprintf (stderr, "Try `%s --help' for more information.\n", progname);
else
- {
+ {
printf ("Usage : %s [OPTION...]\n\n\
Daemon which manages IS-IS routing\n\n\
-d, --daemon Runs in daemon mode\n\
@@ -154,7 +150,7 @@
* Signal handlers
*/
-void
+void
sighup (void)
{
zlog_info ("SIGHUP received");
@@ -168,7 +164,7 @@
{
zlog_info ("SIGINT received");
terminate (0);
-
+
return;
}
@@ -187,29 +183,29 @@
}
struct quagga_signal_t isisd_signals[] =
-{
- {
- .signal = SIGHUP,
- .handler = &sighup,
- },
+{
{
- .signal = SIGUSR1,
- .handler = &sigusr1,
- },
+ .signal = SIGHUP,
+ .handler = &sighup,
+ },
{
- .signal = SIGINT,
- .handler = &sigint,
- },
+ .signal = SIGUSR1,
+ .handler = &sigusr1,
+ },
{
- .signal = SIGTERM,
- .handler = &sigterm,
- },
+ .signal = SIGINT,
+ .handler = &sigint,
+ },
+ {
+ .signal = SIGTERM,
+ .handler = &sigterm,
+ },
};
/*
* Main routine of isisd. Parse arguments and handle IS-IS state machine.
*/
-int
+int
main (int argc, char **argv, char **envp)
{
char *p;
@@ -222,9 +218,8 @@
progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
zlog_default = openzlog (progname, ZLOG_NOLOG, ZLOG_ISIS,
- LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
+ LOG_CONS | LOG_NDELAY | LOG_PID, LOG_DAEMON);
-
/* for reload */
_argc = argc;
_argv = argv;
@@ -234,73 +229,73 @@
snprintf (_progpath, sizeof (_progpath), "%s/%s", _cwd, _argv[0]);
else
snprintf (_progpath, sizeof (_progpath), "%s", argv[0]);
-
+
/* Command line argument treatment. */
- while (1)
+ while (1)
{
opt = getopt_long (argc, argv, "df:i:hA:p:P:u:v", longopts, 0);
-
- if (opt == EOF)
- break;
- switch (opt)
- {
- case 0:
- break;
- case 'd':
- daemon_mode = 1;
- break;
- case 'f':
- config_file = optarg;
- break;
- case 'i':
- pid_file = optarg;
- break;
- case 'A':
- vty_addr = optarg;
- break;
- case 'P':
- /* Deal with atoi() returning 0 on failure, and isisd not
- listening on isisd port... */
- if (strcmp(optarg, "0") == 0)
- {
- vty_port = 0;
- break;
- }
- vty_port = atoi (optarg);
- vty_port = (vty_port ? vty_port : ISISD_VTY_PORT);
+ if (opt == EOF)
+ break;
+
+ switch (opt)
+ {
+ case 0:
break;
- case 'u':
- isisd_privs.user = isisd_privs.group = optarg;
- break;
- break;
- case 'v':
- printf("ISISd version %s\n", ISISD_VERSION);
- printf("Copyright (c) 2001-2002 Sampo Saaristo,"
- " Ofer Wald and Hannes Gredler\n");
- print_version ("Zebra");
- exit (0);
- break;
- case 'h':
- usage (0);
- break;
- default:
- usage (1);
- break;
- }
+ case 'd':
+ daemon_mode = 1;
+ break;
+ case 'f':
+ config_file = optarg;
+ break;
+ case 'i':
+ pid_file = optarg;
+ break;
+ case 'A':
+ vty_addr = optarg;
+ break;
+ case 'P':
+ /* Deal with atoi() returning 0 on failure, and isisd not
+ listening on isisd port... */
+ if (strcmp (optarg, "0") == 0)
+ {
+ vty_port = 0;
+ break;
+ }
+ vty_port = atoi (optarg);
+ vty_port = (vty_port ? vty_port : ISISD_VTY_PORT);
+ break;
+ case 'u':
+ isisd_privs.user = isisd_privs.group = optarg;
+ break;
+ break;
+ case 'v':
+ printf ("ISISd version %s\n", ISISD_VERSION);
+ printf ("Copyright (c) 2001-2002 Sampo Saaristo,"
+ " Ofer Wald and Hannes Gredler\n");
+ print_version ("Zebra");
+ exit (0);
+ break;
+ case 'h':
+ usage (0);
+ break;
+ default:
+ usage (1);
+ break;
+ }
}
-
+
/* thread master */
master = thread_master_create ();
/* random seed from time */
- srand(time(NULL));
+ srand (time (NULL));
/*
* initializations
*/
zprivs_init (&isisd_privs);
- signal_init (master, Q_SIGC(isisd_signals), isisd_signals);
+ signal_init (master, Q_SIGC (isisd_signals), isisd_signals);
cmd_init (1);
vty_init (master);
memory_init ();
@@ -308,7 +303,7 @@
dyn_cache_init ();
sort_node ();
- /* parse config file */
+ /* parse config file */
/* this is needed three times! because we have interfaces before the areas */
vty_read_config (config_file, config_default);
vty_read_config (config_file, config_default);
@@ -323,7 +318,7 @@
/* Make isis vty socket. */
vty_serv_sock (vty_addr, vty_port, ISIS_VTYSH_PATH);
-
+
/* Print banner. */
#if defined(ZEBRA_VERSION)
zlog_info ("ISISd %s starting: vty@%d", ZEBRA_VERSION, vty_port);
@@ -340,13 +335,3 @@
/* Not reached. */
exit (0);
}
-
-
-
-
-
-
-
-
-
-
diff --git a/isisd/isis_misc.c b/isisd/isis_misc.c
index 709dbe4..7fe5286 100644
--- a/isisd/isis_misc.c
+++ b/isisd/isis_misc.c
@@ -21,7 +21,6 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
@@ -50,28 +49,37 @@
/*
* This converts the isonet to its printable format
*/
-char * isonet_print (u_char *from, int len) {
+char *
+isonet_print (u_char * from, int len)
+{
int i = 0;
char *pos = isonet;
- if(!from)
+ if (!from)
return "unknown";
- while (i < len) {
- if (i & 1) {
- sprintf ( pos, "%02x", *(from + i));
- pos += 2;
- } else {
- if (i == (len - 1)) { /* No dot at the end of address */
- sprintf ( pos, "%02x", *(from + i));
- pos += 2;
- } else {
- sprintf ( pos, "%02x.", *(from + i));
- pos += 3;
- }
+ while (i < len)
+ {
+ if (i & 1)
+ {
+ sprintf (pos, "%02x", *(from + i));
+ pos += 2;
+ }
+ else
+ {
+ if (i == (len - 1))
+ { /* No dot at the end of address */
+ sprintf (pos, "%02x", *(from + i));
+ pos += 2;
+ }
+ else
+ {
+ sprintf (pos, "%02x.", *(from + i));
+ pos += 3;
+ }
+ }
+ i++;
}
- i++;
- }
*(pos) = '\0';
return isonet;
}
@@ -81,7 +89,7 @@
* extract dot from the dotted str, and insert all the number in a buff
*/
int
-dotformat2buff (u_char *buff, u_char *dotted)
+dotformat2buff (u_char * buff, u_char * dotted)
{
int dotlen, len = 0;
u_char *pos = dotted;
@@ -89,80 +97,96 @@
int nextdotpos = 2;
number[2] = '\0';
- dotlen = strlen(dotted);
- if (dotlen > 50) {
- /* this can't be an iso net, its too long */
- return 0;
- }
-
- while ( (pos - dotted) < dotlen && len < 20 ) {
- if (*pos == '.') {
- /* we expect the . at 2, and than every 5 */
- if ((pos - dotted) != nextdotpos) {
- len = 0;
- break;
- }
- nextdotpos += 5;
- pos++;
- continue;
- }
- /* we must have at least two chars left here */
- if (dotlen - (pos - dotted) < 2) {
- len = 0;
- break;
+ dotlen = strlen (dotted);
+ if (dotlen > 50)
+ {
+ /* this can't be an iso net, its too long */
+ return 0;
}
- if ((isxdigit((int)*pos)) && (isxdigit((int)*(pos+1)))){
- memcpy (number, pos ,2);
- pos+=2;
- } else {
- len = 0;
- break;
+ while ((pos - dotted) < dotlen && len < 20)
+ {
+ if (*pos == '.')
+ {
+ /* we expect the . at 2, and than every 5 */
+ if ((pos - dotted) != nextdotpos)
+ {
+ len = 0;
+ break;
+ }
+ nextdotpos += 5;
+ pos++;
+ continue;
+ }
+ /* we must have at least two chars left here */
+ if (dotlen - (pos - dotted) < 2)
+ {
+ len = 0;
+ break;
+ }
+
+ if ((isxdigit ((int) *pos)) && (isxdigit ((int) *(pos + 1))))
+ {
+ memcpy (number, pos, 2);
+ pos += 2;
+ }
+ else
+ {
+ len = 0;
+ break;
+ }
+
+ *(buff + len) = (char) strtol (number, NULL, 16);
+ len++;
}
- *(buff + len) = (char)strtol(number, NULL, 16);
- len++;
- }
-
return len;
}
+
/*
* conversion of XXXX.XXXX.XXXX to memory
*/
int
-sysid2buff (u_char *buff, u_char *dotted)
- {
+sysid2buff (u_char * buff, u_char * dotted)
+{
int len = 0;
u_char *pos = dotted;
u_char number[3];
number[2] = '\0';
// surely not a sysid_string if not 14 length
- if (strlen(dotted) != 14) {
- return 0;
- }
-
- while ( len < ISIS_SYS_ID_LEN ) {
- if (*pos == '.') {
- /* the . is not positioned correctly */
- if (((pos - dotted) !=4) && ((pos - dotted) != 9)) {
- len = 0;
- break;
- }
- pos++;
- continue;
- }
- if ((isxdigit((int)*pos)) && (isxdigit((int)*(pos+1)))){
- memcpy (number, pos ,2);
- pos+=2;
- } else {
- len = 0;
- break;
+ if (strlen (dotted) != 14)
+ {
+ return 0;
}
- *(buff + len) = (char)strtol(number, NULL, 16);
- len++;
- }
+ while (len < ISIS_SYS_ID_LEN)
+ {
+ if (*pos == '.')
+ {
+ /* the . is not positioned correctly */
+ if (((pos - dotted) != 4) && ((pos - dotted) != 9))
+ {
+ len = 0;
+ break;
+ }
+ pos++;
+ continue;
+ }
+ if ((isxdigit ((int) *pos)) && (isxdigit ((int) *(pos + 1))))
+ {
+ memcpy (number, pos, 2);
+ pos += 2;
+ }
+ else
+ {
+ len = 0;
+ break;
+ }
+
+ *(buff + len) = (char) strtol (number, NULL, 16);
+ len++;
+ }
return len;
@@ -174,79 +198,82 @@
*/
char *
-nlpid2string (struct nlpids *nlpids) {
+nlpid2string (struct nlpids *nlpids)
+{
char *pos = nlpidstring;
int i;
- for (i=0;i<nlpids->count;i++) {
- switch (nlpids->nlpids[i]) {
- case NLPID_IP:
- pos += sprintf (pos, "IPv4");
- break;
- case NLPID_IPV6:
- pos += sprintf (pos, "IPv6");
- break;
- case NLPID_SNAP:
- pos += sprintf (pos, "SNAP");
- break;
- case NLPID_CLNP:
- pos += sprintf (pos, "CLNP");
- break;
- case NLPID_ESIS:
- pos += sprintf (pos, "ES-IS");
- break;
- default:
- pos += sprintf (pos, "unknown");
- break;
+ for (i = 0; i < nlpids->count; i++)
+ {
+ switch (nlpids->nlpids[i])
+ {
+ case NLPID_IP:
+ pos += sprintf (pos, "IPv4");
+ break;
+ case NLPID_IPV6:
+ pos += sprintf (pos, "IPv6");
+ break;
+ case NLPID_SNAP:
+ pos += sprintf (pos, "SNAP");
+ break;
+ case NLPID_CLNP:
+ pos += sprintf (pos, "CLNP");
+ break;
+ case NLPID_ESIS:
+ pos += sprintf (pos, "ES-IS");
+ break;
+ default:
+ pos += sprintf (pos, "unknown");
+ break;
+ }
+ if (nlpids->count - i > 1)
+ pos += sprintf (pos, ", ");
+
}
- if (nlpids->count-i>1)
- pos += sprintf (pos, ", ");
-
- }
*(pos) = '\0';
-
+
return nlpidstring;
}
/*
* supports the given af ?
*/
-int
+int
speaks (struct nlpids *nlpids, int family)
{
int i, speaks = 0;
-
- if (nlpids == (struct nlpids*)NULL)
+
+ if (nlpids == (struct nlpids *) NULL)
return speaks;
- for (i = 0;i < nlpids->count; i++) {
- if (family == AF_INET && nlpids->nlpids[i] == NLPID_IP)
- speaks = 1;
- if (family == AF_INET6 && nlpids->nlpids[i] == NLPID_IPV6)
- speaks = 1;
- }
+ for (i = 0; i < nlpids->count; i++)
+ {
+ if (family == AF_INET && nlpids->nlpids[i] == NLPID_IP)
+ speaks = 1;
+ if (family == AF_INET6 && nlpids->nlpids[i] == NLPID_IPV6)
+ speaks = 1;
+ }
return speaks;
}
-
/*
* Returns 0 on error, IS-IS Circuit Type on ok
*/
-int
-string2circuit_t (u_char *str)
+int
+string2circuit_t (u_char * str)
{
-
+
if (!str)
return 0;
-
- if (!strcmp(str,"level-1"))
+
+ if (!strcmp (str, "level-1"))
return IS_LEVEL_1;
- if (!strcmp(str,"level-2-only") || !strcmp(str,"level-2"))
+ if (!strcmp (str, "level-2-only") || !strcmp (str, "level-2"))
return IS_LEVEL_2;
-
- if (!strcmp(str,"level-1-2"))
+
+ if (!strcmp (str, "level-1-2"))
return IS_LEVEL_1_AND_2;
return 0;
@@ -255,62 +282,68 @@
const char *
circuit_t2string (int circuit_t)
{
- switch (circuit_t) {
- case IS_LEVEL_1:
- return "L1";
- case IS_LEVEL_2:
- return "L2";
- case IS_LEVEL_1_AND_2:
- return "L1L2";
- default:
- return "??";
- }
+ switch (circuit_t)
+ {
+ case IS_LEVEL_1:
+ return "L1";
+ case IS_LEVEL_2:
+ return "L2";
+ case IS_LEVEL_1_AND_2:
+ return "L1L2";
+ default:
+ return "??";
+ }
- return NULL; /* not reached */
+ return NULL; /* not reached */
}
const char *
syst2string (int type)
{
- switch (type) {
- case ISIS_SYSTYPE_ES:
- return "ES";
- case ISIS_SYSTYPE_IS:
- return "IS";
- case ISIS_SYSTYPE_L1_IS:
- return "1";
- case ISIS_SYSTYPE_L2_IS:
- return "2";
- default:
- return "??";
- }
+ switch (type)
+ {
+ case ISIS_SYSTYPE_ES:
+ return "ES";
+ case ISIS_SYSTYPE_IS:
+ return "IS";
+ case ISIS_SYSTYPE_L1_IS:
+ return "1";
+ case ISIS_SYSTYPE_L2_IS:
+ return "2";
+ default:
+ return "??";
+ }
- return NULL; /* not reached */
+ return NULL; /* not reached */
}
/*
* Print functions - we print to static vars
*/
char *
-snpa_print (u_char *from)
+snpa_print (u_char * from)
{
int i = 0;
u_char *pos = snpa;
- if(!from)
+ if (!from)
return "unknown";
-
- while (i < ETH_ALEN - 1) {
- if (i & 1) {
- sprintf ( pos, "%02x.", *(from + i));
- pos += 3;
- } else {
- sprintf ( pos, "%02x", *(from + i));
- pos += 2;
+ while (i < ETH_ALEN - 1)
+ {
+ if (i & 1)
+ {
+ sprintf (pos, "%02x.", *(from + i));
+ pos += 3;
+ }
+ else
+ {
+ sprintf (pos, "%02x", *(from + i));
+ pos += 2;
+
+ }
+ i++;
}
- i++;
- }
sprintf (pos, "%02x", *(from + (ISIS_SYS_ID_LEN - 1)));
pos += 2;
@@ -320,44 +353,48 @@
}
char *
-sysid_print (u_char *from)
+sysid_print (u_char * from)
{
int i = 0;
char *pos = sysid;
- if(!from)
+ if (!from)
return "unknown";
- while (i < ISIS_SYS_ID_LEN - 1) {
- if (i & 1) {
- sprintf ( pos, "%02x.", *(from + i));
- pos += 3;
- } else {
- sprintf ( pos, "%02x", *(from + i));
- pos += 2;
-
- }
- i++;
- }
+ while (i < ISIS_SYS_ID_LEN - 1)
+ {
+ if (i & 1)
+ {
+ sprintf (pos, "%02x.", *(from + i));
+ pos += 3;
+ }
+ else
+ {
+ sprintf (pos, "%02x", *(from + i));
+ pos += 2;
+
+ }
+ i++;
+ }
sprintf (pos, "%02x", *(from + (ISIS_SYS_ID_LEN - 1)));
pos += 2;
*(pos) = '\0';
-
+
return sysid;
}
char *
-rawlspid_print (u_char *from)
+rawlspid_print (u_char * from)
{
char *pos = lspid;
- if(!from)
+ if (!from)
return "unknown";
- memcpy(pos, sysid_print(from), 15);
+ memcpy (pos, sysid_print (from), 15);
pos += 14;
- sprintf (pos, ".%02x", LSP_PSEUDO_ID(from));
+ sprintf (pos, ".%02x", LSP_PSEUDO_ID (from));
pos += 3;
- sprintf (pos, "-%02x", LSP_FRAGMENT(from));
+ sprintf (pos, "-%02x", LSP_FRAGMENT (from));
pos += 3;
*(pos) = '\0';
@@ -366,34 +403,35 @@
}
char *
-time2string (u_int32_t time) {
- char *pos = datestring;
+time2string (u_int32_t time)
+{
+ char *pos = datestring;
u_int32_t rest;
- if (time==0)
+ if (time == 0)
return "-";
- if(time/SECS_PER_YEAR)
- pos += sprintf (pos, "%uY",time/SECS_PER_YEAR);
- rest=time%SECS_PER_YEAR;
- if(rest/SECS_PER_MONTH)
- pos += sprintf (pos, "%uM",rest/SECS_PER_MONTH);
- rest=rest%SECS_PER_MONTH;
- if(rest/SECS_PER_WEEK)
- pos += sprintf (pos, "%uw",rest/SECS_PER_WEEK);
- rest=rest%SECS_PER_WEEK;
- if(rest/SECS_PER_DAY)
- pos += sprintf (pos, "%ud",rest/SECS_PER_DAY);
- rest=rest%SECS_PER_DAY;
- if(rest/SECS_PER_HOUR)
- pos += sprintf (pos, "%uh",rest/SECS_PER_HOUR);
- rest=rest%SECS_PER_HOUR;
- if(rest/SECS_PER_MINUTE)
- pos += sprintf (pos, "%um",rest/SECS_PER_MINUTE);
- rest=rest%SECS_PER_MINUTE;
- if(rest)
- pos += sprintf (pos, "%us",rest);
-
+ if (time / SECS_PER_YEAR)
+ pos += sprintf (pos, "%uY", time / SECS_PER_YEAR);
+ rest = time % SECS_PER_YEAR;
+ if (rest / SECS_PER_MONTH)
+ pos += sprintf (pos, "%uM", rest / SECS_PER_MONTH);
+ rest = rest % SECS_PER_MONTH;
+ if (rest / SECS_PER_WEEK)
+ pos += sprintf (pos, "%uw", rest / SECS_PER_WEEK);
+ rest = rest % SECS_PER_WEEK;
+ if (rest / SECS_PER_DAY)
+ pos += sprintf (pos, "%ud", rest / SECS_PER_DAY);
+ rest = rest % SECS_PER_DAY;
+ if (rest / SECS_PER_HOUR)
+ pos += sprintf (pos, "%uh", rest / SECS_PER_HOUR);
+ rest = rest % SECS_PER_HOUR;
+ if (rest / SECS_PER_MINUTE)
+ pos += sprintf (pos, "%um", rest / SECS_PER_MINUTE);
+ rest = rest % SECS_PER_MINUTE;
+ if (rest)
+ pos += sprintf (pos, "%us", rest);
+
*(pos) = 0;
return datestring;
@@ -406,12 +444,12 @@
* first argument is the timer and the second is
* the jitter
*/
-unsigned long
+unsigned long
isis_jitter (unsigned long timer, unsigned long jitter)
{
- int j,k;
+ int j, k;
- if (jitter>=100)
+ if (jitter >= 100)
return timer;
if (timer == 1)
@@ -423,9 +461,9 @@
* most IS-IS timers are no longer than 16 bit
*/
- j = 1 + (int) ((RANDOM_SPREAD * rand()) / (RAND_MAX + 1.0 ));
+ j = 1 + (int) ((RANDOM_SPREAD * rand ()) / (RAND_MAX + 1.0));
- k = timer - (timer * (100 - jitter))/100;
+ k = timer - (timer * (100 - jitter)) / 100;
timer = timer - (k * j / RANDOM_SPREAD);
@@ -433,11 +471,11 @@
}
struct in_addr
-newprefix2inaddr (u_char *prefix_start, u_char prefix_masklen)
+newprefix2inaddr (u_char * prefix_start, u_char prefix_masklen)
{
- memset(&new_prefix, 0, sizeof (new_prefix));
- memcpy(&new_prefix, prefix_start, (prefix_masklen & 0x3F) ?
- ((((prefix_masklen & 0x3F)-1)>>3)+1) : 0);
+ memset (&new_prefix, 0, sizeof (new_prefix));
+ memcpy (&new_prefix, prefix_start, (prefix_masklen & 0x3F) ?
+ ((((prefix_masklen & 0x3F) - 1) >> 3) + 1) : 0);
return new_prefix;
}
@@ -446,17 +484,18 @@
* it returns the system hostname.
*/
const char *
-unix_hostname(void)
+unix_hostname (void)
{
static struct utsname names;
const char *hostname;
extern struct host host;
hostname = host.name;
- if (!hostname) {
- uname(&names);
- hostname = names.nodename;
- }
+ if (!hostname)
+ {
+ uname (&names);
+ hostname = names.nodename;
+ }
return hostname;
}
diff --git a/isisd/isis_misc.h b/isisd/isis_misc.h
index ca0c0ae..75c8d8b 100644
--- a/isisd/isis_misc.h
+++ b/isisd/isis_misc.h
@@ -28,7 +28,8 @@
int string2circuit_t (u_char *);
const char *circuit_t2string (int);
const char *syst2string (int);
-struct in_addr newprefix2inaddr (u_char *prefix_start, u_char prefix_masklen);
+struct in_addr newprefix2inaddr (u_char * prefix_start,
+ u_char prefix_masklen);
/*
* Converting input to memory stored format
* return value of 0 indicates wrong input
@@ -41,41 +42,38 @@
*/
char *isonet_print (u_char *, int len);
char *sysid_print (u_char *);
-char *snpa_print (u_char *);
+char *snpa_print (u_char *);
char *rawlspid_print (u_char *);
char *time2string (u_int32_t);
/* typedef struct nlpids nlpids; */
char *nlpid2string (struct nlpids *);
-
/*
* misc functions
*/
-int speaks (struct nlpids *nlpids, int family);
+int speaks (struct nlpids *nlpids, int family);
unsigned long isis_jitter (unsigned long timer, unsigned long jitter);
-const char * unix_hostname(void);
-
+const char *unix_hostname (void);
/*
* macros
*/
#define GETSYSID(A,L) (A->area_addr + (A->addr_len - (L + 1)))
-
/* staticly assigned vars for printing purposes */
-struct in_addr new_prefix;
+struct in_addr new_prefix;
/* len of xxxx.xxxx.xxxx + place for #0 termination */
-char sysid[15];
+char sysid[15];
/* len of xxxx.xxxx.xxxx + place for #0 termination */
-char snpa[15];
+char snpa[15];
/* len of xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx */
-char isonet[51];
+char isonet[51];
/* + place for #0 termination */
/* len of xxxx.xxxx.xxxx.xx.xx + place for #0 termination */
-char lspid[21];
+char lspid[21];
/* len of xxYxxMxWxdxxhxxmxxs + place for #0 termination */
-char datestring[20];
-char nlpidstring[30];
+char datestring[20];
+char nlpidstring[30];
/* used for calculating nice string representation instead of plain seconds */
@@ -86,11 +84,11 @@
#define SECS_PER_MONTH 2628000
#define SECS_PER_YEAR 31536000
-enum {
+enum
+{
ISIS_UI_LEVEL_BRIEF,
ISIS_UI_LEVEL_DETAIL,
ISIS_UI_LEVEL_EXTENSIVE,
};
-
-#endif
+#endif
diff --git a/isisd/isis_network.c b/isisd/isis_network.c
index 4f9af61..080863b 100644
--- a/isisd/isis_network.c
+++ b/isisd/isis_network.c
@@ -25,18 +25,16 @@
#include <errno.h>
#include <zebra.h>
#ifdef GNU_LINUX
-#include <net/ethernet.h> /* the L2 protocols */
+#include <net/ethernet.h> /* the L2 protocols */
#else
#include <net/if.h>
#include <netinet/if_ether.h>
#endif
-
#include "log.h"
#include "stream.h"
#include "if.h"
-
#include "isisd/dict.h"
#include "isisd/include-netbsd/iso.h"
#include "isisd/isis_constants.h"
@@ -59,19 +57,19 @@
*/
#ifdef GNU_LINUX
#include <netpacket/packet.h>
-#else
+#else
#include <sys/time.h>
#include <sys/ioctl.h>
#include <net/bpf.h>
struct bpf_insn llcfilter[] = {
- BPF_STMT(BPF_LD+BPF_B+BPF_ABS, ETHER_HDR_LEN), /* check first byte */
- BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ISO_SAP, 0, 5),
- BPF_STMT(BPF_LD+BPF_B+BPF_ABS, ETHER_HDR_LEN+1),
- BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ISO_SAP, 0, 3), /* check second byte */
- BPF_STMT(BPF_LD+BPF_B+BPF_ABS, ETHER_HDR_LEN+2),
- BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x03, 0, 1), /* check third byte */
- BPF_STMT(BPF_RET+BPF_K, (u_int)-1),
- BPF_STMT(BPF_RET+BPF_K, 0)
+ BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN), /* check first byte */
+ BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 5),
+ BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 1),
+ BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 3), /* check second byte */
+ BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 2),
+ BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, 0x03, 0, 1), /* check third byte */
+ BPF_STMT (BPF_RET + BPF_K, (u_int) - 1),
+ BPF_STMT (BPF_RET + BPF_K, 0)
};
int readblen = 0;
u_char *readbuff = NULL;
@@ -82,10 +80,10 @@
* ISO 10589 - 8.4.8
*/
-u_char ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
-u_char ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
-u_char ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
-u_char ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
+u_char ALL_L1_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x14 };
+u_char ALL_L2_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x15 };
+u_char ALL_ISS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x05 };
+u_char ALL_ESS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x04 };
#ifdef GNU_LINUX
static char discard_buff[8192];
@@ -102,89 +100,101 @@
{
struct packet_mreq mreq;
- memset(&mreq, 0, sizeof(mreq));
+ memset (&mreq, 0, sizeof (mreq));
mreq.mr_ifindex = if_num;
- if (registerto) {
- mreq.mr_type = PACKET_MR_MULTICAST;
- mreq.mr_alen = ETH_ALEN;
- if (registerto == 1)
- memcpy (&mreq.mr_address, ALL_L1_ISS, ETH_ALEN);
- else if (registerto == 2)
- memcpy (&mreq.mr_address, ALL_L2_ISS, ETH_ALEN);
- else if (registerto == 3)
- memcpy (&mreq.mr_address, ALL_ISS, ETH_ALEN);
- else
- memcpy (&mreq.mr_address, ALL_ESS, ETH_ALEN);
+ if (registerto)
+ {
+ mreq.mr_type = PACKET_MR_MULTICAST;
+ mreq.mr_alen = ETH_ALEN;
+ if (registerto == 1)
+ memcpy (&mreq.mr_address, ALL_L1_ISS, ETH_ALEN);
+ else if (registerto == 2)
+ memcpy (&mreq.mr_address, ALL_L2_ISS, ETH_ALEN);
+ else if (registerto == 3)
+ memcpy (&mreq.mr_address, ALL_ISS, ETH_ALEN);
+ else
+ memcpy (&mreq.mr_address, ALL_ESS, ETH_ALEN);
- } else {
- mreq.mr_type = PACKET_MR_ALLMULTI;
- }
+ }
+ else
+ {
+ mreq.mr_type = PACKET_MR_ALLMULTI;
+ }
#ifdef EXTREME_DEBUG
zlog_info ("isis_multicast_join(): fd=%d, reg_to=%d, if_num=%d, "
- "address = %02x:%02x:%02x:%02x:%02x:%02x",
- fd, registerto, if_num, mreq.mr_address[0], mreq.mr_address[1],
- mreq.mr_address[2], mreq.mr_address[3],mreq.mr_address[4],
- mreq.mr_address[5]);
+ "address = %02x:%02x:%02x:%02x:%02x:%02x",
+ fd, registerto, if_num, mreq.mr_address[0], mreq.mr_address[1],
+ mreq.mr_address[2], mreq.mr_address[3], mreq.mr_address[4],
+ mreq.mr_address[5]);
#endif /* EXTREME_DEBUG */
- if (setsockopt (fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq,
- sizeof (struct packet_mreq))) {
- zlog_warn ("isis_multicast_join(): setsockopt(): %s", strerror (errno));
- return ISIS_WARNING;
- }
-
+ if (setsockopt (fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq,
+ sizeof (struct packet_mreq)))
+ {
+ zlog_warn ("isis_multicast_join(): setsockopt(): %s", strerror (errno));
+ return ISIS_WARNING;
+ }
+
return ISIS_OK;
}
-int
+int
open_packet_socket (struct isis_circuit *circuit)
{
struct sockaddr_ll s_addr;
int fd, retval = ISIS_OK;
-
+
fd = socket (PF_PACKET, SOCK_DGRAM, htons (ETH_P_ALL));
- if (fd < 0) {
- zlog_warn ("open_packet_socket(): socket() failed %s", strerror (errno));
- return ISIS_WARNING;
- }
+ if (fd < 0)
+ {
+ zlog_warn ("open_packet_socket(): socket() failed %s",
+ strerror (errno));
+ return ISIS_WARNING;
+ }
/*
* Bind to the physical interface
*/
- memset(&s_addr, 0, sizeof (struct sockaddr_ll));
+ memset (&s_addr, 0, sizeof (struct sockaddr_ll));
s_addr.sll_family = AF_PACKET;
s_addr.sll_protocol = htons (ETH_P_ALL);
s_addr.sll_ifindex = circuit->interface->ifindex;
-
- if (bind (fd, (struct sockaddr*) (&s_addr),
- sizeof(struct sockaddr_ll)) < 0) {
- zlog_warn ("open_packet_socket(): bind() failed: %s", strerror(errno));
- return ISIS_WARNING;
- }
-
+
+ if (bind (fd, (struct sockaddr *) (&s_addr),
+ sizeof (struct sockaddr_ll)) < 0)
+ {
+ zlog_warn ("open_packet_socket(): bind() failed: %s", strerror (errno));
+ return ISIS_WARNING;
+ }
+
circuit->fd = fd;
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- /*
- * Join to multicast groups
- * according to
- * 8.4.2 - Broadcast subnetwork IIH PDUs
- * FIXME: is there a case only one will fail??
- */
- if (circuit->circuit_is_type & IS_LEVEL_1) {
- /* joining ALL_L1_ISS */
- retval = isis_multicast_join (circuit->fd, 1,
- circuit->interface->ifindex);
- /* joining ALL_ISS */
- retval = isis_multicast_join (circuit->fd, 3,
- circuit->interface->ifindex);
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ /*
+ * Join to multicast groups
+ * according to
+ * 8.4.2 - Broadcast subnetwork IIH PDUs
+ * FIXME: is there a case only one will fail??
+ */
+ if (circuit->circuit_is_type & IS_LEVEL_1)
+ {
+ /* joining ALL_L1_ISS */
+ retval = isis_multicast_join (circuit->fd, 1,
+ circuit->interface->ifindex);
+ /* joining ALL_ISS */
+ retval = isis_multicast_join (circuit->fd, 3,
+ circuit->interface->ifindex);
+ }
+ if (circuit->circuit_is_type & IS_LEVEL_2)
+ /* joining ALL_L2_ISS */
+ retval = isis_multicast_join (circuit->fd, 2,
+ circuit->interface->ifindex);
}
- if (circuit->circuit_is_type & IS_LEVEL_2)
- /* joining ALL_L2_ISS */
- retval = isis_multicast_join (circuit->fd, 2,
- circuit->interface->ifindex);
- } else {
- retval = isis_multicast_join (circuit->fd, 0, circuit->interface->ifindex);
- }
+ else
+ {
+ retval =
+ isis_multicast_join (circuit->fd, 0, circuit->interface->ifindex);
+ }
return retval;
}
@@ -201,101 +211,110 @@
int true = 1, false = 0;
struct timeval timeout;
struct bpf_program bpf_prog;
-
- do {
- (void)snprintf(bpfdev, sizeof(bpfdev), "/dev/bpf%d", i++);
- fd = open(bpfdev, O_RDWR);
- } while (fd < 0 && errno == EBUSY);
-
- if (fd < 0) {
- zlog_warn ("open_bpf_dev(): failed to create bpf socket: %s",
- strerror (errno));
- return ISIS_WARNING;
- }
-
+
+ do
+ {
+ (void) snprintf (bpfdev, sizeof (bpfdev), "/dev/bpf%d", i++);
+ fd = open (bpfdev, O_RDWR);
+ }
+ while (fd < 0 && errno == EBUSY);
+
+ if (fd < 0)
+ {
+ zlog_warn ("open_bpf_dev(): failed to create bpf socket: %s",
+ strerror (errno));
+ return ISIS_WARNING;
+ }
+
zlog_info ("Opened BPF device %s", bpfdev);
- memcpy (ifr.ifr_name, circuit->interface->name, sizeof(ifr.ifr_name));
- if (ioctl (fd, BIOCSETIF, (caddr_t)&ifr) < 0 ) {
- zlog_warn ("open_bpf_dev(): failed to bind to interface: %s",
- strerror (errno));
- return ISIS_WARNING;
- }
+ memcpy (ifr.ifr_name, circuit->interface->name, sizeof (ifr.ifr_name));
+ if (ioctl (fd, BIOCSETIF, (caddr_t) & ifr) < 0)
+ {
+ zlog_warn ("open_bpf_dev(): failed to bind to interface: %s",
+ strerror (errno));
+ return ISIS_WARNING;
+ }
+ if (ioctl (fd, BIOCGBLEN, (caddr_t) & blen) < 0)
+ {
+ zlog_warn ("failed to get BPF buffer len");
+ blen = circuit->interface->mtu;
+ }
- if (ioctl (fd, BIOCGBLEN, (caddr_t)&blen) < 0) {
- zlog_warn ("failed to get BPF buffer len");
- blen = circuit->interface->mtu;
- }
-
readblen = blen;
if (readbuff == NULL)
readbuff = malloc (blen);
-
+
zlog_info ("BPF buffer len = %u", blen);
/* BPF(4): reads return immediately upon packet reception.
* Otherwise, a read will block until either the kernel
* buffer becomes full or a timeout occurs.
*/
- if (ioctl (fd, BIOCIMMEDIATE, (caddr_t)&true) < 0) {
- zlog_warn ("failed to set BPF dev to immediate mode");
- }
+ if (ioctl (fd, BIOCIMMEDIATE, (caddr_t) & true) < 0)
+ {
+ zlog_warn ("failed to set BPF dev to immediate mode");
+ }
#ifdef BIOCSSEESENT
/*
* We want to see only incoming packets
*/
- if (ioctl (fd, BIOCSSEESENT, (caddr_t)&false) < 0) {
- zlog_warn ("failed to set BPF dev to incoming only mode");
- }
+ if (ioctl (fd, BIOCSSEESENT, (caddr_t) & false) < 0)
+ {
+ zlog_warn ("failed to set BPF dev to incoming only mode");
+ }
#endif
/*
* ...but all of them
*/
- if (ioctl (fd, BIOCPROMISC, (caddr_t)&true) < 0) {
- zlog_warn ("failed to set BPF dev to promiscuous mode");
- }
-
+ if (ioctl (fd, BIOCPROMISC, (caddr_t) & true) < 0)
+ {
+ zlog_warn ("failed to set BPF dev to promiscuous mode");
+ }
/*
* If the buffer length is smaller than our mtu, lets try to increase it
*/
- if (blen < circuit->interface->mtu) {
- if (ioctl (fd, BIOCSBLEN, &circuit->interface->mtu) < 0) {
- zlog_warn ("failed to set BPF buffer len (%u to %u)", blen,
- circuit->interface->mtu);
+ if (blen < circuit->interface->mtu)
+ {
+ if (ioctl (fd, BIOCSBLEN, &circuit->interface->mtu) < 0)
+ {
+ zlog_warn ("failed to set BPF buffer len (%u to %u)", blen,
+ circuit->interface->mtu);
+ }
}
- }
/*
* Set a timeout parameter - hope this helps select()
*/
timeout.tv_sec = 600;
timeout.tv_usec = 0;
- if (ioctl (fd, BIOCSRTIMEOUT, (caddr_t)&timeout) < 0) {
- zlog_warn ("failed to set BPF device timeout");
- }
-
+ if (ioctl (fd, BIOCSRTIMEOUT, (caddr_t) & timeout) < 0)
+ {
+ zlog_warn ("failed to set BPF device timeout");
+ }
+
/*
* And set the filter
*/
memset (&bpf_prog, 0, sizeof (struct bpf_program));
bpf_prog.bf_len = 8;
bpf_prog.bf_insns = &(llcfilter[0]);
- if (ioctl (fd, BIOCSETF, (caddr_t)&bpf_prog) < 0) {
- zlog_warn ("open_bpf_dev(): failed to install filter: %s",
- strerror (errno));
- return ISIS_WARNING;
- }
-
+ if (ioctl (fd, BIOCSETF, (caddr_t) & bpf_prog) < 0)
+ {
+ zlog_warn ("open_bpf_dev(): failed to install filter: %s",
+ strerror (errno));
+ return ISIS_WARNING;
+ }
assert (fd > 0);
circuit->fd = fd;
-
+
return ISIS_OK;
}
@@ -309,9 +328,8 @@
{
int retval = ISIS_OK;
- if ( isisd_privs.change (ZPRIVS_RAISE) )
- zlog_err ("%s: could not raise privs, %s", __func__,
- strerror (errno) );
+ if (isisd_privs.change (ZPRIVS_RAISE))
+ zlog_err ("%s: could not raise privs, %s", __func__, strerror (errno));
#ifdef GNU_LINUX
retval = open_packet_socket (circuit);
@@ -319,46 +337,48 @@
retval = open_bpf_dev (circuit);
#endif
- if (retval != ISIS_OK) {
- zlog_warn("%s: could not initialize the socket",
- __func__);
- goto end;
- }
-
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- circuit->tx = isis_send_pdu_bcast;
- circuit->rx = isis_recv_pdu_bcast;
- } else if (circuit->circ_type == CIRCUIT_T_P2P) {
- circuit->tx = isis_send_pdu_p2p;
- circuit->rx = isis_recv_pdu_p2p;
- } else {
- zlog_warn ("isis_sock_init(): unknown circuit type");
- retval = ISIS_WARNING;
- goto end;
- }
-
+ if (retval != ISIS_OK)
+ {
+ zlog_warn ("%s: could not initialize the socket", __func__);
+ goto end;
+ }
+
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ circuit->tx = isis_send_pdu_bcast;
+ circuit->rx = isis_recv_pdu_bcast;
+ }
+ else if (circuit->circ_type == CIRCUIT_T_P2P)
+ {
+ circuit->tx = isis_send_pdu_p2p;
+ circuit->rx = isis_recv_pdu_p2p;
+ }
+ else
+ {
+ zlog_warn ("isis_sock_init(): unknown circuit type");
+ retval = ISIS_WARNING;
+ goto end;
+ }
+
end:
- if ( isisd_privs.change (ZPRIVS_LOWER) )
- zlog_err ("%s: could not lower privs, %s", __func__,
- strerror (errno) );
+ if (isisd_privs.change (ZPRIVS_LOWER))
+ zlog_err ("%s: could not lower privs, %s", __func__, strerror (errno));
return retval;
}
-
-static inline int
-llc_check (u_char *llc)
+static inline int
+llc_check (u_char * llc)
{
-
- if(*llc != ISO_SAP || *(llc + 1) != ISO_SAP || *(llc +2) != 3)
+ if (*llc != ISO_SAP || *(llc + 1) != ISO_SAP || *(llc + 2) != 3)
return 0;
-
+
return 1;
}
#ifdef GNU_LINUX
int
-isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char *ssnpa)
+isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa)
{
int bytesread, addr_len;
struct sockaddr_ll s_addr;
@@ -368,50 +388,51 @@
memset (&s_addr, 0, sizeof (struct sockaddr_ll));
- bytesread = recvfrom (circuit->fd, (void *)&llc,
- LLC_LEN, MSG_PEEK,
- (struct sockaddr *)&s_addr, &addr_len);
+ bytesread = recvfrom (circuit->fd, (void *) &llc,
+ LLC_LEN, MSG_PEEK,
+ (struct sockaddr *) &s_addr, &addr_len);
- if (bytesread < 0) {
- zlog_warn ("isis_recv_packet_bcast(): fd %d, recvfrom (): %s",
- circuit->fd, strerror (errno));
- zlog_warn ("circuit is %s", circuit->interface->name);
- zlog_warn ("circuit fd %d", circuit->fd);
- zlog_warn ("bytesread %d", bytesread);
- /* get rid of the packet */
- bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
- return ISIS_WARNING;
- }
+ if (bytesread < 0)
+ {
+ zlog_warn ("isis_recv_packet_bcast(): fd %d, recvfrom (): %s",
+ circuit->fd, strerror (errno));
+ zlog_warn ("circuit is %s", circuit->interface->name);
+ zlog_warn ("circuit fd %d", circuit->fd);
+ zlog_warn ("bytesread %d", bytesread);
+ /* get rid of the packet */
+ bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
+ return ISIS_WARNING;
+ }
/*
* Filtering by llc field, discard packets sent by this host (other circuit)
*/
- if (!llc_check (llc) || s_addr.sll_pkttype == PACKET_OUTGOING) {
- /* Read the packet into discard buff */
- bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
- if (bytesread < 0)
- zlog_warn ("isis_recv_pdu_bcast(): read() failed");
- return ISIS_WARNING;
- }
-
+ if (!llc_check (llc) || s_addr.sll_pkttype == PACKET_OUTGOING)
+ {
+ /* Read the packet into discard buff */
+ bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
+ if (bytesread < 0)
+ zlog_warn ("isis_recv_pdu_bcast(): read() failed");
+ return ISIS_WARNING;
+ }
+
/* on lan we have to read to the static buff first */
bytesread = recvfrom (circuit->fd, sock_buff, circuit->interface->mtu, 0,
- (struct sockaddr *)&s_addr, &addr_len);
-
+ (struct sockaddr *) &s_addr, &addr_len);
+
/* then we lose the LLC */
- memcpy (STREAM_DATA (circuit->rcv_stream),
- sock_buff + LLC_LEN, bytesread - LLC_LEN);
+ memcpy (STREAM_DATA (circuit->rcv_stream),
+ sock_buff + LLC_LEN, bytesread - LLC_LEN);
circuit->rcv_stream->putp = bytesread - LLC_LEN;
circuit->rcv_stream->endp = bytesread - LLC_LEN;
-
- memcpy (ssnpa, &s_addr.sll_addr, s_addr.sll_halen);
-
+
+ memcpy (ssnpa, &s_addr.sll_addr, s_addr.sll_halen);
+
return ISIS_OK;
}
int
-isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char *ssnpa)
+isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char * ssnpa)
{
-
int bytesread, addr_len;
struct sockaddr_ll s_addr;
@@ -420,16 +441,17 @@
/* we can read directly to the stream */
bytesread = recvfrom (circuit->fd, STREAM_DATA (circuit->rcv_stream),
- circuit->interface->mtu, 0,
- (struct sockaddr *)&s_addr, &addr_len);
+ circuit->interface->mtu, 0,
+ (struct sockaddr *) &s_addr, &addr_len);
- if(s_addr.sll_pkttype == PACKET_OUTGOING) {
- /* Read the packet into discard buff */
- bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
- if (bytesread < 0)
- zlog_warn ("isis_recv_pdu_p2p(): read() failed");
- return ISIS_WARNING;
- }
+ if (s_addr.sll_pkttype == PACKET_OUTGOING)
+ {
+ /* Read the packet into discard buff */
+ bytesread = read (circuit->fd, discard_buff, sizeof (discard_buff));
+ if (bytesread < 0)
+ zlog_warn ("isis_recv_pdu_p2p(): read() failed");
+ return ISIS_WARNING;
+ }
circuit->rcv_stream->putp = bytesread;
circuit->rcv_stream->endp = bytesread;
@@ -437,32 +459,31 @@
/* If we don't have protocol type 0x00FE which is
* ISO over GRE we exit with pain :)
*/
- if (ntohs(s_addr.sll_protocol) != 0x00FE) {
- zlog_warn ("isis_recv_pdu_p2p(): protocol mismatch(): %X",
- ntohs(s_addr.sll_protocol));
- return ISIS_WARNING;
- }
-
- memcpy (ssnpa, &s_addr.sll_addr, s_addr.sll_halen);
-
+ if (ntohs (s_addr.sll_protocol) != 0x00FE)
+ {
+ zlog_warn ("isis_recv_pdu_p2p(): protocol mismatch(): %X",
+ ntohs (s_addr.sll_protocol));
+ return ISIS_WARNING;
+ }
+
+ memcpy (ssnpa, &s_addr.sll_addr, s_addr.sll_halen);
+
return ISIS_OK;
}
-
-
-int
+int
isis_send_pdu_bcast (struct isis_circuit *circuit, int level)
{
/* we need to do the LLC in here because of P2P circuits, which will
* not need it
*/
- int written = 1;
+ int written = 1;
struct sockaddr_ll sa;
stream_set_getp (circuit->snd_stream, 0);
memset (&sa, 0, sizeof (struct sockaddr_ll));
sa.sll_family = AF_PACKET;
- sa.sll_protocol = htons (stream_get_endp(circuit->snd_stream)+LLC_LEN);
+ sa.sll_protocol = htons (stream_get_endp (circuit->snd_stream) + LLC_LEN);
sa.sll_ifindex = circuit->interface->ifindex;
sa.sll_halen = ETH_ALEN;
if (level == 1)
@@ -477,29 +498,28 @@
sock_buff[2] = 0x03;
/* then we copy the data */
- memcpy (sock_buff + LLC_LEN, circuit->snd_stream->data,
- stream_get_endp (circuit->snd_stream));
+ memcpy (sock_buff + LLC_LEN, circuit->snd_stream->data,
+ stream_get_endp (circuit->snd_stream));
/* now we can send this */
written = sendto (circuit->fd, sock_buff,
- circuit->snd_stream->putp + LLC_LEN, 0,
- (struct sockaddr *)&sa, sizeof (struct sockaddr_ll));
-
+ circuit->snd_stream->putp + LLC_LEN, 0,
+ (struct sockaddr *) &sa, sizeof (struct sockaddr_ll));
return ISIS_OK;
}
-int
+int
isis_send_pdu_p2p (struct isis_circuit *circuit, int level)
{
- int written = 1;
+ int written = 1;
struct sockaddr_ll sa;
stream_set_getp (circuit->snd_stream, 0);
memset (&sa, 0, sizeof (struct sockaddr_ll));
sa.sll_family = AF_PACKET;
- sa.sll_protocol = htons (stream_get_endp(circuit->snd_stream)+LLC_LEN);
+ sa.sll_protocol = htons (stream_get_endp (circuit->snd_stream) + LLC_LEN);
sa.sll_ifindex = circuit->interface->ifindex;
sa.sll_halen = ETH_ALEN;
if (level == 1)
@@ -509,86 +529,87 @@
/* lets try correcting the protocol */
- sa.sll_protocol = htons(0x00FE);
- written = sendto (circuit->fd, circuit->snd_stream->data,
- circuit->snd_stream->putp, 0, (struct sockaddr *)&sa,
- sizeof (struct sockaddr_ll));
-
+ sa.sll_protocol = htons (0x00FE);
+ written = sendto (circuit->fd, circuit->snd_stream->data,
+ circuit->snd_stream->putp, 0, (struct sockaddr *) &sa,
+ sizeof (struct sockaddr_ll));
+
return ISIS_OK;
}
-
#else
int
-isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char *ssnpa)
+isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa)
{
int bytesread = 0, bytestoread, offset, one = 1;
struct bpf_hdr *bpf_hdr;
assert (circuit->fd > 0);
- if (ioctl (circuit->fd, FIONREAD, (caddr_t)&bytestoread) < 0 ) {
- zlog_warn ("ioctl() FIONREAD failed: %s", strerror (errno));
- }
+ if (ioctl (circuit->fd, FIONREAD, (caddr_t) & bytestoread) < 0)
+ {
+ zlog_warn ("ioctl() FIONREAD failed: %s", strerror (errno));
+ }
- if (bytestoread) {
- bytesread = read (circuit->fd, readbuff, readblen);
- }
- if (bytesread < 0) {
- zlog_warn ("isis_recv_pdu_bcast(): read() failed: %s", strerror (errno));
- return ISIS_WARNING;
- }
+ if (bytestoread)
+ {
+ bytesread = read (circuit->fd, readbuff, readblen);
+ }
+ if (bytesread < 0)
+ {
+ zlog_warn ("isis_recv_pdu_bcast(): read() failed: %s",
+ strerror (errno));
+ return ISIS_WARNING;
+ }
if (bytesread == 0)
return ISIS_WARNING;
- bpf_hdr = (struct bpf_hdr*)readbuff;
+ bpf_hdr = (struct bpf_hdr *) readbuff;
assert (bpf_hdr->bh_caplen == bpf_hdr->bh_datalen);
-
+
offset = bpf_hdr->bh_hdrlen + LLC_LEN + ETHER_HDR_LEN;
-
+
/* then we lose the BPF, LLC and ethernet headers */
- memcpy (STREAM_DATA (circuit->rcv_stream),
- readbuff + offset,
- bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
+ memcpy (STREAM_DATA (circuit->rcv_stream),
+ readbuff + offset, bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
circuit->rcv_stream->putp = bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN;
circuit->rcv_stream->endp = bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN;
circuit->rcv_stream->getp = 0;
- memcpy (ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
- ETHER_ADDR_LEN);
-
+ memcpy (ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
+ ETHER_ADDR_LEN);
+
if (ioctl (circuit->fd, BIOCFLUSH, &one) < 0)
zlog_warn ("Flushing failed: %s", strerror (errno));
-
+
return ISIS_OK;
}
int
-isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char *ssnpa)
+isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char * ssnpa)
{
int bytesread;
-
- bytesread = read (circuit->fd, STREAM_DATA(circuit->rcv_stream),
- circuit->interface->mtu);
- if (bytesread < 0) {
- zlog_warn ("isis_recv_pdu_p2p(): read () failed: %s", strerror (errno));
- return ISIS_WARNING;
- }
+ bytesread = read (circuit->fd, STREAM_DATA (circuit->rcv_stream),
+ circuit->interface->mtu);
+
+ if (bytesread < 0)
+ {
+ zlog_warn ("isis_recv_pdu_p2p(): read () failed: %s", strerror (errno));
+ return ISIS_WARNING;
+ }
circuit->rcv_stream->putp = bytesread;
circuit->rcv_stream->endp = bytesread;
-
+
return ISIS_OK;
}
-
-
-int
+int
isis_send_pdu_bcast (struct isis_circuit *circuit, int level)
{
struct ether_header *eth;
@@ -599,7 +620,7 @@
/*
* First the eth header
*/
- eth = (struct ether_header *)sock_buff;
+ eth = (struct ether_header *) sock_buff;
if (level == 1)
memcpy (eth->ether_dhost, ALL_L1_ISS, ETHER_ADDR_LEN);
else
@@ -610,36 +631,25 @@
/*
* Then the LLC
*/
- sock_buff[ETHER_HDR_LEN] = ISO_SAP;
- sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
- sock_buff[ETHER_HDR_LEN + 2] = 0x03;
+ sock_buff[ETHER_HDR_LEN] = ISO_SAP;
+ sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
+ sock_buff[ETHER_HDR_LEN + 2] = 0x03;
/* then we copy the data */
- memcpy (sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
- stream_get_endp (circuit->snd_stream));
+ memcpy (sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
+ stream_get_endp (circuit->snd_stream));
/* now we can send this */
written = write (circuit->fd, sock_buff,
- circuit->snd_stream->putp + LLC_LEN + ETHER_HDR_LEN);
-
+ circuit->snd_stream->putp + LLC_LEN + ETHER_HDR_LEN);
return ISIS_OK;
}
-int
+int
isis_send_pdu_p2p (struct isis_circuit *circuit, int level)
{
-
-
return ISIS_OK;
}
-
-
-
#endif /* GNU_LINUX */
-
-
-
-
-
diff --git a/isisd/isis_network.h b/isisd/isis_network.h
index 7633f9e..e1e10df 100644
--- a/isisd/isis_network.h
+++ b/isisd/isis_network.h
@@ -29,8 +29,8 @@
int isis_sock_init (struct isis_circuit *circuit);
-int isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char *ssnpa);
-int isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char *ssnpa);
+int isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa);
+int isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char * ssnpa);
int isis_send_pdu_bcast (struct isis_circuit *circuit, int level);
int isis_send_pdu_p2p (struct isis_circuit *circuit, int level);
diff --git a/isisd/isis_pdu.c b/isisd/isis_pdu.c
index f93025d..cae3461 100644
--- a/isisd/isis_pdu.c
+++ b/isisd/isis_pdu.c
@@ -58,15 +58,14 @@
extern struct isis *isis;
#define ISIS_MINIMUM_FIXED_HDR_LEN 15
-#define ISIS_MIN_PDU_LEN 13 /* partial seqnum pdu with id_len=2 */
+#define ISIS_MIN_PDU_LEN 13 /* partial seqnum pdu with id_len=2 */
#ifndef PNBBY
#define PNBBY 8
#endif /* PNBBY */
/* Utility mask array. */
-static u_char maskbit[] =
-{
+static u_char maskbit[] = {
0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
};
@@ -77,21 +76,23 @@
/*
* Compares two sets of area addresses
*/
-static int
+static int
area_match (struct list *left, struct list *right)
{
struct area_addr *addr1, *addr2;
struct listnode *node1, *node2;
- LIST_LOOP (left, addr1, node1) {
- LIST_LOOP (right, addr2, node2) {
- if (addr1->addr_len == addr2->addr_len &&
- !memcmp (addr1->area_addr, addr2->area_addr, (int)addr1->addr_len))
- return 1; /* match */
+ LIST_LOOP (left, addr1, node1)
+ {
+ LIST_LOOP (right, addr2, node2)
+ {
+ if (addr1->addr_len == addr2->addr_len &&
+ !memcmp (addr1->area_addr, addr2->area_addr, (int) addr1->addr_len))
+ return 1; /* match */
}
}
- return 0; /* mismatch */
+ return 0; /* mismatch */
}
/*
@@ -102,35 +103,38 @@
* 1 the IIH's IP is in the IS's subnetwork
*/
int
-ip_same_subnet (struct prefix_ipv4 *ip1, struct in_addr *ip2)
+ip_same_subnet (struct prefix_ipv4 *ip1, struct in_addr *ip2)
{
u_char *addr1, *addr2;
int shift, offset;
int len;
-
- addr1 = (u_char *) &ip1->prefix.s_addr;
- addr2 = (u_char *) &ip2->s_addr;
+
+ addr1 = (u_char *) & ip1->prefix.s_addr;
+ addr2 = (u_char *) & ip2->s_addr;
len = ip1->prefixlen;
shift = len % PNBBY;
offset = len / PNBBY;
- while (offset--) {
- if (addr1[offset] != addr2[offset]) {
- return 0;
+ while (offset--)
+ {
+ if (addr1[offset] != addr2[offset])
+ {
+ return 0;
+ }
}
- }
- if (shift) {
- if (maskbit[shift] & (addr1[offset] ^ addr2[offset])) {
- return 0;
+ if (shift)
+ {
+ if (maskbit[shift] & (addr1[offset] ^ addr2[offset]))
+ {
+ return 0;
+ }
}
- }
-
- return 1; /* match */
+
+ return 1; /* match */
}
-
/*
* Compares two set of ip addresses
* param left the local interface's ip addresses
@@ -138,20 +142,23 @@
* return 0 no match;
* 1 match;
*/
-static int
+static int
ip_match (struct list *left, struct list *right)
{
struct prefix_ipv4 *ip1;
struct in_addr *ip2;
struct listnode *node1, *node2;
- LIST_LOOP (left, ip1, node1) {
- LIST_LOOP (right, ip2, node2) {
- if (ip_same_subnet(ip1, ip2)) {
- return 1; /* match */
- }
+ LIST_LOOP (left, ip1, node1)
+ {
+ LIST_LOOP (right, ip2, node2)
+ {
+ if (ip_same_subnet (ip1, ip2))
+ {
+ return 1; /* match */
+ }
}
-
+
}
return 0;
}
@@ -162,103 +169,111 @@
static int
accept_level (int level, int circuit_t)
{
- int retval = ((circuit_t & level) == level); /* simple approach */
+ int retval = ((circuit_t & level) == level); /* simple approach */
return retval;
}
-int
+int
authentication_check (struct isis_passwd *one, struct isis_passwd *theother)
{
- if (one->type != theother->type) {
- zlog_warn ("Unsupported authentication type %d", theother->type );
- return 1; /* Auth fail (different authentication types)*/
- }
- switch (one->type) {
- case ISIS_PASSWD_TYPE_CLEARTXT:
- if (one->len != theother->len)
- return 1; /* Auth fail () - passwd len mismatch */
- return memcmp (one->passwd, theother->passwd, one->len);
- break;
- default:
- zlog_warn ("Unsupported authentication type");
- break;
- }
- return 0; /* Auth pass */
+ if (one->type != theother->type)
+ {
+ zlog_warn ("Unsupported authentication type %d", theother->type);
+ return 1; /* Auth fail (different authentication types) */
+ }
+ switch (one->type)
+ {
+ case ISIS_PASSWD_TYPE_CLEARTXT:
+ if (one->len != theother->len)
+ return 1; /* Auth fail () - passwd len mismatch */
+ return memcmp (one->passwd, theother->passwd, one->len);
+ break;
+ default:
+ zlog_warn ("Unsupported authentication type");
+ break;
+ }
+ return 0; /* Auth pass */
}
/*
* Processing helper functions
*/
void
-tlvs_to_adj_nlpids (struct tlvs *tlvs, struct isis_adjacency *adj)
+tlvs_to_adj_nlpids (struct tlvs *tlvs, struct isis_adjacency *adj)
{
int i;
struct nlpids *tlv_nlpids;
- if (tlvs->nlpids) {
+ if (tlvs->nlpids)
+ {
- tlv_nlpids = tlvs->nlpids;
+ tlv_nlpids = tlvs->nlpids;
- adj->nlpids.count = tlv_nlpids->count;
+ adj->nlpids.count = tlv_nlpids->count;
- for (i=0;i<tlv_nlpids->count;i++) {
- adj->nlpids.nlpids[i] = tlv_nlpids->nlpids[i];
+ for (i = 0; i < tlv_nlpids->count; i++)
+ {
+ adj->nlpids.nlpids[i] = tlv_nlpids->nlpids[i];
+ }
}
- }
}
-void
+void
del_ip_addr (void *val)
{
XFREE (MTYPE_ISIS_TMP, val);
}
void
-tlvs_to_adj_ipv4_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
+tlvs_to_adj_ipv4_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
{
struct listnode *node;
struct in_addr *ipv4_addr, *malloced;
- if (adj->ipv4_addrs) {
- adj->ipv4_addrs->del = del_ip_addr;
- list_delete (adj->ipv4_addrs);
- }
- adj->ipv4_addrs = list_new ();
- if (tlvs->ipv4_addrs) {
- LIST_LOOP (tlvs->ipv4_addrs, ipv4_addr, node) {
- malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in_addr));
- memcpy (malloced, ipv4_addr, sizeof (struct in_addr));
- listnode_add (adj->ipv4_addrs, malloced);
+ if (adj->ipv4_addrs)
+ {
+ adj->ipv4_addrs->del = del_ip_addr;
+ list_delete (adj->ipv4_addrs);
}
- }
+ adj->ipv4_addrs = list_new ();
+ if (tlvs->ipv4_addrs)
+ {
+ LIST_LOOP (tlvs->ipv4_addrs, ipv4_addr, node)
+ {
+ malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in_addr));
+ memcpy (malloced, ipv4_addr, sizeof (struct in_addr));
+ listnode_add (adj->ipv4_addrs, malloced);
+ }
+ }
}
#ifdef HAVE_IPV6
void
-tlvs_to_adj_ipv6_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
+tlvs_to_adj_ipv6_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
{
struct listnode *node;
struct in6_addr *ipv6_addr, *malloced;
- if (adj->ipv6_addrs) {
- adj->ipv6_addrs->del = del_ip_addr;
- list_delete (adj->ipv6_addrs);
- }
- adj->ipv6_addrs = list_new ();
- if (tlvs->ipv6_addrs) {
- LIST_LOOP (tlvs->ipv6_addrs, ipv6_addr, node) {
- malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in6_addr));
- memcpy (malloced, ipv6_addr, sizeof (struct in6_addr));
- listnode_add (adj->ipv6_addrs, malloced);
+ if (adj->ipv6_addrs)
+ {
+ adj->ipv6_addrs->del = del_ip_addr;
+ list_delete (adj->ipv6_addrs);
}
- }
+ adj->ipv6_addrs = list_new ();
+ if (tlvs->ipv6_addrs)
+ {
+ LIST_LOOP (tlvs->ipv6_addrs, ipv6_addr, node)
+ {
+ malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in6_addr));
+ memcpy (malloced, ipv6_addr, sizeof (struct in6_addr));
+ listnode_add (adj->ipv6_addrs, malloced);
+ }
+ }
}
#endif /* HAVE_IPV6 */
-
-
/*
* RECEIVE SIDE
*/
@@ -278,12 +293,12 @@
u_int32_t expected = 0, found;
struct tlvs tlvs;
- if ((stream_get_endp (circuit->rcv_stream) -
- stream_get_getp (circuit->rcv_stream)) <
- ISIS_P2PHELLO_HDRLEN) {
- zlog_warn ("Packet too short");
- return ISIS_WARNING;
- }
+ if ((stream_get_endp (circuit->rcv_stream) -
+ stream_get_getp (circuit->rcv_stream)) < ISIS_P2PHELLO_HDRLEN)
+ {
+ zlog_warn ("Packet too short");
+ return ISIS_WARNING;
+ }
/* 8.2.5.1 PDU acceptance tests */
@@ -301,41 +316,43 @@
/*
* Get the header
*/
- hdr = (struct isis_p2p_hello_hdr*) STREAM_PNT(circuit->rcv_stream);
+ hdr = (struct isis_p2p_hello_hdr *) STREAM_PNT (circuit->rcv_stream);
circuit->rcv_stream->getp += ISIS_P2PHELLO_HDRLEN;
/* hdr.circuit_t = stream_getc (stream);
- stream_get (hdr.source_id, stream, ISIS_SYS_ID_LEN);
- hdr.hold_time = stream_getw (stream);
- hdr.pdu_len = stream_getw (stream);
- hdr.local_id = stream_getc (stream); */
+ stream_get (hdr.source_id, stream, ISIS_SYS_ID_LEN);
+ hdr.hold_time = stream_getw (stream);
+ hdr.pdu_len = stream_getw (stream);
+ hdr.local_id = stream_getc (stream); */
/*
* My interpertation of the ISO, if no adj exists we will create one for
* the circuit
*/
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- zlog_info("ISIS-Adj (%s): Rcvd P2P IIH from (%s), cir type %s,"
- " cir id %02d, length %d",
- circuit->area->area_tag, circuit->interface->name,
- circuit_t2string(circuit->circuit_is_type),
- circuit->circuit_id,ntohs(hdr->pdu_len));
- }
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ zlog_info ("ISIS-Adj (%s): Rcvd P2P IIH from (%s), cir type %s,"
+ " cir id %02d, length %d",
+ circuit->area->area_tag, circuit->interface->name,
+ circuit_t2string (circuit->circuit_is_type),
+ circuit->circuit_id, ntohs (hdr->pdu_len));
+ }
adj = circuit->u.p2p.neighbor;
- if ( !adj ) {
- adj = isis_new_adj (hdr->source_id," ", 0, circuit);
- if (adj == NULL)
- return ISIS_ERROR;
- circuit->u.p2p.neighbor = adj;
- isis_adj_state_change(adj, ISIS_ADJ_INITIALIZING, NULL);
- adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
- }
+ if (!adj)
+ {
+ adj = isis_new_adj (hdr->source_id, " ", 0, circuit);
+ if (adj == NULL)
+ return ISIS_ERROR;
+ circuit->u.p2p.neighbor = adj;
+ isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
+ adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
+ }
/* 8.2.6 Monitoring point-to-point adjacencies */
adj->hold_time = ntohs (hdr->hold_time);
- adj->last_upd = time (NULL);
+ adj->last_upd = time (NULL);
/*
* Lets get the TLVS now
@@ -348,214 +365,273 @@
retval = parse_tlvs (circuit->area->area_tag,
STREAM_PNT (circuit->rcv_stream),
- ntohs (hdr->pdu_len) - ISIS_P2PHELLO_HDRLEN
- - ISIS_FIXED_HDR_LEN,
- &expected,
- &found,
- &tlvs);
+ ntohs (hdr->pdu_len) - ISIS_P2PHELLO_HDRLEN
+ - ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
- if (retval > ISIS_WARNING) {
- free_tlvs (&tlvs);
- return retval;
- };
+ if (retval > ISIS_WARNING)
+ {
+ free_tlvs (&tlvs);
+ return retval;
+ };
/* 8.2.5.1 c) Authentication */
- if (circuit->passwd.type) {
- if (!(found & TLVFLAG_AUTH_INFO) ||
- authentication_check (&circuit->passwd, &tlvs.auth_info)) {
- isis_event_auth_failure (circuit->area->area_tag,
- "P2P hello authentication failure",
- hdr->source_id);
- return ISIS_OK;
+ if (circuit->passwd.type)
+ {
+ if (!(found & TLVFLAG_AUTH_INFO) ||
+ authentication_check (&circuit->passwd, &tlvs.auth_info))
+ {
+ isis_event_auth_failure (circuit->area->area_tag,
+ "P2P hello authentication failure",
+ hdr->source_id);
+ return ISIS_OK;
+ }
}
- }
/* we do this now because the adj may not survive till the end... */
/* we need to copy addresses to the adj */
- tlvs_to_adj_ipv4_addrs (&tlvs,adj);
+ tlvs_to_adj_ipv4_addrs (&tlvs, adj);
#ifdef HAVE_IPV6
- tlvs_to_adj_ipv6_addrs (&tlvs,adj);
+ tlvs_to_adj_ipv6_addrs (&tlvs, adj);
#endif /* HAVE_IPV6 */
/* lets take care of the expiry */
- THREAD_TIMER_OFF(adj->t_expire);
- THREAD_TIMER_ON(master, adj->t_expire, isis_adj_expire, adj,
- (long)adj->hold_time);
+ THREAD_TIMER_OFF (adj->t_expire);
+ THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
+ (long) adj->hold_time);
/* 8.2.5.2 a) a match was detected */
- if (area_match (circuit->area->area_addrs, tlvs.area_addrs)) {
- /* 8.2.5.2 a) 2) If the system is L1 - table 5 */
- if (circuit->area->is_type == IS_LEVEL_1) {
- switch (hdr->circuit_t) {
- case IS_LEVEL_1:
- case IS_LEVEL_1_AND_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (4) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (5) adj usage level 1 */
- adj->adj_usage = ISIS_ADJ_LEVEL1;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- ; /* accept */
- }
- break;
- case IS_LEVEL_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (7) reject - wrong system type event */
- zlog_warn ("wrongSystemType");
- return ISIS_WARNING; /* Reject */
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- /* (6) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- }
- break;
- }
- }
+ if (area_match (circuit->area->area_addrs, tlvs.area_addrs))
+ {
+ /* 8.2.5.2 a) 2) If the system is L1 - table 5 */
+ if (circuit->area->is_type == IS_LEVEL_1)
+ {
+ switch (hdr->circuit_t)
+ {
+ case IS_LEVEL_1:
+ case IS_LEVEL_1_AND_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (4) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (5) adj usage level 1 */
+ adj->adj_usage = ISIS_ADJ_LEVEL1;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ ; /* accept */
+ }
+ break;
+ case IS_LEVEL_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (7) reject - wrong system type event */
+ zlog_warn ("wrongSystemType");
+ return ISIS_WARNING; /* Reject */
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ /* (6) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ break;
+ }
+ }
- /* 8.2.5.2 a) 3) If the system is L1L2 - table 6 */
- if (circuit->area->is_type == IS_LEVEL_1_AND_2) {
- switch (hdr->circuit_t) {
- case IS_LEVEL_1:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (6) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (7) adj usage level 1 */
- adj->adj_usage = ISIS_ADJ_LEVEL1;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- ; /* accept */
- } else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
- (adj->adj_usage == ISIS_ADJ_LEVEL2)) {
- /* (8) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- }
- break;
- case IS_LEVEL_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (6) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (9) adj usage level 2 */
- adj->adj_usage = ISIS_ADJ_LEVEL2;
- } else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
- (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)) {
- /* (8) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL2) {
- ; /* Accept */
- }
- break;
- case IS_LEVEL_1_AND_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (6) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (10) adj usage level 1 */
- adj->adj_usage = ISIS_ADJ_LEVEL1AND2;
- } else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
- (adj->adj_usage == ISIS_ADJ_LEVEL2)) {
- /* (8) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2) {
- ; /* Accept */
- }
- break;
- }
- }
+ /* 8.2.5.2 a) 3) If the system is L1L2 - table 6 */
+ if (circuit->area->is_type == IS_LEVEL_1_AND_2)
+ {
+ switch (hdr->circuit_t)
+ {
+ case IS_LEVEL_1:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (6) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (7) adj usage level 1 */
+ adj->adj_usage = ISIS_ADJ_LEVEL1;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ ; /* accept */
+ }
+ else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
+ (adj->adj_usage == ISIS_ADJ_LEVEL2))
+ {
+ /* (8) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ break;
+ case IS_LEVEL_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (6) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (9) adj usage level 2 */
+ adj->adj_usage = ISIS_ADJ_LEVEL2;
+ }
+ else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
+ (adj->adj_usage == ISIS_ADJ_LEVEL1AND2))
+ {
+ /* (8) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ ; /* Accept */
+ }
+ break;
+ case IS_LEVEL_1_AND_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (6) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (10) adj usage level 1 */
+ adj->adj_usage = ISIS_ADJ_LEVEL1AND2;
+ }
+ else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
+ (adj->adj_usage == ISIS_ADJ_LEVEL2))
+ {
+ /* (8) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
+ {
+ ; /* Accept */
+ }
+ break;
+ }
+ }
- /* 8.2.5.2 a) 4) If the system is L2 - table 7 */
- if (circuit->area->is_type == IS_LEVEL_2) {
- switch (hdr->circuit_t) {
- case IS_LEVEL_1:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (5) reject - wrong system type event */
- zlog_warn ("wrongSystemType");
- return ISIS_WARNING; /* Reject */
- } else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
- (adj->adj_usage == ISIS_ADJ_LEVEL2)) {
- /* (6) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- }
- break;
- case IS_LEVEL_1_AND_2:
- case IS_LEVEL_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (7) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (8) adj usage level 2 */
- adj->adj_usage = ISIS_ADJ_LEVEL2;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2) {
- /* (6) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL2) {
- ; /* Accept */
- }
- break;
- }
+ /* 8.2.5.2 a) 4) If the system is L2 - table 7 */
+ if (circuit->area->is_type == IS_LEVEL_2)
+ {
+ switch (hdr->circuit_t)
+ {
+ case IS_LEVEL_1:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (5) reject - wrong system type event */
+ zlog_warn ("wrongSystemType");
+ return ISIS_WARNING; /* Reject */
+ }
+ else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
+ (adj->adj_usage == ISIS_ADJ_LEVEL2))
+ {
+ /* (6) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ break;
+ case IS_LEVEL_1_AND_2:
+ case IS_LEVEL_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (7) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (8) adj usage level 2 */
+ adj->adj_usage = ISIS_ADJ_LEVEL2;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
+ {
+ /* (6) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ ; /* Accept */
+ }
+ break;
+ }
+ }
}
- }
/* 8.2.5.2 b) if no match was detected */
else
- {
- if (circuit->area->is_type == IS_LEVEL_1) {
- /* 8.2.5.2 b) 1) is_type L1 and adj is not up */
- if (adj->adj_state != ISIS_ADJ_UP) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
- /* 8.2.5.2 b) 2)is_type L1 and adj is up */
- } else {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Down - Area Mismatch");
- }
- }
- /* 8.2.5.2 b 3 If the system is L2 or L1L2 - table 8 */
- else
{
- switch (hdr->circuit_t) {
- case IS_LEVEL_1:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (6) reject - Area Mismatch event */
- zlog_warn ("AreaMismatch");
- return ISIS_WARNING; /* Reject */
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- /* (7) down - area mismatch */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
+ if (circuit->area->is_type == IS_LEVEL_1)
+ {
+ /* 8.2.5.2 b) 1) is_type L1 and adj is not up */
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
+ /* 8.2.5.2 b) 2)is_type L1 and adj is up */
+ }
+ else
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN,
+ "Down - Area Mismatch");
+ }
+ }
+ /* 8.2.5.2 b 3 If the system is L2 or L1L2 - table 8 */
+ else
+ {
+ switch (hdr->circuit_t)
+ {
+ case IS_LEVEL_1:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (6) reject - Area Mismatch event */
+ zlog_warn ("AreaMismatch");
+ return ISIS_WARNING; /* Reject */
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ /* (7) down - area mismatch */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
- } else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
- (adj->adj_usage == ISIS_ADJ_LEVEL2)) {
- /* (7) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- }
- break;
- case IS_LEVEL_1_AND_2:
- case IS_LEVEL_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* (8) adj state up */
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
- /* (9) adj usage level 2 */
- adj->adj_usage = ISIS_ADJ_LEVEL2;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- /* (7) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2) {
- if (hdr->circuit_t == IS_LEVEL_2) {
- /* (7) down - wrong system */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
- } else {
- /* (7) down - area mismatch */
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
- }
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL2) {
- ; /* Accept */
- }
- break;
- }
+ }
+ else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
+ (adj->adj_usage == ISIS_ADJ_LEVEL2))
+ {
+ /* (7) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ break;
+ case IS_LEVEL_1_AND_2:
+ case IS_LEVEL_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* (8) adj state up */
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
+ /* (9) adj usage level 2 */
+ adj->adj_usage = ISIS_ADJ_LEVEL2;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ /* (7) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
+ {
+ if (hdr->circuit_t == IS_LEVEL_2)
+ {
+ /* (7) down - wrong system */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN,
+ "Wrong System");
+ }
+ else
+ {
+ /* (7) down - area mismatch */
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN,
+ "Area Mismatch");
+ }
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ ; /* Accept */
+ }
+ break;
+ }
+ }
}
- }
/* 8.2.5.2 c) if the action was up - comparing circuit IDs */
/* FIXME - Missing parts */
-
/* some of my own understanding of the ISO, why the heck does
* it not say what should I change the system_type to...
*/
- switch (adj->adj_usage) {
+ switch (adj->adj_usage)
+ {
case ISIS_ADJ_LEVEL1:
adj->sys_type = ISIS_SYSTYPE_L1_IS;
break;
@@ -568,7 +644,7 @@
case ISIS_ADJ_NONE:
adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
break;
- }
+ }
adj->circuit_t = hdr->circuit_t;
adj->level = hdr->circuit_t;
@@ -578,12 +654,11 @@
return retval;
}
-
/*
* Process IS-IS LAN Level 1/2 Hello PDU
*/
-static int
-process_lan_hello (int level, struct isis_circuit *circuit, u_char *ssnpa)
+static int
+process_lan_hello (int level, struct isis_circuit *circuit, u_char * ssnpa)
{
int retval = ISIS_OK;
struct isis_lan_hello_hdr hdr;
@@ -593,35 +668,41 @@
u_char *snpa;
struct listnode *node;
- if ((stream_get_endp (circuit->rcv_stream) -
- stream_get_getp (circuit->rcv_stream)) < ISIS_LANHELLO_HDRLEN) {
- zlog_warn ("Packet too short");
- return ISIS_WARNING;
- }
-
- if (circuit->ext_domain) {
- zlog_info ("level %d LAN Hello received over circuit with "
- "externalDomain = true", level);
- return ISIS_WARNING;
- }
-
- if (!accept_level (level, circuit->circuit_is_type)) {
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- zlog_info ("ISIS-Adj (%s): Interface level mismatch, %s",
- circuit->area->area_tag, circuit->interface->name);
+ if ((stream_get_endp (circuit->rcv_stream) -
+ stream_get_getp (circuit->rcv_stream)) < ISIS_LANHELLO_HDRLEN)
+ {
+ zlog_warn ("Packet too short");
+ return ISIS_WARNING;
}
- return ISIS_WARNING;
- }
+
+ if (circuit->ext_domain)
+ {
+ zlog_info ("level %d LAN Hello received over circuit with "
+ "externalDomain = true", level);
+ return ISIS_WARNING;
+ }
+
+ if (!accept_level (level, circuit->circuit_is_type))
+ {
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ zlog_info ("ISIS-Adj (%s): Interface level mismatch, %s",
+ circuit->area->area_tag, circuit->interface->name);
+ }
+ return ISIS_WARNING;
+ }
#if 0
/* Cisco's debug message compatability */
- if (!accept_level (level, circuit->area->is_type)) {
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- zlog_info ("ISIS-Adj (%s): is type mismatch",
- circuit->area->area_tag);
+ if (!accept_level (level, circuit->area->is_type))
+ {
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ zlog_info ("ISIS-Adj (%s): is type mismatch",
+ circuit->area->area_tag);
+ }
+ return ISIS_WARNING;
}
- return ISIS_WARNING;
- }
#endif
/*
* Fill the header
@@ -629,16 +710,17 @@
hdr.circuit_t = stream_getc (circuit->rcv_stream);
stream_get (hdr.source_id, circuit->rcv_stream, ISIS_SYS_ID_LEN);
hdr.hold_time = stream_getw (circuit->rcv_stream);
- hdr.pdu_len = stream_getw (circuit->rcv_stream);
- hdr.prio = stream_getc (circuit->rcv_stream);
+ hdr.pdu_len = stream_getw (circuit->rcv_stream);
+ hdr.prio = stream_getc (circuit->rcv_stream);
stream_get (hdr.lan_id, circuit->rcv_stream, ISIS_SYS_ID_LEN + 1);
if (hdr.circuit_t != IS_LEVEL_1 && hdr.circuit_t != IS_LEVEL_2 &&
- hdr.circuit_t != IS_LEVEL_1_AND_2 ) {
- zlog_warn ("Level %d LAN Hello with Circuit Type %d", level,
- hdr.circuit_t);
- return ISIS_ERROR;
- }
+ hdr.circuit_t != IS_LEVEL_1_AND_2)
+ {
+ zlog_warn ("Level %d LAN Hello with Circuit Type %d", level,
+ hdr.circuit_t);
+ return ISIS_ERROR;
+ }
/*
* Then get the tlvs
*/
@@ -650,171 +732,194 @@
expected |= TLVFLAG_IPV6_ADDR;
retval = parse_tlvs (circuit->area->area_tag,
- STREAM_PNT (circuit->rcv_stream),
- hdr.pdu_len - ISIS_LANHELLO_HDRLEN - ISIS_FIXED_HDR_LEN,
- &expected,
- &found,
- &tlvs);
+ STREAM_PNT (circuit->rcv_stream),
+ hdr.pdu_len - ISIS_LANHELLO_HDRLEN -
+ ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
- if (retval > ISIS_WARNING) {
- zlog_warn ("parse_tlvs() failed");
- goto out;
- }
+ if (retval > ISIS_WARNING)
+ {
+ zlog_warn ("parse_tlvs() failed");
+ goto out;
+ }
- if (!(found & TLVFLAG_AREA_ADDRS)) {
- zlog_warn ("No Area addresses TLV in Level %d LAN IS to IS hello", level);
- retval = ISIS_WARNING;
- goto out;
- }
-
- if (circuit->passwd.type) {
- if (!(found & TLVFLAG_AUTH_INFO) ||
- authentication_check (&circuit->passwd, &tlvs.auth_info)) {
- isis_event_auth_failure (circuit->area->area_tag,
- "LAN hello authentication failure",
- hdr.source_id);
+ if (!(found & TLVFLAG_AREA_ADDRS))
+ {
+ zlog_warn ("No Area addresses TLV in Level %d LAN IS to IS hello",
+ level);
retval = ISIS_WARNING;
goto out;
}
- }
+
+ if (circuit->passwd.type)
+ {
+ if (!(found & TLVFLAG_AUTH_INFO) ||
+ authentication_check (&circuit->passwd, &tlvs.auth_info))
+ {
+ isis_event_auth_failure (circuit->area->area_tag,
+ "LAN hello authentication failure",
+ hdr.source_id);
+ retval = ISIS_WARNING;
+ goto out;
+ }
+ }
/*
* Accept the level 1 adjacency only if a match between local and
* remote area addresses is found
*/
- if (level == 1 && !area_match (circuit->area->area_addrs, tlvs.area_addrs)) {
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- zlog_info ("ISIS-Adj (%s): Area mismatch, level %d IIH on %s",
- circuit->area->area_tag, level,circuit->interface->name);
+ if (level == 1 && !area_match (circuit->area->area_addrs, tlvs.area_addrs))
+ {
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ zlog_info ("ISIS-Adj (%s): Area mismatch, level %d IIH on %s",
+ circuit->area->area_tag, level,
+ circuit->interface->name);
+ }
+ retval = ISIS_OK;
+ goto out;
}
- retval = ISIS_OK;
- goto out;
- }
/*
* it's own IIH PDU - discard silently
- */
- if (!memcmp (circuit->u.bc.snpa, ssnpa, ETH_ALEN)) {
- zlog_info ("ISIS-Adj (%s): it's own IIH PDU - discarded",
- circuit->area->area_tag);
+ */
+ if (!memcmp (circuit->u.bc.snpa, ssnpa, ETH_ALEN))
+ {
+ zlog_info ("ISIS-Adj (%s): it's own IIH PDU - discarded",
+ circuit->area->area_tag);
- retval = ISIS_OK;
- goto out;
- }
+ retval = ISIS_OK;
+ goto out;
+ }
/*
* check if it's own interface ip match iih ip addrs
*/
- if (!(found & TLVFLAG_IPV4_ADDR) || !ip_match(circuit->ip_addrs, tlvs.ipv4_addrs)) {
- zlog_info("ISIS-Adj: No usable IP interface addresses in LAN IIH from %s\n",
- circuit->interface->name);
- retval = ISIS_WARNING;
- goto out;
- }
-
+ if (!(found & TLVFLAG_IPV4_ADDR)
+ || !ip_match (circuit->ip_addrs, tlvs.ipv4_addrs))
+ {
+ zlog_info
+ ("ISIS-Adj: No usable IP interface addresses in LAN IIH from %s\n",
+ circuit->interface->name);
+ retval = ISIS_WARNING;
+ goto out;
+ }
adj = isis_adj_lookup (hdr.source_id, circuit->u.bc.adjdb[level - 1]);
- if (!adj) {
- /*
- * Do as in 8.4.2.5
- */
- adj = isis_new_adj (hdr.source_id, ssnpa, level, circuit);
- if (adj == NULL)
- retval = ISIS_ERROR;
+ if (!adj)
+ {
+ /*
+ * Do as in 8.4.2.5
+ */
+ adj = isis_new_adj (hdr.source_id, ssnpa, level, circuit);
+ if (adj == NULL)
+ retval = ISIS_ERROR;
goto out;
- adj->level = level;
- isis_adj_state_change(adj, ISIS_ADJ_INITIALIZING, NULL);
+ adj->level = level;
+ isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
- if (level == 1) {
- adj->sys_type = ISIS_SYSTYPE_L1_IS;
- } else {
- adj->sys_type = ISIS_SYSTYPE_L2_IS;
+ if (level == 1)
+ {
+ adj->sys_type = ISIS_SYSTYPE_L1_IS;
+ }
+ else
+ {
+ adj->sys_type = ISIS_SYSTYPE_L2_IS;
+ }
+ list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
+ isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
+ circuit->u.bc.lan_neighs[level - 1]);
}
- list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
- isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
- circuit->u.bc.lan_neighs[level - 1]);
- }
- switch (level) {
- case 1 :
- if (memcmp(circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1)) {
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
- memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
+ switch (level)
+ {
+ case 1:
+ if (memcmp (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
+ {
+ thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id,
+ ISIS_SYS_ID_LEN + 1);
+ }
+ break;
+ case 2:
+ if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
+ {
+ thread_add_event (master, isis_event_dis_status_change, circuit, 0);
+ memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id,
+ ISIS_SYS_ID_LEN + 1);
+ }
+ break;
}
- break;
- case 2 :
- if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1)) {
- thread_add_event (master, isis_event_dis_status_change, circuit, 0);
- memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
- }
- break;
- }
#if 0
- /* Old solution: believe the lan-header always
- */
- if (level == 1) {
- memcpy(circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
- } else if (level == 2) {
- memcpy(circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
- }
+ /* Old solution: believe the lan-header always
+ */
+ if (level == 1)
+ {
+ memcpy (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
+ }
+ else if (level == 2)
+ {
+ memcpy (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
+ }
#endif
adj->hold_time = hdr.hold_time;
- adj->last_upd = time (NULL);
- adj->prio[level-1] = hdr.prio;
+ adj->last_upd = time (NULL);
+ adj->prio[level - 1] = hdr.prio;
memcpy (adj->lanid, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
/* which protocol are spoken ??? */
- if (found & TLVFLAG_NLPID)
+ if (found & TLVFLAG_NLPID)
tlvs_to_adj_nlpids (&tlvs, adj);
/* we need to copy addresses to the adj */
- if (found & TLVFLAG_IPV4_ADDR)
+ if (found & TLVFLAG_IPV4_ADDR)
tlvs_to_adj_ipv4_addrs (&tlvs, adj);
#ifdef HAVE_IPV6
- if (found & TLVFLAG_IPV6_ADDR)
+ if (found & TLVFLAG_IPV6_ADDR)
tlvs_to_adj_ipv6_addrs (&tlvs, adj);
#endif /* HAVE_IPV6 */
adj->circuit_t = hdr.circuit_t;
/* lets take care of the expiry */
- THREAD_TIMER_OFF(adj->t_expire);
- THREAD_TIMER_ON(master, adj->t_expire, isis_adj_expire, adj,
- (long)adj->hold_time);
+ THREAD_TIMER_OFF (adj->t_expire);
+ THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
+ (long) adj->hold_time);
/*
* If the snpa for this circuit is found from LAN Neighbours TLV
* we have two-way communication -> adjacency can be put to state "up"
*/
- if (found & TLVFLAG_LAN_NEIGHS) {
- if (adj->adj_state != ISIS_ADJ_UP) {
- LIST_LOOP (tlvs.lan_neighs, snpa, node)
- if (!memcmp (snpa, circuit->u.bc.snpa, ETH_ALEN)) {
- isis_adj_state_change (adj, ISIS_ADJ_UP,
- "own SNPA found in LAN Neighbours TLV");
- }
+ if (found & TLVFLAG_LAN_NEIGHS)
+ {
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ LIST_LOOP (tlvs.lan_neighs, snpa, node)
+ if (!memcmp (snpa, circuit->u.bc.snpa, ETH_ALEN))
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_UP,
+ "own SNPA found in LAN Neighbours TLV");
+ }
+ }
}
- }
- out:
+out:
/* DEBUG_ADJ_PACKETS */
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- /* FIXME: is this place right? fix missing info */
- zlog_info ("ISIS-Adj (%s): Rcvd L%d LAN IIH from %s on %s, cirType %s, "
- "cirID %u, length %ld",
- circuit->area->area_tag,
- level,snpa_print(ssnpa), circuit->interface->name,
- circuit_t2string(circuit->circuit_is_type),
- circuit->circuit_id,
- stream_get_endp (circuit->rcv_stream));
- }
-
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ /* FIXME: is this place right? fix missing info */
+ zlog_info ("ISIS-Adj (%s): Rcvd L%d LAN IIH from %s on %s, cirType %s, "
+ "cirID %u, length %ld",
+ circuit->area->area_tag,
+ level, snpa_print (ssnpa), circuit->interface->name,
+ circuit_t2string (circuit->circuit_is_type),
+ circuit->circuit_id, stream_get_endp (circuit->rcv_stream));
+ }
free_tlvs (&tlvs);
@@ -825,9 +930,9 @@
* Process Level 1/2 Link State
* ISO - 10589
* Section 7.3.15.1 - Action on receipt of a link state PDU
- */
-static int
-process_lsp (int level, struct isis_circuit *circuit, u_char *ssnpa)
+ */
+static int
+process_lsp (int level, struct isis_circuit *circuit, u_char * ssnpa)
{
struct isis_link_state_hdr *hdr;
struct isis_adjacency *adj = NULL;
@@ -837,64 +942,65 @@
struct isis_passwd *passwd;
/* Sanity check - FIXME: move to correct place */
- if ((stream_get_endp (circuit->rcv_stream) -
- stream_get_getp (circuit->rcv_stream)) < ISIS_LSP_HDR_LEN ) {
- zlog_warn ("Packet too short");
- return ISIS_WARNING;
- }
+ if ((stream_get_endp (circuit->rcv_stream) -
+ stream_get_getp (circuit->rcv_stream)) < ISIS_LSP_HDR_LEN)
+ {
+ zlog_warn ("Packet too short");
+ return ISIS_WARNING;
+ }
/* Reference the header */
- hdr = (struct isis_link_state_hdr*)STREAM_PNT (circuit->rcv_stream);
+ hdr = (struct isis_link_state_hdr *) STREAM_PNT (circuit->rcv_stream);
- if (isis->debugs & DEBUG_UPDATE_PACKETS) {
- zlog_info ("ISIS-Upd (%s): Rcvd L%d LSP %s, seq 0x%08x, cksum 0x%04x, "
- "lifetime %us, len %lu, on %s",
- circuit->area->area_tag,
- level,
- rawlspid_print(hdr->lsp_id),
- ntohl(hdr->seq_num),
- ntohs(hdr->checksum),
- ntohs(hdr->rem_lifetime),
- circuit->rcv_stream->endp,
- circuit->interface->name);
- }
+ if (isis->debugs & DEBUG_UPDATE_PACKETS)
+ {
+ zlog_info ("ISIS-Upd (%s): Rcvd L%d LSP %s, seq 0x%08x, cksum 0x%04x, "
+ "lifetime %us, len %lu, on %s",
+ circuit->area->area_tag,
+ level,
+ rawlspid_print (hdr->lsp_id),
+ ntohl (hdr->seq_num),
+ ntohs (hdr->checksum),
+ ntohs (hdr->rem_lifetime),
+ circuit->rcv_stream->endp, circuit->interface->name);
+ }
assert (ntohs (hdr->pdu_len) > ISIS_LSP_HDR_LEN);
/* Checksum sanity check - FIXME: move to correct place */
/* 12 = sysid+pdu+remtime */
- if (iso_csum_verify (STREAM_PNT (circuit->rcv_stream) + 4,
- ntohs (hdr->pdu_len) - 12, &hdr->checksum)) {
- zlog_info ("ISIS-Upd (%s): LSP %s invalid LSP checksum 0x%04x",
- circuit->area->area_tag,
- rawlspid_print (hdr->lsp_id),
- ntohs(hdr->checksum));
+ if (iso_csum_verify (STREAM_PNT (circuit->rcv_stream) + 4,
+ ntohs (hdr->pdu_len) - 12, &hdr->checksum))
+ {
+ zlog_info ("ISIS-Upd (%s): LSP %s invalid LSP checksum 0x%04x",
+ circuit->area->area_tag,
+ rawlspid_print (hdr->lsp_id), ntohs (hdr->checksum));
- return ISIS_WARNING;
- }
+ return ISIS_WARNING;
+ }
/* 7.3.15.1 a) 1 - external domain circuit will discard lsps */
- if (circuit->ext_domain) {
- zlog_info ("ISIS-Upd (%s): LSP %s received at level %d over circuit with "
- "externalDomain = true",
- circuit->area->area_tag,
- rawlspid_print (hdr->lsp_id),
- level);
+ if (circuit->ext_domain)
+ {
+ zlog_info
+ ("ISIS-Upd (%s): LSP %s received at level %d over circuit with "
+ "externalDomain = true", circuit->area->area_tag,
+ rawlspid_print (hdr->lsp_id), level);
- return ISIS_WARNING;
- }
+ return ISIS_WARNING;
+ }
/* 7.3.15.1 a) 2,3 - manualL2OnlyMode not implemented */
- if (!accept_level (level, circuit->circuit_is_type)) {
- zlog_info ("ISIS-Upd (%s): LSP %s received at level %d over circuit of"
- " type %s",
- circuit->area->area_tag,
- rawlspid_print(hdr->lsp_id),
- level,
- circuit_t2string (circuit->circuit_is_type));
+ if (!accept_level (level, circuit->circuit_is_type))
+ {
+ zlog_info ("ISIS-Upd (%s): LSP %s received at level %d over circuit of"
+ " type %s",
+ circuit->area->area_tag,
+ rawlspid_print (hdr->lsp_id),
+ level, circuit_t2string (circuit->circuit_is_type));
- return ISIS_WARNING;
- }
+ return ISIS_WARNING;
+ }
/* 7.3.15.1 a) 4 - need to make sure IDLength matches */
@@ -903,221 +1009,254 @@
/* 7.3.15.1 a) 7 - password check */
(level == ISIS_LEVEL1) ? (passwd = &circuit->area->area_passwd) :
(passwd = &circuit->area->domain_passwd);
- if (passwd->type) {
- if (isis_lsp_authinfo_check (circuit->rcv_stream, circuit->area,
- ntohs (hdr->pdu_len), passwd)) {
- isis_event_auth_failure (circuit->area->area_tag,
- "LSP authentication failure",
- hdr->lsp_id);
- return ISIS_WARNING;
+ if (passwd->type)
+ {
+ if (isis_lsp_authinfo_check (circuit->rcv_stream, circuit->area,
+ ntohs (hdr->pdu_len), passwd))
+ {
+ isis_event_auth_failure (circuit->area->area_tag,
+ "LSP authentication failure", hdr->lsp_id);
+ return ISIS_WARNING;
+ }
}
- }
/* Find the LSP in our database and compare it to this Link State header */
lsp = lsp_search (hdr->lsp_id, circuit->area->lspdb[level - 1]);
if (lsp)
- comp = lsp_compare (circuit->area->area_tag, lsp, hdr->seq_num,
- hdr->checksum, hdr->rem_lifetime);
- if (lsp && (lsp->own_lsp
+ comp = lsp_compare (circuit->area->area_tag, lsp, hdr->seq_num,
+ hdr->checksum, hdr->rem_lifetime);
+ if (lsp && (lsp->own_lsp
#ifdef TOPOLOGY_GENERATE
- || lsp->from_topology
+ || lsp->from_topology
#endif /* TOPOLOGY_GENERATE */
- ))
+ ))
goto dontcheckadj;
/* 7.3.15.1 a) 6 - Must check that we have an adjacency of the same level */
/* for broadcast circuits, snpa should be compared */
/* FIXME : Point To Point */
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- adj = isis_adj_lookup_snpa (ssnpa, circuit->u.bc.adjdb[level - 1]);
- if (!adj) {
- zlog_info ("(%s): DS ======= LSP %s, seq 0x%08x, cksum 0x%04x, "
- "lifetime %us on %s",
- circuit->area->area_tag,
- rawlspid_print (hdr->lsp_id),
- ntohl (hdr->seq_num),
- ntohs (hdr->checksum),
- ntohs (hdr->rem_lifetime),
- circuit->interface->name);
- return ISIS_WARNING; /* Silently discard */
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ adj = isis_adj_lookup_snpa (ssnpa, circuit->u.bc.adjdb[level - 1]);
+ if (!adj)
+ {
+ zlog_info ("(%s): DS ======= LSP %s, seq 0x%08x, cksum 0x%04x, "
+ "lifetime %us on %s",
+ circuit->area->area_tag,
+ rawlspid_print (hdr->lsp_id),
+ ntohl (hdr->seq_num),
+ ntohs (hdr->checksum),
+ ntohs (hdr->rem_lifetime), circuit->interface->name);
+ return ISIS_WARNING; /* Silently discard */
+ }
}
- }
/* for non broadcast, we just need to find same level adj */
- else {
- /* If no adj, or no sharing of level */
- if (!circuit->u.p2p.neighbor) {
- return ISIS_OK; /* Silently discard */
- } else {
- if (((level == 1) &&
- (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL2)) ||
- ((level == 2) &&
- (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL1)))
- return ISIS_WARNING; /* Silently discard */
+ else
+ {
+ /* If no adj, or no sharing of level */
+ if (!circuit->u.p2p.neighbor)
+ {
+ return ISIS_OK; /* Silently discard */
+ }
+ else
+ {
+ if (((level == 1) &&
+ (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL2)) ||
+ ((level == 2) &&
+ (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL1)))
+ return ISIS_WARNING; /* Silently discard */
+ }
}
- }
- dontcheckadj:
+dontcheckadj:
/* 7.3.15.1 a) 7 - Passwords for level 1 - not implemented */
/* 7.3.15.1 a) 8 - Passwords for level 2 - not implemented */
- /* 7.3.15.1 a) 9 - OriginatingLSPBufferSize - not implemented FIXME: do it*/
+ /* 7.3.15.1 a) 9 - OriginatingLSPBufferSize - not implemented FIXME: do it */
+ /* 7.3.15.1 b) - If the remaining life time is 0, we perform 7.3.16.4 */
+ if (hdr->rem_lifetime == 0)
+ {
+ if (!lsp)
+ {
+ /* 7.3.16.4 a) 1) No LSP in db -> send an ack, but don't save */
+ /* only needed on explicit update, eg - p2p */
+ if (circuit->circ_type == CIRCUIT_T_P2P)
+ ack_lsp (hdr, circuit, level);
+ return retval; /* FIXME: do we need a purge? */
+ }
+ else
+ {
+ if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
+ {
+ /* LSP by some other system -> do 7.3.16.4 b) */
+ /* 7.3.16.4 b) 1) */
+ if (comp == LSP_NEWER)
+ {
+ lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area);
+ /* ii */
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ /* iii */
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ /* v */
+ ISIS_FLAGS_CLEAR_ALL (lsp->SSNflags); /* FIXME: OTHER than c */
+ /* iv */
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
- /* 7.3.15.1 b) - If the remaining life time is 0, we perform 7.3.16.4*/
- if (hdr->rem_lifetime == 0) {
- if (!lsp) {
- /* 7.3.16.4 a) 1) No LSP in db -> send an ack, but don't save */
- /* only needed on explicit update, eg - p2p */
- if (circuit->circ_type == CIRCUIT_T_P2P)
- ack_lsp (hdr, circuit, level);
- return retval; /* FIXME: do we need a purge? */
- } else {
- if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN )) {
- /* LSP by some other system -> do 7.3.16.4 b) */
- /* 7.3.16.4 b) 1) */
- if (comp == LSP_NEWER) {
- lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area);
- /* ii */
- ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- /* iii */
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
- /* v */
- ISIS_FLAGS_CLEAR_ALL(lsp->SSNflags); /* FIXME: OTHER than c */
- /* iv */
- if (circuit->circ_type != CIRCUIT_T_BROADCAST)
- ISIS_SET_FLAG(lsp->SSNflags, circuit);
-
- } /* 7.3.16.4 b) 2) */
- else if (comp == LSP_EQUAL) {
- /* i */
- ISIS_CLEAR_FLAG(lsp->SRMflags, circuit);
- /* ii*/
- if (circuit->circ_type != CIRCUIT_T_BROADCAST)
- ISIS_SET_FLAG(lsp->SSNflags, circuit);
- } /* 7.3.16.4 b) 3) */
- else {
- ISIS_SET_FLAG(lsp->SRMflags, circuit);
- ISIS_CLEAR_FLAG(lsp->SSNflags, circuit);
- }
- } else {
- /* our own LSP -> 7.3.16.4 c) */
- if (LSP_PSEUDO_ID(lsp->lsp_header->lsp_id) != circuit->circuit_id ||
- (LSP_PSEUDO_ID(lsp->lsp_header->lsp_id) == circuit->circuit_id &&
- circuit->u.bc.is_dr[level - 1] == 1) ) {
- lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
- zlog_info ("LSP LEN: %d", ntohs (lsp->lsp_header->pdu_len));
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs (lsp->lsp_header->pdu_len) - 12, 12);
- ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- zlog_info ("ISIS-Upd (%s): (1) re-originating LSP %s new seq 0x%08x",
- circuit->area->area_tag,
- rawlspid_print (hdr->lsp_id),
- ntohl (lsp->lsp_header->seq_num));
- lsp->lsp_header->rem_lifetime = htons (isis_jitter
- (circuit->area->
- max_lsp_lifetime[level-1],
- MAX_AGE_JITTER));
-
- } else {
- /* Got purge for own pseudo-lsp, and we are not DR */
- lsp_purge_dr (lsp->lsp_header->lsp_id, circuit, level);
- }
- }
+ } /* 7.3.16.4 b) 2) */
+ else if (comp == LSP_EQUAL)
+ {
+ /* i */
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ /* ii */
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
+ } /* 7.3.16.4 b) 3) */
+ else
+ {
+ ISIS_SET_FLAG (lsp->SRMflags, circuit);
+ ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
+ }
+ }
+ else
+ {
+ /* our own LSP -> 7.3.16.4 c) */
+ if (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) !=
+ circuit->circuit_id
+ || (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) ==
+ circuit->circuit_id
+ && circuit->u.bc.is_dr[level - 1] == 1))
+ {
+ lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
+ zlog_info ("LSP LEN: %d", ntohs (lsp->lsp_header->pdu_len));
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ zlog_info
+ ("ISIS-Upd (%s): (1) re-originating LSP %s new seq 0x%08x",
+ circuit->area->area_tag, rawlspid_print (hdr->lsp_id),
+ ntohl (lsp->lsp_header->seq_num));
+ lsp->lsp_header->rem_lifetime =
+ htons (isis_jitter
+ (circuit->area->max_lsp_lifetime[level - 1],
+ MAX_AGE_JITTER));
+ }
+ else
+ {
+ /* Got purge for own pseudo-lsp, and we are not DR */
+ lsp_purge_dr (lsp->lsp_header->lsp_id, circuit, level);
+ }
+ }
+ }
+ return retval;
}
- return retval;
- }
/* 7.3.15.1 c) - If this is our own lsp and we don't have it initiate a
* purge */
- if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN ) == 0) {
- if (!lsp) {
- /* 7.3.16.4: initiate a purge */
- lsp_purge_non_exist (hdr, circuit->area);
- return ISIS_OK;
+ if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN) == 0)
+ {
+ if (!lsp)
+ {
+ /* 7.3.16.4: initiate a purge */
+ lsp_purge_non_exist (hdr, circuit->area);
+ return ISIS_OK;
+ }
+ /* 7.3.15.1 d) - If this is our own lsp and we have it */
+
+ /* In 7.3.16.1, If an Intermediate system R somewhere in the domain
+ * has information that the current sequence number for source S is
+ * "greater" than that held by S, ... */
+
+ else if (ntohl (hdr->seq_num) > ntohl (lsp->lsp_header->seq_num))
+ {
+ /* 7.3.16.1 */
+ lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
+
+ iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
+ ntohs (lsp->lsp_header->pdu_len) - 12, 12);
+
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ zlog_info
+ ("ISIS-Upd (%s): (2) re-originating LSP %s new seq 0x%08x",
+ circuit->area->area_tag, rawlspid_print (hdr->lsp_id),
+ ntohl (lsp->lsp_header->seq_num));
+ lsp->lsp_header->rem_lifetime =
+ htons (isis_jitter
+ (circuit->area->max_lsp_lifetime[level - 1],
+ MAX_AGE_JITTER));
+ }
}
- /* 7.3.15.1 d) - If this is our own lsp and we have it */
+ else
+ {
+ /* 7.3.15.1 e) - This lsp originated on another system */
- /* In 7.3.16.1, If an Intermediate system R somewhere in the domain
- * has information that the current sequence number for source S is
- * "greater" than that held by S, ... */
-
- else if (ntohl (hdr->seq_num) > ntohl (lsp->lsp_header->seq_num)) {
- /* 7.3.16.1 */
- lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
-
- iso_csum_create (STREAM_DATA (lsp->pdu) + 12,
- ntohs(lsp->lsp_header->pdu_len) - 12, 12);
-
- ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- zlog_info ("ISIS-Upd (%s): (2) re-originating LSP %s new seq 0x%08x",
- circuit->area->area_tag,
- rawlspid_print (hdr->lsp_id),
- ntohl (lsp->lsp_header->seq_num));
- lsp->lsp_header->rem_lifetime = htons (isis_jitter
- (circuit->
- area->max_lsp_lifetime[level-1],
- MAX_AGE_JITTER));
-
- }
- } else {
- /* 7.3.15.1 e) - This lsp originated on another system */
-
- /* 7.3.15.1 e) 1) LSP newer than the one in db or no LSP in db */
- if ((!lsp || comp == LSP_NEWER)){
- /* i */
- if (lsp) {
+ /* 7.3.15.1 e) 1) LSP newer than the one in db or no LSP in db */
+ if ((!lsp || comp == LSP_NEWER))
+ {
+ /* i */
+ if (lsp)
+ {
#ifdef EXTREME_DEBUG
- zlog_info ("level %d number is - %ld", level,
- circuit->area->lspdb[level-1]->dict_nodecount);
+ zlog_info ("level %d number is - %ld", level,
+ circuit->area->lspdb[level - 1]->dict_nodecount);
#endif /* EXTREME DEBUG */
- lsp_search_and_destroy (hdr->lsp_id, circuit->area->lspdb[level-1]);
- /* exists, so we overwrite */
+ lsp_search_and_destroy (hdr->lsp_id,
+ circuit->area->lspdb[level - 1]);
+ /* exists, so we overwrite */
#ifdef EXTREME_DEBUG
- zlog_info ("level %d number is - %ld",level,
- circuit->area->lspdb[level-1]->dict_nodecount);
+ zlog_info ("level %d number is - %ld", level,
+ circuit->area->lspdb[level - 1]->dict_nodecount);
#endif /* EXTREME DEBUG */
- }
- /*
- * If this lsp is a frag, need to see if we have zero lsp present
- */
- if (LSP_FRAGMENT (hdr->lsp_id) != 0) {
- memcpy (lspid, hdr->lsp_id, ISIS_SYS_ID_LEN + 1);
- LSP_FRAGMENT (lspid) = 0;
- lsp0 = lsp_search (lspid, circuit->area->lspdb[level - 1]);
- if (!lsp0) {
- zlog_info ("Got lsp frag, while zero lsp not database");
- return ISIS_OK;
- }
- }
- lsp = lsp_new_from_stream_ptr (circuit->rcv_stream, ntohs (hdr->pdu_len),
- lsp0, circuit->area);
- lsp->level = level;
- lsp->adj = adj;
- lsp_insert (lsp, circuit->area->lspdb[level-1]);
- /* ii */
- ISIS_FLAGS_SET_ALL (lsp->SRMflags);
- /* iii */
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ }
+ /*
+ * If this lsp is a frag, need to see if we have zero lsp present
+ */
+ if (LSP_FRAGMENT (hdr->lsp_id) != 0)
+ {
+ memcpy (lspid, hdr->lsp_id, ISIS_SYS_ID_LEN + 1);
+ LSP_FRAGMENT (lspid) = 0;
+ lsp0 = lsp_search (lspid, circuit->area->lspdb[level - 1]);
+ if (!lsp0)
+ {
+ zlog_info ("Got lsp frag, while zero lsp not database");
+ return ISIS_OK;
+ }
+ }
+ lsp =
+ lsp_new_from_stream_ptr (circuit->rcv_stream,
+ ntohs (hdr->pdu_len), lsp0,
+ circuit->area);
+ lsp->level = level;
+ lsp->adj = adj;
+ lsp_insert (lsp, circuit->area->lspdb[level - 1]);
+ /* ii */
+ ISIS_FLAGS_SET_ALL (lsp->SRMflags);
+ /* iii */
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
- /* iv */
- if (circuit->circ_type != CIRCUIT_T_BROADCAST)
- ISIS_SET_FLAG (lsp->SSNflags, circuit);
- /* FIXME: v) */
+ /* iv */
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
+ /* FIXME: v) */
+ }
+ /* 7.3.15.1 e) 2) LSP equal to the one in db */
+ else if (comp == LSP_EQUAL)
+ {
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area);
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ {
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
+ }
+ }
+ /* 7.3.15.1 e) 3) LSP older than the one in db */
+ else
+ {
+ ISIS_SET_FLAG (lsp->SRMflags, circuit);
+ ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
+ }
}
- /* 7.3.15.1 e) 2) LSP equal to the one in db */
- else if (comp == LSP_EQUAL) {
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
- lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area);
- if (circuit->circ_type != CIRCUIT_T_BROADCAST) {
- ISIS_SET_FLAG (lsp->SSNflags, circuit);
- }
- }
- /* 7.3.15.1 e) 3) LSP older than the one in db */
- else {
- ISIS_SET_FLAG(lsp->SRMflags, circuit);
- ISIS_CLEAR_FLAG(lsp->SSNflags, circuit);
- }
- }
if (lsp)
lsp->adj = adj;
return retval;
@@ -1130,8 +1269,8 @@
*/
int
-process_snp (int snp_type, int level, struct isis_circuit *circuit,
- u_char *ssnpa)
+process_snp (int snp_type, int level, struct isis_circuit *circuit,
+ u_char * ssnpa)
{
int retval = ISIS_OK;
int cmp, own_lsp;
@@ -1143,76 +1282,82 @@
uint32_t found = 0, expected = 0;
struct isis_lsp *lsp;
struct lsp_entry *entry;
- struct listnode *node,*node2;
+ struct listnode *node, *node2;
struct tlvs tlvs;
struct list *lsp_list = NULL;
struct isis_passwd *passwd;
- if (snp_type == ISIS_SNP_CSNP_FLAG) {
- /* getting the header info */
- typechar = 'C';
- chdr = (struct isis_complete_seqnum_hdr*)STREAM_PNT(circuit->rcv_stream);
- circuit->rcv_stream->getp += ISIS_CSNP_HDRLEN;
- len = ntohs(chdr->pdu_len);
- if (len < ISIS_CSNP_HDRLEN) {
- zlog_warn ("Received a CSNP with bogus length!");
- return ISIS_OK;
+ if (snp_type == ISIS_SNP_CSNP_FLAG)
+ {
+ /* getting the header info */
+ typechar = 'C';
+ chdr =
+ (struct isis_complete_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
+ circuit->rcv_stream->getp += ISIS_CSNP_HDRLEN;
+ len = ntohs (chdr->pdu_len);
+ if (len < ISIS_CSNP_HDRLEN)
+ {
+ zlog_warn ("Received a CSNP with bogus length!");
+ return ISIS_OK;
+ }
}
- } else {
- typechar = 'P';
- phdr = (struct isis_partial_seqnum_hdr*)STREAM_PNT(circuit->rcv_stream);
- circuit->rcv_stream->getp += ISIS_PSNP_HDRLEN;
- len = ntohs(phdr->pdu_len);
- if (len < ISIS_PSNP_HDRLEN) {
- zlog_warn ("Received a CSNP with bogus length!");
- return ISIS_OK;
+ else
+ {
+ typechar = 'P';
+ phdr =
+ (struct isis_partial_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
+ circuit->rcv_stream->getp += ISIS_PSNP_HDRLEN;
+ len = ntohs (phdr->pdu_len);
+ if (len < ISIS_PSNP_HDRLEN)
+ {
+ zlog_warn ("Received a CSNP with bogus length!");
+ return ISIS_OK;
+ }
}
- }
/* 7.3.15.2 a) 1 - external domain circuit will discard snp pdu */
- if (circuit->ext_domain) {
+ if (circuit->ext_domain)
+ {
- zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
- "skipping: circuit externalDomain = true",
- circuit->area->area_tag,
- level,
- typechar,
- circuit->interface->name);
-
- return ISIS_OK;
- }
-
- /* 7.3.15.2 a) 2,3 - manualL2OnlyMode not implemented */
- if (!accept_level (level, circuit->circuit_is_type)) {
-
- zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
- "skipping: circuit type %s does not match level %d",
- circuit->area->area_tag,
- level,
- typechar,
- circuit->interface->name,
- circuit_t2string (circuit->circuit_is_type),
- level);
-
- return ISIS_OK;
- }
-
- /* 7.3.15.2 a) 4 - not applicable for CSNP only PSNPs on broadcast */
- if ((snp_type == ISIS_SNP_PSNP_FLAG) &&
- (circuit->circ_type == CIRCUIT_T_BROADCAST)) {
- if (!circuit->u.bc.is_dr[level-1]) {
-
- zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s, "
- "skipping: we are not the DIS",
+ zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
+ "skipping: circuit externalDomain = true",
circuit->area->area_tag,
- level,
- typechar,
- snpa_print(ssnpa),
- circuit->interface->name);
+ level, typechar, circuit->interface->name);
return ISIS_OK;
}
- }
+
+ /* 7.3.15.2 a) 2,3 - manualL2OnlyMode not implemented */
+ if (!accept_level (level, circuit->circuit_is_type))
+ {
+
+ zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
+ "skipping: circuit type %s does not match level %d",
+ circuit->area->area_tag,
+ level,
+ typechar,
+ circuit->interface->name,
+ circuit_t2string (circuit->circuit_is_type), level);
+
+ return ISIS_OK;
+ }
+
+ /* 7.3.15.2 a) 4 - not applicable for CSNP only PSNPs on broadcast */
+ if ((snp_type == ISIS_SNP_PSNP_FLAG) &&
+ (circuit->circ_type == CIRCUIT_T_BROADCAST))
+ {
+ if (!circuit->u.bc.is_dr[level - 1])
+ {
+
+ zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s, "
+ "skipping: we are not the DIS",
+ circuit->area->area_tag,
+ level,
+ typechar, snpa_print (ssnpa), circuit->interface->name);
+
+ return ISIS_OK;
+ }
+ }
/* 7.3.15.2 a) 5 - need to make sure IDLength matches - already checked */
@@ -1222,19 +1367,27 @@
/* 7.3.15.2 a) 7 - Must check that we have an adjacency of the same level */
/* for broadcast circuits, snpa should be compared */
/* FIXME : Do we need to check SNPA? */
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- if (snp_type == ISIS_SNP_CSNP_FLAG) {
- adj = isis_adj_lookup (chdr->source_id, circuit->u.bc.adjdb[level - 1]);
- } else {
- /* a psnp on a broadcast, how lovely of Juniper :) */
- adj = isis_adj_lookup (phdr->source_id, circuit->u.bc.adjdb[level - 1]);
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ if (snp_type == ISIS_SNP_CSNP_FLAG)
+ {
+ adj =
+ isis_adj_lookup (chdr->source_id, circuit->u.bc.adjdb[level - 1]);
+ }
+ else
+ {
+ /* a psnp on a broadcast, how lovely of Juniper :) */
+ adj =
+ isis_adj_lookup (phdr->source_id, circuit->u.bc.adjdb[level - 1]);
+ }
+ if (!adj)
+ return ISIS_OK; /* Silently discard */
}
- if (!adj)
- return ISIS_OK; /* Silently discard */
- } else {
- if (!circuit->u.p2p.neighbor)
- return ISIS_OK; /* Silently discard */
- }
+ else
+ {
+ if (!circuit->u.p2p.neighbor)
+ return ISIS_OK; /* Silently discard */
+ }
/* 7.3.15.2 a) 8 - Passwords for level 1 - not implemented */
@@ -1246,163 +1399,183 @@
expected |= TLVFLAG_LSP_ENTRIES;
expected |= TLVFLAG_AUTH_INFO;
retval = parse_tlvs (circuit->area->area_tag,
- STREAM_PNT(circuit->rcv_stream),
+ STREAM_PNT (circuit->rcv_stream),
len - circuit->rcv_stream->getp,
- &expected,
- &found,
- &tlvs);
+ &expected, &found, &tlvs);
- if (retval > ISIS_WARNING) {
- zlog_warn ("something went very wrong processing SNP");
- free_tlvs (&tlvs);
- return retval;
- }
+ if (retval > ISIS_WARNING)
+ {
+ zlog_warn ("something went very wrong processing SNP");
+ free_tlvs (&tlvs);
+ return retval;
+ }
(level == 1) ? (passwd = &circuit->area->area_passwd) :
- (passwd = &circuit->area->domain_passwd);
- if (passwd->type) {
- if (!(found & TLVFLAG_AUTH_INFO) ||
- authentication_check (passwd, &tlvs.auth_info)) {
- isis_event_auth_failure (circuit->area->area_tag, "SNP authentication"
- " failure", phdr ?
- phdr->source_id : chdr->source_id);
- return ISIS_OK;
- }
- }
+ (passwd = &circuit->area->domain_passwd);
+ if (passwd->type)
+ {
+ if (!(found & TLVFLAG_AUTH_INFO) ||
+ authentication_check (passwd, &tlvs.auth_info))
+ {
+ isis_event_auth_failure (circuit->area->area_tag,
+ "SNP authentication" " failure",
+ phdr ? phdr->source_id : chdr->source_id);
+ return ISIS_OK;
+ }
+ }
/* debug isis snp-packets */
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s",
- circuit->area->area_tag,
- level,
- typechar,
- snpa_print(ssnpa),
- circuit->interface->name);
- if (tlvs.lsp_entries) {
- LIST_LOOP (tlvs.lsp_entries,entry,node) {
- zlog_info("ISIS-Snp (%s): %cSNP entry %s, seq 0x%08x,"
- " cksum 0x%04x, lifetime %us",
- circuit->area->area_tag,
- typechar,
- rawlspid_print (entry->lsp_id),
- ntohl (entry->seq_num),
- ntohs (entry->checksum),
- ntohs (entry->rem_lifetime));
- }
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ zlog_info ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s",
+ circuit->area->area_tag,
+ level,
+ typechar, snpa_print (ssnpa), circuit->interface->name);
+ if (tlvs.lsp_entries)
+ {
+ LIST_LOOP (tlvs.lsp_entries, entry, node)
+ {
+ zlog_info ("ISIS-Snp (%s): %cSNP entry %s, seq 0x%08x,"
+ " cksum 0x%04x, lifetime %us",
+ circuit->area->area_tag,
+ typechar,
+ rawlspid_print (entry->lsp_id),
+ ntohl (entry->seq_num),
+ ntohs (entry->checksum), ntohs (entry->rem_lifetime));
+ }
+ }
}
- }
/* 7.3.15.2 b) Actions on LSP_ENTRIES reported */
- if (tlvs.lsp_entries) {
- LIST_LOOP (tlvs.lsp_entries, entry, node) {
- lsp = lsp_search (entry->lsp_id, circuit->area->lspdb[level - 1]);
- own_lsp = !memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
- if (lsp) {
- /* 7.3.15.2 b) 1) is this LSP newer */
- cmp = lsp_compare (circuit->area->area_tag, lsp, entry->seq_num,
- entry->checksum, entry->rem_lifetime);
- /* 7.3.15.2 b) 2) if it equals, clear SRM on p2p */
- if (cmp == LSP_EQUAL) {
- if (circuit->circ_type != CIRCUIT_T_BROADCAST)
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
- /* 7.3.15.2 b) 3) if it is older, clear SSN and set SRM */
- } else if (cmp == LSP_OLDER) {
- ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
- ISIS_SET_FLAG (lsp->SRMflags, circuit);
- } else {
- /* 7.3.15.2 b) 4) if it is newer, set SSN and clear SRM on p2p*/
- if (own_lsp) {
- lsp_inc_seqnum (lsp, ntohl (entry->seq_num));
- ISIS_SET_FLAG (lsp->SRMflags, circuit);
- } else {
- ISIS_SET_FLAG (lsp->SSNflags, circuit);
- if (circuit->circ_type != CIRCUIT_T_BROADCAST)
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
- }
- }
- } else {
- /* 7.3.15.2 b) 5) if it was not found, and all of those are not 0,
- * insert it and set SSN on it */
- if (entry->rem_lifetime && entry->checksum && entry->seq_num &&
- memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN)) {
- lsp = lsp_new (entry->lsp_id, ntohs (entry->rem_lifetime),
- 0, 0, entry->checksum, level);
- lsp_insert (lsp, circuit->area->lspdb[level - 1]);
- ISIS_SET_FLAG (lsp->SSNflags, circuit);
- }
+ if (tlvs.lsp_entries)
+ {
+ LIST_LOOP (tlvs.lsp_entries, entry, node)
+ {
+ lsp = lsp_search (entry->lsp_id, circuit->area->lspdb[level - 1]);
+ own_lsp = !memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
+ if (lsp)
+ {
+ /* 7.3.15.2 b) 1) is this LSP newer */
+ cmp = lsp_compare (circuit->area->area_tag, lsp, entry->seq_num,
+ entry->checksum, entry->rem_lifetime);
+ /* 7.3.15.2 b) 2) if it equals, clear SRM on p2p */
+ if (cmp == LSP_EQUAL)
+ {
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ /* 7.3.15.2 b) 3) if it is older, clear SSN and set SRM */
+ }
+ else if (cmp == LSP_OLDER)
+ {
+ ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
+ ISIS_SET_FLAG (lsp->SRMflags, circuit);
+ }
+ else
+ {
+ /* 7.3.15.2 b) 4) if it is newer, set SSN and clear SRM
+ * on p2p */
+ if (own_lsp)
+ {
+ lsp_inc_seqnum (lsp, ntohl (entry->seq_num));
+ ISIS_SET_FLAG (lsp->SRMflags, circuit);
+ }
+ else
+ {
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
+ if (circuit->circ_type != CIRCUIT_T_BROADCAST)
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ }
+ }
+ }
+ else
+ {
+ /* 7.3.15.2 b) 5) if it was not found, and all of those are not 0,
+ * insert it and set SSN on it */
+ if (entry->rem_lifetime && entry->checksum && entry->seq_num &&
+ memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
+ {
+ lsp = lsp_new (entry->lsp_id, ntohs (entry->rem_lifetime),
+ 0, 0, entry->checksum, level);
+ lsp_insert (lsp, circuit->area->lspdb[level - 1]);
+ ISIS_SET_FLAG (lsp->SSNflags, circuit);
+ }
+ }
}
}
- }
/* 7.3.15.2 c) on CSNP set SRM for all in range which were not reported */
- if (snp_type == ISIS_SNP_CSNP_FLAG) {
- /*
- * Build a list from our own LSP db bounded with start_ and stop_lsp_id
- */
- lsp_list = list_new ();
- lsp_build_list_nonzero_ht (chdr->start_lsp_id, chdr->stop_lsp_id,
- lsp_list, circuit->area->lspdb[level - 1]);
+ if (snp_type == ISIS_SNP_CSNP_FLAG)
+ {
+ /*
+ * Build a list from our own LSP db bounded with start_ and stop_lsp_id
+ */
+ lsp_list = list_new ();
+ lsp_build_list_nonzero_ht (chdr->start_lsp_id, chdr->stop_lsp_id,
+ lsp_list, circuit->area->lspdb[level - 1]);
- /* Fixme: Find a better solution */
- if (tlvs.lsp_entries) {
- LIST_LOOP (tlvs.lsp_entries, entry, node) {
- LIST_LOOP (lsp_list, lsp, node2) {
- if (lsp_id_cmp (lsp->lsp_header->lsp_id, entry->lsp_id) == 0) {
- list_delete_node (lsp_list, node2);
- break;
- }
- }
+ /* Fixme: Find a better solution */
+ if (tlvs.lsp_entries)
+ {
+ LIST_LOOP (tlvs.lsp_entries, entry, node)
+ {
+ LIST_LOOP (lsp_list, lsp, node2)
+ {
+ if (lsp_id_cmp (lsp->lsp_header->lsp_id, entry->lsp_id) == 0)
+ {
+ list_delete_node (lsp_list, node2);
+ break;
+ }
+ }
+ }
+ }
+ /* on remaining LSPs we set SRM (neighbor knew not of) */
+ LIST_LOOP (lsp_list, lsp, node2)
+ {
+ ISIS_SET_FLAG (lsp->SRMflags, circuit);
}
+ /* lets free it */
+ list_free (lsp_list);
}
- /* on remaining LSPs we set SRM (neighbor knew not of) */
- LIST_LOOP (lsp_list, lsp, node2) {
- ISIS_SET_FLAG (lsp->SRMflags, circuit);
- }
- /* lets free it */
- list_free (lsp_list);
- }
free_tlvs (&tlvs);
return retval;
}
int
-process_csnp (int level, struct isis_circuit *circuit, u_char *ssnpa)
+process_csnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
{
-
/* Sanity check - FIXME: move to correct place */
- if ((stream_get_endp (circuit->rcv_stream) -
- stream_get_getp (circuit->rcv_stream)) < ISIS_CSNP_HDRLEN) {
- zlog_warn ("Packet too short ( < %d)", ISIS_CSNP_HDRLEN);
- return ISIS_WARNING;
- }
+ if ((stream_get_endp (circuit->rcv_stream) -
+ stream_get_getp (circuit->rcv_stream)) < ISIS_CSNP_HDRLEN)
+ {
+ zlog_warn ("Packet too short ( < %d)", ISIS_CSNP_HDRLEN);
+ return ISIS_WARNING;
+ }
return process_snp (ISIS_SNP_CSNP_FLAG, level, circuit, ssnpa);
}
-int
-process_psnp (int level, struct isis_circuit *circuit, u_char *ssnpa)
+int
+process_psnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
{
-
- if ((stream_get_endp (circuit->rcv_stream) -
- stream_get_getp (circuit->rcv_stream)) < ISIS_PSNP_HDRLEN) {
- zlog_warn ("Packet too short");
- return ISIS_WARNING;
- }
+ if ((stream_get_endp (circuit->rcv_stream) -
+ stream_get_getp (circuit->rcv_stream)) < ISIS_PSNP_HDRLEN)
+ {
+ zlog_warn ("Packet too short");
+ return ISIS_WARNING;
+ }
return process_snp (ISIS_SNP_PSNP_FLAG, level, circuit, ssnpa);
}
-
-
/*
* Process ISH
* ISO - 10589
* Section 8.2.2 - Receiving ISH PDUs by an intermediate system
* FIXME: sample packet dump, need to figure 0x81 - looks like NLPid
- 0x82 0x15 0x01 0x00 0x04 0x01 0x2c 0x59
- 0x38 0x08 0x47 0x00 0x01 0x00 0x02 0x00
- 0x03 0x00 0x81 0x01 0xcc
+ * 0x82 0x15 0x01 0x00 0x04 0x01 0x2c 0x59
+ * 0x38 0x08 0x47 0x00 0x01 0x00 0x02 0x00
+ * 0x03 0x00 0x81 0x01 0xcc
*/
int
process_is_hello (struct isis_circuit *circuit)
@@ -1419,172 +1592,185 @@
return retval;
neigh_len = stream_getc (circuit->rcv_stream);
- sysid = STREAM_PNT(circuit->rcv_stream) + neigh_len - 1 - ISIS_SYS_ID_LEN;
+ sysid = STREAM_PNT (circuit->rcv_stream) + neigh_len - 1 - ISIS_SYS_ID_LEN;
adj = circuit->u.p2p.neighbor;
- if (!adj) {
- /* 8.2.2 */
- adj = isis_new_adj (sysid, " ", 0, circuit);
- if (adj == NULL)
- return ISIS_ERROR;
+ if (!adj)
+ {
+ /* 8.2.2 */
+ adj = isis_new_adj (sysid, " ", 0, circuit);
+ if (adj == NULL)
+ return ISIS_ERROR;
- isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
- adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
- circuit->u.p2p.neighbor = adj;
- }
- /* 8.2.2 a)*/
- if ((adj->adj_state == ISIS_ADJ_UP) && memcmp (adj->sysid,sysid,
- ISIS_SYS_ID_LEN)) {
- /* 8.2.2 a) 1) FIXME: adjStateChange(down) event */
- /* 8.2.2 a) 2) delete the adj */
- XFREE (MTYPE_ISIS_ADJACENCY, adj);
- /* 8.2.2 a) 3) create a new adj */
- adj = isis_new_adj (sysid, " ", 0, circuit);
- if (adj == NULL)
- return ISIS_ERROR;
+ isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
+ adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
+ circuit->u.p2p.neighbor = adj;
+ }
+ /* 8.2.2 a) */
+ if ((adj->adj_state == ISIS_ADJ_UP) && memcmp (adj->sysid, sysid,
+ ISIS_SYS_ID_LEN))
+ {
+ /* 8.2.2 a) 1) FIXME: adjStateChange(down) event */
+ /* 8.2.2 a) 2) delete the adj */
+ XFREE (MTYPE_ISIS_ADJACENCY, adj);
+ /* 8.2.2 a) 3) create a new adj */
+ adj = isis_new_adj (sysid, " ", 0, circuit);
+ if (adj == NULL)
+ return ISIS_ERROR;
- /* 8.2.2 a) 3) i */
- isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
- /* 8.2.2 a) 3) ii */
- adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
- /* 8.2.2 a) 4) quite meaningless */
- }
+ /* 8.2.2 a) 3) i */
+ isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
+ /* 8.2.2 a) 3) ii */
+ adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
+ /* 8.2.2 a) 4) quite meaningless */
+ }
/* 8.2.2 b) ignore on condition */
- if ((adj->adj_state == ISIS_ADJ_INITIALIZING) &&
- (adj->sys_type == ISIS_SYSTYPE_IS)) {
- /* do nothing */
- } else {
- /* 8.2.2 c) respond with a p2p IIH */
- send_hello (circuit, 1);
- }
+ if ((adj->adj_state == ISIS_ADJ_INITIALIZING) &&
+ (adj->sys_type == ISIS_SYSTYPE_IS))
+ {
+ /* do nothing */
+ }
+ else
+ {
+ /* 8.2.2 c) respond with a p2p IIH */
+ send_hello (circuit, 1);
+ }
/* 8.2.2 d) type is IS */
- adj->sys_type = ISIS_SYSTYPE_IS;
+ adj->sys_type = ISIS_SYSTYPE_IS;
/* 8.2.2 e) FIXME: Circuit type of? */
-
return retval;
}
-
/*
* PDU Dispatcher
*/
-int
-isis_handle_pdu (struct isis_circuit *circuit, u_char *ssnpa)
+int
+isis_handle_pdu (struct isis_circuit *circuit, u_char * ssnpa)
{
-
struct isis_fixed_hdr *hdr;
struct esis_fixed_hdr *esis_hdr;
- int retval=ISIS_OK;
+ int retval = ISIS_OK;
/*
* Let's first read data from stream to the header
*/
- hdr = (struct isis_fixed_hdr*)STREAM_DATA(circuit->rcv_stream);
+ hdr = (struct isis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
- if ((hdr->idrp != ISO10589_ISIS) && (hdr->idrp != ISO9542_ESIS)){
- zlog_warn ("Not an IS-IS or ES-IS packet IDRP=%02x", hdr->idrp);
- return ISIS_ERROR;
- }
+ if ((hdr->idrp != ISO10589_ISIS) && (hdr->idrp != ISO9542_ESIS))
+ {
+ zlog_warn ("Not an IS-IS or ES-IS packet IDRP=%02x", hdr->idrp);
+ return ISIS_ERROR;
+ }
/* now we need to know if this is an ISO 9542 packet and
* take real good care of it, waaa!
*/
- if (hdr->idrp == ISO9542_ESIS){
- esis_hdr = (struct esis_fixed_hdr*)STREAM_DATA(circuit->rcv_stream);
- stream_set_getp (circuit->rcv_stream, ESIS_FIXED_HDR_LEN);
- /* FIXME: Need to do some acceptence tests */
- /* example length... */
- switch (esis_hdr->pdu_type) {
- case ESH_PDU:
- /* FIXME */
- break;
- case ISH_PDU:
- zlog_info ("AN ISH PDU!!");
- retval = process_is_hello (circuit);
- break;
- default:
- return ISIS_ERROR;
- }
- return retval;
- } else {
- stream_set_getp (circuit->rcv_stream, ISIS_FIXED_HDR_LEN);
- }
+ if (hdr->idrp == ISO9542_ESIS)
+ {
+ esis_hdr = (struct esis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
+ stream_set_getp (circuit->rcv_stream, ESIS_FIXED_HDR_LEN);
+ /* FIXME: Need to do some acceptence tests */
+ /* example length... */
+ switch (esis_hdr->pdu_type)
+ {
+ case ESH_PDU:
+ /* FIXME */
+ break;
+ case ISH_PDU:
+ zlog_info ("AN ISH PDU!!");
+ retval = process_is_hello (circuit);
+ break;
+ default:
+ return ISIS_ERROR;
+ }
+ return retval;
+ }
+ else
+ {
+ stream_set_getp (circuit->rcv_stream, ISIS_FIXED_HDR_LEN);
+ }
/*
* and then process it
*/
- if (hdr->length < ISIS_MINIMUM_FIXED_HDR_LEN) {
- zlog_err ("Fixed header length = %d", hdr->length);
- return ISIS_ERROR;
- }
+ if (hdr->length < ISIS_MINIMUM_FIXED_HDR_LEN)
+ {
+ zlog_err ("Fixed header length = %d", hdr->length);
+ return ISIS_ERROR;
+ }
- if (hdr->version1 != 1) {
- zlog_warn ("Unsupported ISIS version %u", hdr->version1);
- return ISIS_WARNING;
- }
+ if (hdr->version1 != 1)
+ {
+ zlog_warn ("Unsupported ISIS version %u", hdr->version1);
+ return ISIS_WARNING;
+ }
/* either 6 or 0 */
- if ((hdr->id_len != 0) && (hdr->id_len != ISIS_SYS_ID_LEN)) {
- zlog_err ("IDFieldLengthMismatch: ID Length field in a received PDU %u, "
- "while the parameter for this IS is %u", hdr->id_len,
- ISIS_SYS_ID_LEN);
- return ISIS_ERROR;
- }
+ if ((hdr->id_len != 0) && (hdr->id_len != ISIS_SYS_ID_LEN))
+ {
+ zlog_err
+ ("IDFieldLengthMismatch: ID Length field in a received PDU %u, "
+ "while the parameter for this IS is %u", hdr->id_len,
+ ISIS_SYS_ID_LEN);
+ return ISIS_ERROR;
+ }
- if (hdr->version2 != 1) {
- zlog_warn ("Unsupported ISIS version %u", hdr->version2);
- return ISIS_WARNING;
- }
+ if (hdr->version2 != 1)
+ {
+ zlog_warn ("Unsupported ISIS version %u", hdr->version2);
+ return ISIS_WARNING;
+ }
/* either 3 or 0 */
- if ((hdr->max_area_addrs != 0) && (hdr->max_area_addrs != isis->max_area_addrs)) {
- zlog_err ("maximumAreaAddressesMismatch: maximumAreaAdresses in a "
- "received PDU %u while the parameter for this IS is %u",
- hdr->max_area_addrs, isis->max_area_addrs);
- return ISIS_ERROR;
- }
+ if ((hdr->max_area_addrs != 0)
+ && (hdr->max_area_addrs != isis->max_area_addrs))
+ {
+ zlog_err ("maximumAreaAddressesMismatch: maximumAreaAdresses in a "
+ "received PDU %u while the parameter for this IS is %u",
+ hdr->max_area_addrs, isis->max_area_addrs);
+ return ISIS_ERROR;
+ }
- switch (hdr->pdu_type) {
- case L1_LAN_HELLO:
- retval = process_lan_hello (ISIS_LEVEL1, circuit, ssnpa);
- break;
- case L2_LAN_HELLO:
- retval = process_lan_hello (ISIS_LEVEL2, circuit, ssnpa);
- break;
- case P2P_HELLO:
- retval = process_p2p_hello (circuit);
- break;
- case L1_LINK_STATE:
- retval = process_lsp (ISIS_LEVEL1, circuit, ssnpa);
- break;
- case L2_LINK_STATE:
- retval = process_lsp (ISIS_LEVEL2, circuit, ssnpa);
- break;
- case L1_COMPLETE_SEQ_NUM:
- retval = process_csnp (ISIS_LEVEL1, circuit, ssnpa);
- break;
- case L2_COMPLETE_SEQ_NUM:
- retval = process_csnp (ISIS_LEVEL2, circuit, ssnpa);
- break;
- case L1_PARTIAL_SEQ_NUM:
- retval = process_psnp (ISIS_LEVEL1, circuit, ssnpa);
- break;
- case L2_PARTIAL_SEQ_NUM:
- retval = process_psnp (ISIS_LEVEL2, circuit, ssnpa);
- break;
- default:
- return ISIS_ERROR;
- }
+ switch (hdr->pdu_type)
+ {
+ case L1_LAN_HELLO:
+ retval = process_lan_hello (ISIS_LEVEL1, circuit, ssnpa);
+ break;
+ case L2_LAN_HELLO:
+ retval = process_lan_hello (ISIS_LEVEL2, circuit, ssnpa);
+ break;
+ case P2P_HELLO:
+ retval = process_p2p_hello (circuit);
+ break;
+ case L1_LINK_STATE:
+ retval = process_lsp (ISIS_LEVEL1, circuit, ssnpa);
+ break;
+ case L2_LINK_STATE:
+ retval = process_lsp (ISIS_LEVEL2, circuit, ssnpa);
+ break;
+ case L1_COMPLETE_SEQ_NUM:
+ retval = process_csnp (ISIS_LEVEL1, circuit, ssnpa);
+ break;
+ case L2_COMPLETE_SEQ_NUM:
+ retval = process_csnp (ISIS_LEVEL2, circuit, ssnpa);
+ break;
+ case L1_PARTIAL_SEQ_NUM:
+ retval = process_psnp (ISIS_LEVEL1, circuit, ssnpa);
+ break;
+ case L2_PARTIAL_SEQ_NUM:
+ retval = process_psnp (ISIS_LEVEL2, circuit, ssnpa);
+ break;
+ default:
+ return ISIS_ERROR;
+ }
return retval;
}
-
#ifdef GNU_LINUX
int
isis_receive (struct thread *thread)
{
-
struct isis_circuit *circuit;
u_char ssnpa[ETH_ALEN];
int retval;
@@ -1596,12 +1782,12 @@
assert (circuit);
if (circuit->rcv_stream == NULL)
- circuit->rcv_stream = stream_new (ISO_MTU(circuit));
+ circuit->rcv_stream = stream_new (ISO_MTU (circuit));
else
stream_reset (circuit->rcv_stream);
retval = circuit->rx (circuit, ssnpa);
- circuit->t_read = NULL;
+ circuit->t_read = NULL;
if (retval == ISIS_OK)
retval = isis_handle_pdu (circuit, ssnpa);
@@ -1609,7 +1795,8 @@
/*
* prepare for next packet.
*/
- THREAD_READ_ON(master, circuit->t_read, isis_receive, circuit, circuit->fd);
+ THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
+ circuit->fd);
return retval;
}
@@ -1618,7 +1805,6 @@
int
isis_receive (struct thread *thread)
{
-
struct isis_circuit *circuit;
u_char ssnpa[ETH_ALEN];
int retval;
@@ -1629,10 +1815,10 @@
circuit = THREAD_ARG (thread);
assert (circuit);
- circuit->t_read = NULL;
+ circuit->t_read = NULL;
if (circuit->rcv_stream == NULL)
- circuit->rcv_stream = stream_new (ISO_MTU(circuit));
+ circuit->rcv_stream = stream_new (ISO_MTU (circuit));
else
stream_reset (circuit->rcv_stream);
@@ -1644,10 +1830,10 @@
/*
* prepare for next packet.
*/
- circuit->t_read = thread_add_timer_msec (master, isis_receive, circuit,
- listcount
- (circuit->area->circuit_list)*100);
-
+ circuit->t_read = thread_add_timer_msec (master, isis_receive, circuit,
+ listcount
+ (circuit->area->circuit_list) *
+ 100);
return retval;
}
@@ -1662,47 +1848,47 @@
hdr->idrp = ISO10589_ISIS;
- switch (pdu_type) {
- case L1_LAN_HELLO:
- case L2_LAN_HELLO:
- hdr->length = ISIS_LANHELLO_HDRLEN;
- break;
- case P2P_HELLO:
- hdr->length = ISIS_P2PHELLO_HDRLEN;
- break;
- case L1_LINK_STATE:
- case L2_LINK_STATE:
- hdr->length = ISIS_LSP_HDR_LEN;
- break;
- case L1_COMPLETE_SEQ_NUM:
- case L2_COMPLETE_SEQ_NUM:
- hdr->length = ISIS_CSNP_HDRLEN;
- break;
- case L1_PARTIAL_SEQ_NUM:
- case L2_PARTIAL_SEQ_NUM:
- hdr->length = ISIS_PSNP_HDRLEN;
- break;
- default:
- zlog_warn ("fill_fixed_hdr(): unknown pdu type %d", pdu_type);
- return;
- }
+ switch (pdu_type)
+ {
+ case L1_LAN_HELLO:
+ case L2_LAN_HELLO:
+ hdr->length = ISIS_LANHELLO_HDRLEN;
+ break;
+ case P2P_HELLO:
+ hdr->length = ISIS_P2PHELLO_HDRLEN;
+ break;
+ case L1_LINK_STATE:
+ case L2_LINK_STATE:
+ hdr->length = ISIS_LSP_HDR_LEN;
+ break;
+ case L1_COMPLETE_SEQ_NUM:
+ case L2_COMPLETE_SEQ_NUM:
+ hdr->length = ISIS_CSNP_HDRLEN;
+ break;
+ case L1_PARTIAL_SEQ_NUM:
+ case L2_PARTIAL_SEQ_NUM:
+ hdr->length = ISIS_PSNP_HDRLEN;
+ break;
+ default:
+ zlog_warn ("fill_fixed_hdr(): unknown pdu type %d", pdu_type);
+ return;
+ }
hdr->length += ISIS_FIXED_HDR_LEN;
hdr->pdu_type = pdu_type;
hdr->version1 = 1;
- hdr->id_len = 0; /* ISIS_SYS_ID_LEN - 0==6 */
+ hdr->id_len = 0; /* ISIS_SYS_ID_LEN - 0==6 */
hdr->version2 = 1;
- hdr->max_area_addrs = 0; /* isis->max_area_addrs - 0==3 */
+ hdr->max_area_addrs = 0; /* isis->max_area_addrs - 0==3 */
}
-
/*
* SEND SIDE
*/
void
fill_fixed_hdr_andstream (struct isis_fixed_hdr *hdr, u_char pdu_type,
- struct stream *stream)
+ struct stream *stream)
{
- fill_fixed_hdr (hdr,pdu_type);
+ fill_fixed_hdr (hdr, pdu_type);
stream_putc (stream, hdr->idrp);
stream_putc (stream, hdr->length);
@@ -1716,7 +1902,6 @@
return;
}
-
int
send_hello (struct isis_circuit *circuit, int level)
{
@@ -1728,55 +1913,65 @@
unsigned long len_pointer, length;
int retval;
- if (circuit->interface->mtu == 0) {
- zlog_warn ("circuit has zero MTU");
- return ISIS_WARNING;
- }
+ if (circuit->interface->mtu == 0)
+ {
+ zlog_warn ("circuit has zero MTU");
+ return ISIS_WARNING;
+ }
if (!circuit->snd_stream)
- circuit->snd_stream = stream_new (ISO_MTU(circuit));
+ circuit->snd_stream = stream_new (ISO_MTU (circuit));
else
stream_reset (circuit->snd_stream);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
if (level == 1)
- fill_fixed_hdr_andstream(&fixed_hdr, L1_LAN_HELLO, circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L1_LAN_HELLO,
+ circuit->snd_stream);
else
- fill_fixed_hdr_andstream(&fixed_hdr, L2_LAN_HELLO, circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L2_LAN_HELLO,
+ circuit->snd_stream);
else
- fill_fixed_hdr_andstream(&fixed_hdr, P2P_HELLO, circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, P2P_HELLO, circuit->snd_stream);
/*
* Fill LAN Level 1 or 2 Hello PDU header
*/
memset (&hello_hdr, 0, sizeof (struct isis_lan_hello_hdr));
- interval = circuit->hello_multiplier[level - 1] *
+ interval = circuit->hello_multiplier[level - 1] *
circuit->hello_interval[level - 1];
if (interval > USHRT_MAX)
interval = USHRT_MAX;
hello_hdr.circuit_t = circuit->circuit_is_type;
memcpy (hello_hdr.source_id, isis->sysid, ISIS_SYS_ID_LEN);
- hello_hdr.hold_time = htons((u_int16_t)interval);
+ hello_hdr.hold_time = htons ((u_int16_t) interval);
- hello_hdr.pdu_len = 0; /* Update the PDU Length later */
- len_pointer = stream_get_putp (circuit->snd_stream) + 3 + ISIS_SYS_ID_LEN;
-
+ hello_hdr.pdu_len = 0; /* Update the PDU Length later */
+ len_pointer = stream_get_putp (circuit->snd_stream) + 3 + ISIS_SYS_ID_LEN;
/* copy the shared part of the hello to the p2p hello if needed */
- if (circuit->circ_type == CIRCUIT_T_P2P) {
- memcpy (&p2p_hello_hdr, &hello_hdr, 5 + ISIS_SYS_ID_LEN);
- p2p_hello_hdr.local_id = circuit->circuit_id;
- /* FIXME: need better understanding */
- stream_put (circuit->snd_stream, &p2p_hello_hdr, ISIS_P2PHELLO_HDRLEN);
- } else {
- hello_hdr.prio = circuit->u.bc.priority[level - 1];
- if(level == 1 && circuit->u.bc.l1_desig_is) {
- memcpy(hello_hdr.lan_id, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
- } else if (level == 2 && circuit->u.bc.l2_desig_is){
- memcpy(hello_hdr.lan_id, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
+ if (circuit->circ_type == CIRCUIT_T_P2P)
+ {
+ memcpy (&p2p_hello_hdr, &hello_hdr, 5 + ISIS_SYS_ID_LEN);
+ p2p_hello_hdr.local_id = circuit->circuit_id;
+ /* FIXME: need better understanding */
+ stream_put (circuit->snd_stream, &p2p_hello_hdr, ISIS_P2PHELLO_HDRLEN);
}
- stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN);
- }
+ else
+ {
+ hello_hdr.prio = circuit->u.bc.priority[level - 1];
+ if (level == 1 && circuit->u.bc.l1_desig_is)
+ {
+ memcpy (hello_hdr.lan_id, circuit->u.bc.l1_desig_is,
+ ISIS_SYS_ID_LEN + 1);
+ }
+ else if (level == 2 && circuit->u.bc.l2_desig_is)
+ {
+ memcpy (hello_hdr.lan_id, circuit->u.bc.l2_desig_is,
+ ISIS_SYS_ID_LEN + 1);
+ }
+ stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN);
+ }
/*
* Then the variable length part
@@ -1793,19 +1988,20 @@
return ISIS_WARNING;
/* LAN Neighbors TLV */
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- if (level == 1 && circuit->u.bc.lan_neighs[0]->count > 0)
- if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[0],
- circuit->snd_stream))
- return ISIS_WARNING;
- if (level == 2 && circuit->u.bc.lan_neighs[1]->count > 0)
- if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[1],
- circuit->snd_stream))
- return ISIS_WARNING;
- }
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ if (level == 1 && circuit->u.bc.lan_neighs[0]->count > 0)
+ if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[0],
+ circuit->snd_stream))
+ return ISIS_WARNING;
+ if (level == 2 && circuit->u.bc.lan_neighs[1]->count > 0)
+ if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[1],
+ circuit->snd_stream))
+ return ISIS_WARNING;
+ }
/* Protocols Supported TLV */
- if (circuit->nlpids.count > 0)
+ if (circuit->nlpids.count > 0)
if (tlv_add_nlpid (&circuit->nlpids, circuit->snd_stream))
return ISIS_WARNING;
/* IP interface Address TLV */
@@ -1813,9 +2009,9 @@
if (tlv_add_ip_addrs (circuit->ip_addrs, circuit->snd_stream))
return ISIS_WARNING;
-#ifdef HAVE_IPV6
+#ifdef HAVE_IPV6
/* IPv6 Interface Address TLV */
- if (circuit->ipv6_router && circuit->ipv6_link &&
+ if (circuit->ipv6_router && circuit->ipv6_link &&
circuit->ipv6_link->count > 0)
if (tlv_add_ipv6_addrs (circuit->ipv6_link, circuit->snd_stream))
return ISIS_WARNING;
@@ -1827,25 +2023,28 @@
length = stream_get_putp (circuit->snd_stream);
/* Update PDU length */
- stream_putw_at (circuit->snd_stream, len_pointer, (u_int16_t)length);
+ stream_putw_at (circuit->snd_stream, len_pointer, (u_int16_t) length);
retval = circuit->tx (circuit, level);
if (retval)
zlog_warn ("sending of LAN Level %d Hello failed", level);
/* DEBUG_ADJ_PACKETS */
- if (isis->debugs & DEBUG_ADJ_PACKETS) {
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- zlog_info ("ISIS-Adj (%s): Sent L%d LAN IIH on %s, length %ld",
- circuit->area->area_tag, level, circuit->interface->name,
- STREAM_SIZE(circuit->snd_stream));
- } else {
- zlog_info ("ISIS-Adj (%s): Sent P2P IIH on %s, length %ld",
- circuit->area->area_tag, circuit->interface->name,
- STREAM_SIZE(circuit->snd_stream));
+ if (isis->debugs & DEBUG_ADJ_PACKETS)
+ {
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ zlog_info ("ISIS-Adj (%s): Sent L%d LAN IIH on %s, length %ld",
+ circuit->area->area_tag, level, circuit->interface->name,
+ STREAM_SIZE (circuit->snd_stream));
+ }
+ else
+ {
+ zlog_info ("ISIS-Adj (%s): Sent P2P IIH on %s, length %ld",
+ circuit->area->area_tag, circuit->interface->name,
+ STREAM_SIZE (circuit->snd_stream));
+ }
}
- }
-
return retval;
}
@@ -1853,13 +2052,12 @@
int
send_lan_hello (struct isis_circuit *circuit, int level)
{
- return send_hello (circuit,level);
+ return send_hello (circuit, level);
}
int
send_lan_l1_hello (struct thread *thread)
{
-
struct isis_circuit *circuit;
int retval;
@@ -1868,13 +2066,14 @@
circuit->u.bc.t_send_lan_hello[0] = NULL;
if (circuit->u.bc.run_dr_elect[0])
- retval = isis_dr_elect (circuit, 1);
+ retval = isis_dr_elect (circuit, 1);
retval = send_lan_hello (circuit, 1);
/* set next timer thread */
- THREAD_TIMER_ON(master, circuit->u.bc.t_send_lan_hello[0], send_lan_l1_hello,
- circuit, isis_jitter (circuit->hello_interval[0], IIH_JITTER));
+ THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
+ send_lan_l1_hello, circuit,
+ isis_jitter (circuit->hello_interval[0], IIH_JITTER));
return retval;
}
@@ -1894,9 +2093,10 @@
retval = send_lan_hello (circuit, 2);
- /* set next timer thread*/
- THREAD_TIMER_ON(master, circuit->u.bc.t_send_lan_hello[1], send_lan_l2_hello,
- circuit, isis_jitter (circuit->hello_interval[1], IIH_JITTER));
+ /* set next timer thread */
+ THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
+ send_lan_l2_hello, circuit,
+ isis_jitter (circuit->hello_interval[1], IIH_JITTER));
return retval;
}
@@ -1910,18 +2110,19 @@
assert (circuit);
circuit->u.p2p.t_send_p2p_hello = NULL;
- send_hello(circuit,1);
+ send_hello (circuit, 1);
- /* set next timer thread*/
- THREAD_TIMER_ON(master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
- circuit, isis_jitter (circuit->hello_interval[1], IIH_JITTER));
+ /* set next timer thread */
+ THREAD_TIMER_ON (master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
+ circuit, isis_jitter (circuit->hello_interval[1],
+ IIH_JITTER));
return ISIS_OK;
}
int
-build_csnp (int level, u_char *start, u_char *stop, struct list *lsps,
- struct isis_circuit *circuit)
+build_csnp (int level, u_char * start, u_char * stop, struct list *lsps,
+ struct isis_circuit *circuit)
{
struct isis_fixed_hdr fixed_hdr;
struct isis_passwd *passwd;
@@ -1929,19 +2130,19 @@
unsigned long lenp;
u_int16_t length;
- if (level ==1)
- fill_fixed_hdr_andstream (&fixed_hdr, L1_COMPLETE_SEQ_NUM,
- circuit->snd_stream);
+ if (level == 1)
+ fill_fixed_hdr_andstream (&fixed_hdr, L1_COMPLETE_SEQ_NUM,
+ circuit->snd_stream);
else
- fill_fixed_hdr_andstream (&fixed_hdr, L2_COMPLETE_SEQ_NUM,
- circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L2_COMPLETE_SEQ_NUM,
+ circuit->snd_stream);
/*
* Fill Level 1 or 2 Complete Sequence Numbers header
*/
lenp = stream_get_putp (circuit->snd_stream);
- stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
+ stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
/* no need to send the source here, it is always us if we csnp */
stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
/* with zero circuit id - ref 9.10, 9.11 */
@@ -1962,10 +2163,11 @@
retval = tlv_add_authinfo (passwd->type, passwd->len,
passwd->passwd, circuit->snd_stream);
- if (!retval && lsps) {
- retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
- }
- length = (u_int16_t)stream_get_putp (circuit->snd_stream);
+ if (!retval && lsps)
+ {
+ retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
+ }
+ length = (u_int16_t) stream_get_putp (circuit->snd_stream);
assert (length >= ISIS_CSNP_HDRLEN);
/* Update PU length */
stream_putw_at (circuit->snd_stream, lenp, length);
@@ -1987,41 +2189,44 @@
struct listnode *node;
struct isis_lsp *lsp;
- memset (start,0x00, ISIS_SYS_ID_LEN + 2);
+ memset (start, 0x00, ISIS_SYS_ID_LEN + 2);
memset (stop, 0xff, ISIS_SYS_ID_LEN + 2);
- if (circuit->area->lspdb[level-1] &&
- dict_count (circuit->area->lspdb[level-1]) > 0) {
- list = list_new ();
- lsp_build_list (start, stop, list, circuit->area->lspdb[level-1]);
+ if (circuit->area->lspdb[level - 1] &&
+ dict_count (circuit->area->lspdb[level - 1]) > 0)
+ {
+ list = list_new ();
+ lsp_build_list (start, stop, list, circuit->area->lspdb[level - 1]);
- if (circuit->snd_stream == NULL)
- circuit->snd_stream = stream_new (ISO_MTU(circuit));
- else
- stream_reset (circuit->snd_stream);
+ if (circuit->snd_stream == NULL)
+ circuit->snd_stream = stream_new (ISO_MTU (circuit));
+ else
+ stream_reset (circuit->snd_stream);
- retval = build_csnp (level, start, stop, list, circuit);
+ retval = build_csnp (level, start, stop, list, circuit);
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- zlog_info ("ISIS-Snp (%s): Sent L%d CSNP on %s, length %ld",
- circuit->area->area_tag, level, circuit->interface->name,
- STREAM_SIZE(circuit->snd_stream));
- LIST_LOOP (list, lsp, node) {
- zlog_info("ISIS-Snp (%s): CSNP entry %s, seq 0x%08x,"
- " cksum 0x%04x, lifetime %us",
- circuit->area->area_tag,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl (lsp->lsp_header->seq_num),
- ntohs (lsp->lsp_header->checksum),
- ntohs (lsp->lsp_header->rem_lifetime));
- }
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ zlog_info ("ISIS-Snp (%s): Sent L%d CSNP on %s, length %ld",
+ circuit->area->area_tag, level, circuit->interface->name,
+ STREAM_SIZE (circuit->snd_stream));
+ LIST_LOOP (list, lsp, node)
+ {
+ zlog_info ("ISIS-Snp (%s): CSNP entry %s, seq 0x%08x,"
+ " cksum 0x%04x, lifetime %us",
+ circuit->area->area_tag,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ }
+ }
+
+ list_delete (list);
+
+ if (retval == ISIS_OK)
+ retval = circuit->tx (circuit, level);
}
-
- list_delete (list);
-
- if (retval == ISIS_OK)
- retval = circuit->tx (circuit, level);
- }
return retval;
}
@@ -2036,12 +2241,13 @@
circuit->t_send_csnp[0] = NULL;
- if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[0]) {
- send_csnp(circuit,1);
- }
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[0])
+ {
+ send_csnp (circuit, 1);
+ }
/* set next timer thread */
- THREAD_TIMER_ON(master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
- isis_jitter(circuit->csnp_interval[0], CSNP_JITTER));
+ THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
+ isis_jitter (circuit->csnp_interval[0], CSNP_JITTER));
return retval;
}
@@ -2057,12 +2263,13 @@
circuit->t_send_csnp[1] = NULL;
- if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[1]) {
- send_csnp(circuit,2);
- }
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[1])
+ {
+ send_csnp (circuit, 2);
+ }
/* set next timer thread */
- THREAD_TIMER_ON(master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
- isis_jitter(circuit->csnp_interval[1], CSNP_JITTER));
+ THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
+ isis_jitter (circuit->csnp_interval[1], CSNP_JITTER));
return retval;
}
@@ -2079,17 +2286,17 @@
struct listnode *node;
if (level == 1)
- fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
- circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
+ circuit->snd_stream);
else
fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
- circuit->snd_stream);
+ circuit->snd_stream);
/*
* Fill Level 1 or 2 Partial Sequence Numbers header
*/
lenp = stream_get_putp (circuit->snd_stream);
- stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
+ stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
stream_putc (circuit->snd_stream, circuit->idx);
@@ -2106,23 +2313,26 @@
retval = tlv_add_authinfo (passwd->type, passwd->len,
passwd->passwd, circuit->snd_stream);
- if (!retval && lsps) {
- retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
- }
-
- if (isis->debugs & DEBUG_SNP_PACKETS) {
- LIST_LOOP (lsps, lsp, node) {
- zlog_info("ISIS-Snp (%s): PSNP entry %s, seq 0x%08x,"
- " cksum 0x%04x, lifetime %us",
- circuit->area->area_tag,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl (lsp->lsp_header->seq_num),
- ntohs (lsp->lsp_header->checksum),
- ntohs (lsp->lsp_header->rem_lifetime));
+ if (!retval && lsps)
+ {
+ retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
}
- }
- length = (u_int16_t)stream_get_putp (circuit->snd_stream);
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ {
+ LIST_LOOP (lsps, lsp, node)
+ {
+ zlog_info ("ISIS-Snp (%s): PSNP entry %s, seq 0x%08x,"
+ " cksum 0x%04x, lifetime %us",
+ circuit->area->area_tag,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime));
+ }
+ }
+
+ length = (u_int16_t) stream_get_putp (circuit->snd_stream);
assert (length >= ISIS_PSNP_HDRLEN);
/* Update PDU length */
stream_putw_at (circuit->snd_stream, lenp, length);
@@ -2142,45 +2352,51 @@
struct list *list = NULL;
struct listnode *node;
- if ((circuit->circ_type == CIRCUIT_T_BROADCAST &&
+ if ((circuit->circ_type == CIRCUIT_T_BROADCAST &&
!circuit->u.bc.is_dr[level - 1]) ||
- circuit->circ_type != CIRCUIT_T_BROADCAST) {
+ circuit->circ_type != CIRCUIT_T_BROADCAST)
+ {
- if (circuit->area->lspdb[level-1] &&
- dict_count (circuit->area->lspdb[level-1]) > 0) {
- list = list_new ();
- lsp_build_list_ssn (circuit, list, circuit->area->lspdb[level-1]);
+ if (circuit->area->lspdb[level - 1] &&
+ dict_count (circuit->area->lspdb[level - 1]) > 0)
+ {
+ list = list_new ();
+ lsp_build_list_ssn (circuit, list, circuit->area->lspdb[level - 1]);
- if (listcount(list) > 0) {
- if (circuit->snd_stream == NULL)
- circuit->snd_stream = stream_new (ISO_MTU(circuit));
- else
- stream_reset (circuit->snd_stream);
+ if (listcount (list) > 0)
+ {
+ if (circuit->snd_stream == NULL)
+ circuit->snd_stream = stream_new (ISO_MTU (circuit));
+ else
+ stream_reset (circuit->snd_stream);
- if (isis->debugs & DEBUG_SNP_PACKETS)
- zlog_info ("ISIS-Snp (%s): Sent L%d PSNP on %s, length %ld",
- circuit->area->area_tag, level, circuit->interface->name,
- STREAM_SIZE(circuit->snd_stream));
+ if (isis->debugs & DEBUG_SNP_PACKETS)
+ zlog_info ("ISIS-Snp (%s): Sent L%d PSNP on %s, length %ld",
+ circuit->area->area_tag, level,
+ circuit->interface->name,
+ STREAM_SIZE (circuit->snd_stream));
- retval = build_psnp (level, circuit, list);
- if (retval == ISIS_OK)
- retval = circuit->tx (circuit, level);
+ retval = build_psnp (level, circuit, list);
+ if (retval == ISIS_OK)
+ retval = circuit->tx (circuit, level);
- if (retval == ISIS_OK) {
- /*
- * sending succeeded, we can clear SSN flags of this circuit
- * for the LSPs in list
- */
- for (node = listhead (list); node; nextnode(node)) {
- lsp = getdata (node);
- ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
- }
- }
- }
- list_delete (list);
+ if (retval == ISIS_OK)
+ {
+ /*
+ * sending succeeded, we can clear SSN flags of this circuit
+ * for the LSPs in list
+ */
+ for (node = listhead (list); node; nextnode (node))
+ {
+ lsp = getdata (node);
+ ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
+ }
+ }
+ }
+ list_delete (list);
+ }
}
- }
return retval;
}
@@ -2199,8 +2415,8 @@
send_psnp (1, circuit);
/* set next timer thread */
- THREAD_TIMER_ON(master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
- isis_jitter(circuit->psnp_interval[0], PSNP_JITTER));
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
return retval;
}
@@ -2212,7 +2428,6 @@
int
send_l2_psnp (struct thread *thread)
{
-
struct isis_circuit *circuit;
int retval = ISIS_OK;
@@ -2224,26 +2439,24 @@
send_psnp (2, circuit);
/* set next timer thread */
- THREAD_TIMER_ON(master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
- isis_jitter(circuit->psnp_interval[1], PSNP_JITTER));
+ THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
+ isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
return retval;
}
-
void
build_link_state (struct isis_lsp *lsp, struct isis_circuit *circuit,
- struct stream *stream)
+ struct stream *stream)
{
unsigned long length;
- stream_put (stream, lsp->pdu, ntohs(lsp->lsp_header->pdu_len));
- length = stream_get_putp (stream);
+ stream_put (stream, lsp->pdu, ntohs (lsp->lsp_header->pdu_len));
+ length = stream_get_putp (stream);
return;
}
-
/*
* ISO 10589 - 7.3.14.3
*/
@@ -2258,90 +2471,98 @@
circuit = THREAD_ARG (thread);
assert (circuit);
- if (circuit->state == C_STATE_UP) {
- node = listhead (circuit->lsp_queue);
- assert (node);
+ if (circuit->state == C_STATE_UP)
+ {
+ node = listhead (circuit->lsp_queue);
+ assert (node);
- lsp = getdata (node);
-
- /*
- * Do not send if levels do not match
- */
- if (!(lsp->level & circuit->circuit_is_type))
- goto dontsend;
-
- /*
- * Do not send if we do not have adjacencies in state up on the circuit
- */
- if (circuit->upadjcount[lsp->level - 1] == 0)
- goto dontsend;
- /* only send if it needs sending */
- if ((time(NULL) - lsp->last_sent) >=
- circuit->area->lsp_gen_interval[lsp->level-1]) {
-
- if (isis->debugs & DEBUG_UPDATE_PACKETS) {
- zlog_info ("ISIS-Upd (%s): Sent L%d LSP %s, seq 0x%08x, cksum 0x%04x,"
- " lifetime %us on %s",
- circuit->area->area_tag,
- lsp->level,
- rawlspid_print (lsp->lsp_header->lsp_id),
- ntohl(lsp->lsp_header->seq_num),
- ntohs(lsp->lsp_header->checksum),
- ntohs(lsp->lsp_header->rem_lifetime),
- circuit->interface->name);
- }
- /* copy our lsp to the send buffer */
- circuit->snd_stream->getp = lsp->pdu->getp;
- circuit->snd_stream->putp = lsp->pdu->putp;
- circuit->snd_stream->endp = lsp->pdu->endp;
- memcpy (circuit->snd_stream->data, lsp->pdu->data, lsp->pdu->endp);
-
- retval = circuit->tx (circuit, lsp->level);
+ lsp = getdata (node);
/*
- * If the sending succeeded, we can del the lsp from circuits lsp_queue
+ * Do not send if levels do not match
*/
- if (retval == ISIS_OK) {
- list_delete_node (circuit->lsp_queue, node);
+ if (!(lsp->level & circuit->circuit_is_type))
+ goto dontsend;
- /*
- * On broadcast circuits also the SRMflag can be cleared
- */
- if (circuit->circ_type == CIRCUIT_T_BROADCAST)
- ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+ /*
+ * Do not send if we do not have adjacencies in state up on the circuit
+ */
+ if (circuit->upadjcount[lsp->level - 1] == 0)
+ goto dontsend;
+ /* only send if it needs sending */
+ if ((time (NULL) - lsp->last_sent) >=
+ circuit->area->lsp_gen_interval[lsp->level - 1])
+ {
- if (flags_any_set (lsp->SRMflags) == 0) {
+ if (isis->debugs & DEBUG_UPDATE_PACKETS)
+ {
+ zlog_info
+ ("ISIS-Upd (%s): Sent L%d LSP %s, seq 0x%08x, cksum 0x%04x,"
+ " lifetime %us on %s", circuit->area->area_tag, lsp->level,
+ rawlspid_print (lsp->lsp_header->lsp_id),
+ ntohl (lsp->lsp_header->seq_num),
+ ntohs (lsp->lsp_header->checksum),
+ ntohs (lsp->lsp_header->rem_lifetime),
+ circuit->interface->name);
+ }
+ /* copy our lsp to the send buffer */
+ circuit->snd_stream->getp = lsp->pdu->getp;
+ circuit->snd_stream->putp = lsp->pdu->putp;
+ circuit->snd_stream->endp = lsp->pdu->endp;
+ memcpy (circuit->snd_stream->data, lsp->pdu->data, lsp->pdu->endp);
+
+ retval = circuit->tx (circuit, lsp->level);
+
/*
- * need to remember when we were last sent
+ * If the sending succeeded, we can del the lsp from circuits
+ * lsp_queue
*/
- lsp->last_sent = time (NULL);
+ if (retval == ISIS_OK)
+ {
+ list_delete_node (circuit->lsp_queue, node);
+
+ /*
+ * On broadcast circuits also the SRMflag can be cleared
+ */
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
+
+ if (flags_any_set (lsp->SRMflags) == 0)
+ {
+ /*
+ * need to remember when we were last sent
+ */
+ lsp->last_sent = time (NULL);
+ }
+ }
+ else
+ {
+ zlog_info ("sending of level %d link state failed", lsp->level);
+ }
}
- } else {
- zlog_info ("sending of level %d link state failed", lsp->level);
- }
- } else {
- /* my belief is that if it wasn't his time, the lsp can be removed
- * from the queue
- */
- dontsend:
- list_delete_node (circuit->lsp_queue, node);
- }
+ else
+ {
+ /* my belief is that if it wasn't his time, the lsp can be removed
+ * from the queue
+ */
+ dontsend:
+ list_delete_node (circuit->lsp_queue, node);
+ }
#if 0
- /*
- * If there are still LSPs send next one after lsp-interval (33 msecs)
- */
- if (listcount (circuit->lsp_queue) > 0)
- thread_add_timer (master, send_lsp, circuit,
- 1);
+ /*
+ * If there are still LSPs send next one after lsp-interval (33 msecs)
+ */
+ if (listcount (circuit->lsp_queue) > 0)
+ thread_add_timer (master, send_lsp, circuit, 1);
#endif
- }
+ }
return retval;
-}
+}
int
-ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit,
- int level)
+ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit,
+ int level)
{
unsigned long lenp;
int retval;
@@ -2349,32 +2570,32 @@
struct isis_fixed_hdr fixed_hdr;
if (!circuit->snd_stream)
- circuit->snd_stream = stream_new (ISO_MTU(circuit));
+ circuit->snd_stream = stream_new (ISO_MTU (circuit));
else
stream_reset (circuit->snd_stream);
// fill_llc_hdr (stream);
if (level == 1)
- fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
- circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
+ circuit->snd_stream);
else
- fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
- circuit->snd_stream);
+ fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
+ circuit->snd_stream);
lenp = stream_get_putp (circuit->snd_stream);
- stream_putw (circuit->snd_stream, 0); /* PDU length */
- stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
+ stream_putw (circuit->snd_stream, 0); /* PDU length */
+ stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
stream_putc (circuit->snd_stream, circuit->idx);
- stream_putc (circuit->snd_stream, 9); /* code */
- stream_putc (circuit->snd_stream, 16); /* len */
+ stream_putc (circuit->snd_stream, 9); /* code */
+ stream_putc (circuit->snd_stream, 16); /* len */
- stream_putw (circuit->snd_stream, ntohs(hdr->rem_lifetime));
- stream_put (circuit->snd_stream, hdr->lsp_id, ISIS_SYS_ID_LEN + 2);
- stream_putl (circuit->snd_stream, ntohl(hdr->seq_num));
- stream_putw (circuit->snd_stream, ntohs(hdr->checksum));
+ stream_putw (circuit->snd_stream, ntohs (hdr->rem_lifetime));
+ stream_put (circuit->snd_stream, hdr->lsp_id, ISIS_SYS_ID_LEN + 2);
+ stream_putl (circuit->snd_stream, ntohl (hdr->seq_num));
+ stream_putw (circuit->snd_stream, ntohs (hdr->checksum));
- length = (u_int16_t)stream_get_putp (circuit->snd_stream);
+ length = (u_int16_t) stream_get_putp (circuit->snd_stream);
/* Update PDU length */
stream_putw_at (circuit->snd_stream, lenp, length);
@@ -2388,67 +2609,86 @@
* ISH PDU Processing
*/
-
/*
* Let's first check if the local and remote system have any common area
* addresses
*/
- if (area_match(tlvs.area_addrs, isis->man_area_addrs) == 0) {
- if (circuit->circuit_t == IS_LEVEL_2) {
- /* do as in table 8 (p. 40) */
- switch (circuit_type) {
- case IS_LEVEL_1:
- if (adj->adj_state != ISIS_ADJ_UP) {
- /* Reject */
- zlog_warn("areaMismatch");
- retval = ISIS_WARNING;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch",
- circuit->adjdb);
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2 ||
- adj->adj_usage == ISIS_ADJ_LEVEL2) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
- circuit->adjdb);
- }
- break;
- case IS_LEVEL_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL, circuit->adjdb);
- adj->adj_usage = ISIS_ADJ_LEVEL2;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1 ||
- adj->adj_usage == ISIS_ADJ_LEVEL1AND2) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
- circuit->adjdb);
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL2) {
- ; /* Accept */
- }
- break;
- case IS_LEVEL_1_AND_2:
- if (adj->adj_state != ISIS_ADJ_UP) {
- isis_adj_state_change (adj, ISIS_ADJ_UP, NULL, circuit->adjdb);
- adj->adj_usage = ISIS_ADJ_LEVEL2;
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
- circuit->adjdb);
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2) {
- isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch",
- circuit->adjdb);
- } else if (adj->adj_usage == ISIS_ADJ_LEVEL2) {
- ; /* Accept */
- }
- break;
+if (area_match (tlvs.area_addrs, isis->man_area_addrs) == 0)
+ {
+ if (circuit->circuit_t == IS_LEVEL_2)
+ {
+ /* do as in table 8 (p. 40) */
+ switch (circuit_type)
+ {
+ case IS_LEVEL_1:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ /* Reject */
+ zlog_warn ("areaMismatch");
+ retval = ISIS_WARNING;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch",
+ circuit->adjdb);
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2 ||
+ adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
+ circuit->adjdb);
+ }
+ break;
+ case IS_LEVEL_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL,
+ circuit->adjdb);
+ adj->adj_usage = ISIS_ADJ_LEVEL2;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1 ||
+ adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
+ circuit->adjdb);
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ ; /* Accept */
+ }
+ break;
+ case IS_LEVEL_1_AND_2:
+ if (adj->adj_state != ISIS_ADJ_UP)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_UP, NULL,
+ circuit->adjdb);
+ adj->adj_usage = ISIS_ADJ_LEVEL2;
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System",
+ circuit->adjdb);
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
+ {
+ isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch",
+ circuit->adjdb);
+ }
+ else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
+ {
+ ; /* Accept */
+ }
+ break;
+ }
+ goto mismatch;
}
- goto mismatch;
- } else {
- isis_delete_adj (adj, circuit->adjdb);
- zlog_warn("areaMismatch");
- return ISIS_WARNING;
- }
+ else
+ {
+ isis_delete_adj (adj, circuit->adjdb);
+ zlog_warn ("areaMismatch");
+ return ISIS_WARNING;
+ }
}
mismatch:
#endif
-
-
-
-
diff --git a/isisd/isis_pdu.h b/isisd/isis_pdu.h
index 9940368..29c7621 100644
--- a/isisd/isis_pdu.h
+++ b/isisd/isis_pdu.h
@@ -54,7 +54,7 @@
u_char pdu_type;
u_int16_t holdtime;
u_int16_t checksum;
-} __attribute__((packed));
+} __attribute__ ((packed));
#define ESIS_FIXED_HDR_LEN 9
@@ -81,7 +81,7 @@
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
-struct isis_fixed_hdr
+struct isis_fixed_hdr
{
u_char idrp;
u_char length;
@@ -117,14 +117,15 @@
* | LAN ID | id_len + 1
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
-struct isis_lan_hello_hdr {
- u_char circuit_t;
- u_char source_id[ISIS_SYS_ID_LEN];
- u_int16_t hold_time;
- u_int16_t pdu_len;
- u_char prio;
- u_char lan_id[ISIS_SYS_ID_LEN + 1];
-} __attribute__((packed));
+struct isis_lan_hello_hdr
+{
+ u_char circuit_t;
+ u_char source_id[ISIS_SYS_ID_LEN];
+ u_int16_t hold_time;
+ u_int16_t pdu_len;
+ u_char prio;
+ u_char lan_id[ISIS_SYS_ID_LEN + 1];
+} __attribute__ ((packed));
#define ISIS_LANHELLO_HDRLEN 19
#define P2P_HELLO 17
@@ -142,13 +143,14 @@
* | Local Circuit ID | 1
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
-struct isis_p2p_hello_hdr {
- u_char circuit_t;
- u_char source_id[ISIS_SYS_ID_LEN];
- u_int16_t hold_time;
- u_int16_t pdu_len;
+struct isis_p2p_hello_hdr
+{
+ u_char circuit_t;
+ u_char source_id[ISIS_SYS_ID_LEN];
+ u_int16_t hold_time;
+ u_int16_t pdu_len;
u_char local_id;
-} __attribute__((packed));
+} __attribute__ ((packed));
#define ISIS_P2PHELLO_HDRLEN 12
#define L1_LINK_STATE 18
@@ -169,14 +171,15 @@
* | P | ATT |LSPDBOL| ISTYPE |
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
-struct isis_link_state_hdr {
- u_int16_t pdu_len;
+struct isis_link_state_hdr
+{
+ u_int16_t pdu_len;
u_int16_t rem_lifetime;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
+ u_char lsp_id[ISIS_SYS_ID_LEN + 2];
u_int32_t seq_num;
u_int16_t checksum;
- u_int8_t lsp_bits;
-} __attribute__((packed));
+ u_int8_t lsp_bits;
+} __attribute__ ((packed));
#define ISIS_LSP_HDR_LEN 19
#define L1_COMPLETE_SEQ_NUM 24
@@ -193,11 +196,12 @@
* + End LSP ID + id_len + 2
* +-------+-------+-------+-------+-------+-------+-------+-------+
*/
-struct isis_complete_seqnum_hdr {
+struct isis_complete_seqnum_hdr
+{
u_int16_t pdu_len;
- u_char source_id[ISIS_SYS_ID_LEN + 1];
- u_char start_lsp_id[ISIS_SYS_ID_LEN + 2];
- u_char stop_lsp_id[ISIS_SYS_ID_LEN + 2];
+ u_char source_id[ISIS_SYS_ID_LEN + 1];
+ u_char start_lsp_id[ISIS_SYS_ID_LEN + 2];
+ u_char stop_lsp_id[ISIS_SYS_ID_LEN + 2];
};
#define ISIS_CSNP_HDRLEN 25
@@ -211,9 +215,10 @@
* + Source ID + id_len + 1
* +---------------------------------------------------------------+
*/
-struct isis_partial_seqnum_hdr {
+struct isis_partial_seqnum_hdr
+{
u_int16_t pdu_len;
- u_char source_id[ISIS_SYS_ID_LEN + 1];
+ u_char source_id[ISIS_SYS_ID_LEN + 1];
};
#define ISIS_PSNP_HDRLEN 9
@@ -231,27 +236,22 @@
/*
* Sending functions
*/
-int send_lan_l1_hello (struct thread *thread);
-int send_lan_l2_hello (struct thread *thread);
-int send_p2p_hello (struct thread *thread);
-int send_csnp (struct isis_circuit *circuit, int level);
-int send_l1_csnp (struct thread *thread);
-int send_l2_csnp (struct thread *thread);
-int send_l1_psnp (struct thread *thread);
-int send_l2_psnp (struct thread *thread);
-int send_lsp (struct thread *thread);
-int ack_lsp (struct isis_link_state_hdr *hdr,
- struct isis_circuit *circuit, int level);
-void fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type);
-int send_hello (struct isis_circuit *circuit, int level);
+int send_lan_l1_hello (struct thread *thread);
+int send_lan_l2_hello (struct thread *thread);
+int send_p2p_hello (struct thread *thread);
+int send_csnp (struct isis_circuit *circuit, int level);
+int send_l1_csnp (struct thread *thread);
+int send_l2_csnp (struct thread *thread);
+int send_l1_psnp (struct thread *thread);
+int send_l2_psnp (struct thread *thread);
+int send_lsp (struct thread *thread);
+int ack_lsp (struct isis_link_state_hdr *hdr,
+ struct isis_circuit *circuit, int level);
+void fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type);
+int send_hello (struct isis_circuit *circuit, int level);
-int authentication_check (struct isis_passwd *one,
+int authentication_check (struct isis_passwd *one,
struct isis_passwd *theother);
#endif /* _ZEBRA_ISIS_PDU_H */
-
-
-
-
-
diff --git a/isisd/isis_route.c b/isisd/isis_route.c
index b889d3b..9080868 100644
--- a/isisd/isis_route.c
+++ b/isisd/isis_route.c
@@ -55,27 +55,28 @@
struct isis_nexthop *
isis_nexthop_create (struct in_addr *ip, unsigned int ifindex)
-
{
struct listnode *node;
struct isis_nexthop *nexthop;
-
- for (node = listhead (isis->nexthops); node; nextnode (node)) {
- nexthop = getdata (node);
- if (nexthop->ifindex != ifindex)
- continue;
- if (ip && memcmp (&nexthop->ip, ip, sizeof (struct in_addr)) != 0)
- continue;
- nexthop->lock++;
- return nexthop;
- }
-
+ for (node = listhead (isis->nexthops); node; nextnode (node))
+ {
+ nexthop = getdata (node);
+ if (nexthop->ifindex != ifindex)
+ continue;
+ if (ip && memcmp (&nexthop->ip, ip, sizeof (struct in_addr)) != 0)
+ continue;
+
+ nexthop->lock++;
+ return nexthop;
+ }
+
nexthop = XMALLOC (MTYPE_ISIS_NEXTHOP, sizeof (struct isis_nexthop));
- if (!nexthop) {
- zlog_err ("ISIS-Rte: isis_nexthop_create: out of memory!");
- }
-
+ if (!nexthop)
+ {
+ zlog_err ("ISIS-Rte: isis_nexthop_create: out of memory!");
+ }
+
memset (nexthop, 0, sizeof (struct isis_nexthop));
nexthop->ifindex = ifindex;
memcpy (&nexthop->ip, ip, sizeof (struct in_addr));
@@ -85,32 +86,33 @@
return nexthop;
}
-
void
isis_nexthop_delete (struct isis_nexthop *nexthop)
{
nexthop->lock--;
- if (nexthop->lock == 0) {
- listnode_delete (isis->nexthops, nexthop);
- XFREE (MTYPE_ISIS_NEXTHOP, nexthop);
- }
-
+ if (nexthop->lock == 0)
+ {
+ listnode_delete (isis->nexthops, nexthop);
+ XFREE (MTYPE_ISIS_NEXTHOP, nexthop);
+ }
+
return;
}
int
-nexthoplookup (struct list *nexthops, struct in_addr *ip,
- unsigned int ifindex)
+nexthoplookup (struct list *nexthops, struct in_addr *ip,
+ unsigned int ifindex)
{
struct listnode *node;
struct isis_nexthop *nh;
- for (node = listhead (nexthops); node; nextnode (node)) {
- nh = getdata (node);
- if (!(memcmp (ip, &nh->ip, sizeof (struct in_addr))) &&
- ifindex == nh->ifindex)
- return 1;
- }
+ for (node = listhead (nexthops); node; nextnode (node))
+ {
+ nh = getdata (node);
+ if (!(memcmp (ip, &nh->ip, sizeof (struct in_addr))) &&
+ ifindex == nh->ifindex)
+ return 1;
+ }
return 0;
}
@@ -119,9 +121,9 @@
nexthop_print (struct isis_nexthop *nh)
{
u_char buf[BUFSIZ];
-
+
inet_ntop (AF_INET, &nh->ip, buf, BUFSIZ);
-
+
zlog_info (" %s %u", buf, nh->ifindex);
}
@@ -129,24 +131,25 @@
nexthops_print (struct list *nhs)
{
struct listnode *node;
-
- for (node = listhead(nhs); node; nextnode (node))
+
+ for (node = listhead (nhs); node; nextnode (node))
nexthop_print (getdata (node));
}
#ifdef HAVE_IPV6
struct isis_nexthop6 *
-isis_nexthop6_new (struct in6_addr *ip6, unsigned int ifindex)
+isis_nexthop6_new (struct in6_addr *ip6, unsigned int ifindex)
{
-
+
struct isis_nexthop6 *nexthop6;
-
+
nexthop6 = XMALLOC (MTYPE_ISIS_NEXTHOP6, sizeof (struct isis_nexthop6));
- if (!nexthop6) {
- zlog_err ("ISIS-Rte: isis_nexthop_create6: out of memory!");
- }
-
+ if (!nexthop6)
+ {
+ zlog_err ("ISIS-Rte: isis_nexthop_create6: out of memory!");
+ }
+
memset (nexthop6, 0, sizeof (struct isis_nexthop6));
nexthop6->ifindex = ifindex;
memcpy (&nexthop6->ip6, ip6, sizeof (struct in6_addr));
@@ -157,54 +160,55 @@
struct isis_nexthop6 *
isis_nexthop6_create (struct in6_addr *ip6, unsigned int ifindex)
-
{
struct listnode *node;
struct isis_nexthop6 *nexthop6;
-
- for (node = listhead (isis->nexthops6); node; nextnode (node)) {
- nexthop6 = getdata (node);
- if (nexthop6->ifindex != ifindex)
- continue;
- if (ip6 && memcmp (&nexthop6->ip6, ip6, sizeof (struct in6_addr)) != 0)
- continue;
- nexthop6->lock++;
- return nexthop6;
- }
-
+ for (node = listhead (isis->nexthops6); node; nextnode (node))
+ {
+ nexthop6 = getdata (node);
+ if (nexthop6->ifindex != ifindex)
+ continue;
+ if (ip6 && memcmp (&nexthop6->ip6, ip6, sizeof (struct in6_addr)) != 0)
+ continue;
+
+ nexthop6->lock++;
+ return nexthop6;
+ }
+
nexthop6 = isis_nexthop6_new (ip6, ifindex);
return nexthop6;
}
-
void
isis_nexthop6_delete (struct isis_nexthop6 *nexthop6)
{
nexthop6->lock--;
- if (nexthop6->lock == 0) {
- listnode_delete (isis->nexthops6, nexthop6);
- XFREE (MTYPE_ISIS_NEXTHOP6, nexthop6);
- }
-
+ if (nexthop6->lock == 0)
+ {
+ listnode_delete (isis->nexthops6, nexthop6);
+ XFREE (MTYPE_ISIS_NEXTHOP6, nexthop6);
+ }
+
return;
}
int
-nexthop6lookup (struct list *nexthops6, struct in6_addr *ip6,
- unsigned int ifindex)
+nexthop6lookup (struct list *nexthops6, struct in6_addr *ip6,
+ unsigned int ifindex)
{
struct listnode *node;
struct isis_nexthop6 *nh6;
- for (node = listhead (nexthops6); node; nextnode (node)) {
- nh6 = getdata (node);
- if (!(memcmp (ip6, &nh6->ip6, sizeof (struct in6_addr))) &&
- ifindex == nh6->ifindex)
- return 1;
- }
+ for (node = listhead (nexthops6); node; nextnode (node))
+ {
+ nh6 = getdata (node);
+ if (!(memcmp (ip6, &nh6->ip6, sizeof (struct in6_addr))) &&
+ ifindex == nh6->ifindex)
+ return 1;
+ }
return 0;
}
@@ -213,9 +217,9 @@
nexthop6_print (struct isis_nexthop6 *nh6)
{
u_char buf[BUFSIZ];
-
+
inet_ntop (AF_INET6, &nh6->ip6, buf, BUFSIZ);
-
+
zlog_info (" %s %u", buf, nh6->ifindex);
}
@@ -223,8 +227,8 @@
nexthops6_print (struct list *nhs6)
{
struct listnode *node;
-
- for (node = listhead(nhs6); node; nextnode (node))
+
+ for (node = listhead (nhs6); node; nextnode (node))
nexthop6_print (getdata (node));
}
@@ -240,15 +244,17 @@
if (adj->ipv4_addrs == NULL)
return;
- for (node = listhead (adj->ipv4_addrs); node; nextnode (node)) {
- ipv4_addr = getdata (node);
- if (!nexthoplookup (nexthops, ipv4_addr,
- adj->circuit->interface->ifindex)) {
- nh = isis_nexthop_create (ipv4_addr,
- adj->circuit->interface->ifindex);
- listnode_add (nexthops, nh);
+ for (node = listhead (adj->ipv4_addrs); node; nextnode (node))
+ {
+ ipv4_addr = getdata (node);
+ if (!nexthoplookup (nexthops, ipv4_addr,
+ adj->circuit->interface->ifindex))
+ {
+ nh = isis_nexthop_create (ipv4_addr,
+ adj->circuit->interface->ifindex);
+ listnode_add (nexthops, nh);
+ }
}
- }
}
#ifdef HAVE_IPV6
@@ -258,156 +264,170 @@
struct listnode *node;
struct in6_addr *ipv6_addr;
struct isis_nexthop6 *nh6;
-
+
if (!adj->ipv6_addrs)
return;
- for (node = listhead (adj->ipv6_addrs); node; nextnode (node)) {
- ipv6_addr = getdata (node);
- if (!nexthop6lookup (nexthops6, ipv6_addr,
- adj->circuit->interface->ifindex)) {
- nh6 = isis_nexthop6_create (ipv6_addr,
- adj->circuit->interface->ifindex);
- listnode_add (nexthops6, nh6);
+ for (node = listhead (adj->ipv6_addrs); node; nextnode (node))
+ {
+ ipv6_addr = getdata (node);
+ if (!nexthop6lookup (nexthops6, ipv6_addr,
+ adj->circuit->interface->ifindex))
+ {
+ nh6 = isis_nexthop6_create (ipv6_addr,
+ adj->circuit->interface->ifindex);
+ listnode_add (nexthops6, nh6);
+ }
}
- }
}
#endif /* HAVE_IPV6 */
struct isis_route_info *
-isis_route_info_new (uint32_t cost, uint32_t depth, u_char family,
- struct list *adjacencies)
+isis_route_info_new (uint32_t cost, uint32_t depth, u_char family,
+ struct list *adjacencies)
{
struct isis_route_info *rinfo;
struct isis_adjacency *adj;
struct listnode *node;
-
+
rinfo = XMALLOC (MTYPE_ISIS_ROUTE_INFO, sizeof (struct isis_route_info));
- if (!rinfo) {
- zlog_err ("ISIS-Rte: isis_route_info_new: out of memory!");
- return NULL;
- }
+ if (!rinfo)
+ {
+ zlog_err ("ISIS-Rte: isis_route_info_new: out of memory!");
+ return NULL;
+ }
memset (rinfo, 0, sizeof (struct isis_route_info));
- if (family == AF_INET) {
- rinfo->nexthops = list_new ();
- for (node = listhead (adjacencies); node; nextnode (node)) {
- adj = getdata (node);
- adjinfo2nexthop (rinfo->nexthops, adj);
+ if (family == AF_INET)
+ {
+ rinfo->nexthops = list_new ();
+ for (node = listhead (adjacencies); node; nextnode (node))
+ {
+ adj = getdata (node);
+ adjinfo2nexthop (rinfo->nexthops, adj);
+ }
}
- }
#ifdef HAVE_IPV6
- if (family == AF_INET6) {
- rinfo->nexthops6 = list_new ();
- for (node = listhead (adjacencies); node; nextnode (node)) {
- adj =getdata (node);
- adjinfo2nexthop6 (rinfo->nexthops6, adj);
+ if (family == AF_INET6)
+ {
+ rinfo->nexthops6 = list_new ();
+ for (node = listhead (adjacencies); node; nextnode (node))
+ {
+ adj = getdata (node);
+ adjinfo2nexthop6 (rinfo->nexthops6, adj);
+ }
}
- }
-
+
#endif /* HAVE_IPV6 */
rinfo->cost = cost;
rinfo->depth = depth;
-
+
return rinfo;
}
-
void
isis_route_info_delete (struct isis_route_info *route_info)
{
-
- if (route_info->nexthops) {
- route_info->nexthops->del = (void *)isis_nexthop_delete;
- list_delete (route_info->nexthops);
- }
-
+ if (route_info->nexthops)
+ {
+ route_info->nexthops->del = (void *) isis_nexthop_delete;
+ list_delete (route_info->nexthops);
+ }
+
#ifdef HAVE_IPV6
- if (route_info->nexthops6) {
- route_info->nexthops6->del = (void *)isis_nexthop6_delete;
+ if (route_info->nexthops6)
+ {
+ route_info->nexthops6->del = (void *) isis_nexthop6_delete;
list_delete (route_info->nexthops6);
- }
+ }
#endif /* HAVE_IPV6 */
-
+
XFREE (MTYPE_ISIS_ROUTE_INFO, route_info);
}
int
-isis_route_info_same_attrib (struct isis_route_info *new,
- struct isis_route_info *old)
+isis_route_info_same_attrib (struct isis_route_info *new,
+ struct isis_route_info *old)
{
if (new->cost != old->cost)
return 0;
if (new->depth != old->depth)
return 0;
-
+
return 1;
}
int
-isis_route_info_same (struct isis_route_info *new, struct isis_route_info *old,
- u_char family)
+isis_route_info_same (struct isis_route_info *new,
+ struct isis_route_info *old, u_char family)
{
- struct listnode *node;
+ struct listnode *node;
struct isis_nexthop *nexthop;
#ifdef HAVE_IPV6
struct isis_nexthop6 *nexthop6;
#endif /* HAVE_IPV6 */
if (!isis_route_info_same_attrib (new, old))
return 0;
-
- if (family == AF_INET) {
- for (node = listhead (new->nexthops); node; nextnode (node)) {
- nexthop = (struct isis_nexthop *) getdata (node);
- if (nexthoplookup (old->nexthops, &nexthop->ip, nexthop->ifindex) == 0)
- return 0;
+
+ if (family == AF_INET)
+ {
+ for (node = listhead (new->nexthops); node; nextnode (node))
+ {
+ nexthop = (struct isis_nexthop *) getdata (node);
+ if (nexthoplookup (old->nexthops, &nexthop->ip, nexthop->ifindex) ==
+ 0)
+ return 0;
+ }
+
+ for (node = listhead (old->nexthops); node; nextnode (node))
+ {
+ nexthop = (struct isis_nexthop *) getdata (node);
+ if (nexthoplookup (new->nexthops, &nexthop->ip, nexthop->ifindex) ==
+ 0)
+ return 0;
+ }
}
-
- for (node = listhead (old->nexthops); node; nextnode (node)) {
- nexthop = (struct isis_nexthop *) getdata (node);
- if (nexthoplookup (new->nexthops, &nexthop->ip, nexthop->ifindex) == 0)
- return 0;
- }
- }
#ifdef HAVE_IPV6
- else if (family == AF_INET6) {
- for (node = listhead (new->nexthops6); node; nextnode (node)) {
- nexthop6 = (struct isis_nexthop6 *) getdata (node);
- if (nexthop6lookup (old->nexthops6, &nexthop6->ip6,
- nexthop6->ifindex) == 0)
- return 0;
+ else if (family == AF_INET6)
+ {
+ for (node = listhead (new->nexthops6); node; nextnode (node))
+ {
+ nexthop6 = (struct isis_nexthop6 *) getdata (node);
+ if (nexthop6lookup (old->nexthops6, &nexthop6->ip6,
+ nexthop6->ifindex) == 0)
+ return 0;
+ }
+
+ for (node = listhead (old->nexthops6); node; nextnode (node))
+ {
+ nexthop6 = (struct isis_nexthop6 *) getdata (node);
+ if (nexthop6lookup (new->nexthops6, &nexthop6->ip6,
+ nexthop6->ifindex) == 0)
+ return 0;
+ }
}
-
- for (node = listhead (old->nexthops6); node; nextnode (node)) {
- nexthop6 = (struct isis_nexthop6 *) getdata (node);
- if (nexthop6lookup (new->nexthops6, &nexthop6->ip6,
- nexthop6->ifindex) == 0)
- return 0;
- }
- }
#endif /* HAVE_IPV6 */
return 1;
}
-
void
isis_nexthops_merge (struct list *new, struct list *old)
{
struct listnode *node;
struct isis_nexthop *nexthop;
- for (node = listhead (new); node; nextnode (node)) {
- nexthop = (struct isis_nexthop *) getdata (node);
- if (nexthoplookup (old, &nexthop->ip, nexthop->ifindex))
- continue;
- listnode_add (old, nexthop);
- nexthop->lock++;
- }
+ for (node = listhead (new); node; nextnode (node))
+ {
+ nexthop = (struct isis_nexthop *) getdata (node);
+ if (nexthoplookup (old, &nexthop->ip, nexthop->ifindex))
+ continue;
+ listnode_add (old, nexthop);
+ nexthop->lock++;
+ }
}
-
#ifdef HAVE_IPV6
void
isis_nexthops6_merge (struct list *new, struct list *old)
@@ -415,123 +435,133 @@
struct listnode *node;
struct isis_nexthop6 *nexthop6;
- for (node = listhead (new); node; nextnode (node)) {
- nexthop6 = (struct isis_nexthop6 *) getdata (node);
- if (nexthop6lookup (old, &nexthop6->ip6, nexthop6->ifindex))
- continue;
- listnode_add (old, nexthop6);
- nexthop6->lock++;
- }
+ for (node = listhead (new); node; nextnode (node))
+ {
+ nexthop6 = (struct isis_nexthop6 *) getdata (node);
+ if (nexthop6lookup (old, &nexthop6->ip6, nexthop6->ifindex))
+ continue;
+ listnode_add (old, nexthop6);
+ nexthop6->lock++;
+ }
}
#endif /* HAVE_IPV6 */
void
-isis_route_info_merge (struct isis_route_info *new,
- struct isis_route_info *old, u_char family)
+isis_route_info_merge (struct isis_route_info *new,
+ struct isis_route_info *old, u_char family)
{
-
- if (family == AF_INET)
+ if (family == AF_INET)
isis_nexthops_merge (new->nexthops, old->nexthops);
#ifdef HAVE_IPV6
- else if (family == AF_INET6)
+ else if (family == AF_INET6)
isis_nexthops6_merge (new->nexthops6, old->nexthops6);
#endif /* HAVE_IPV6 */
-
+
return;
}
-
int
-isis_route_info_prefer_new (struct isis_route_info *new,
- struct isis_route_info *old)
+isis_route_info_prefer_new (struct isis_route_info *new,
+ struct isis_route_info *old)
{
-
if (!CHECK_FLAG (old->flag, ISIS_ROUTE_FLAG_ACTIVE))
return 1;
if (new->cost < old->cost)
return 1;
-
+
return 0;
}
-
struct isis_route_info *
isis_route_create (struct prefix *prefix, u_int32_t cost, u_int32_t depth,
- struct list *adjacencies, struct isis_area *area)
+ struct list *adjacencies, struct isis_area *area)
{
struct route_node *route_node;
struct isis_route_info *rinfo_new, *rinfo_old, *route_info = NULL;
u_char buff[BUFSIZ];
u_char family;
-
+
family = prefix->family;
/* for debugs */
prefix2str (prefix, buff, BUFSIZ);
-
+
rinfo_new = isis_route_info_new (cost, depth, family, adjacencies);
- if (!rinfo_new) {
- zlog_err ("ISIS-Rte (%s): isis_route_create: out of memory!",
- area->area_tag);
- return NULL;
- }
-
+ if (!rinfo_new)
+ {
+ zlog_err ("ISIS-Rte (%s): isis_route_create: out of memory!",
+ area->area_tag);
+ return NULL;
+ }
+
if (family == AF_INET)
- route_node = route_node_get (area->route_table, prefix);
+ route_node = route_node_get (area->route_table, prefix);
#ifdef HAVE_IPV6
else if (family == AF_INET6)
- route_node = route_node_get (area->route_table6, prefix);
+ route_node = route_node_get (area->route_table6, prefix);
#endif /* HAVE_IPV6 */
- else
+ else
return NULL;
- rinfo_old = route_node->info;
- if (!rinfo_old) {
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route created: %s", area->area_tag, buff);
- SET_FLAG(rinfo_new->flag, ISIS_ROUTE_FLAG_ACTIVE);
- route_node->info = rinfo_new;
- return rinfo_new;
- }
-
+ rinfo_old = route_node->info;
+ if (!rinfo_old)
+ {
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte (%s) route created: %s", area->area_tag, buff);
+ SET_FLAG (rinfo_new->flag, ISIS_ROUTE_FLAG_ACTIVE);
+ route_node->info = rinfo_new;
+ return rinfo_new;
+ }
+
if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route already exists: %s", area->area_tag, buff);
-
- if (isis_route_info_same (rinfo_new, rinfo_old, family)) {
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route unchanged: %s", area->area_tag, buff);
- isis_route_info_delete (rinfo_new);
- route_info = rinfo_old;
- } else if (isis_route_info_same_attrib (rinfo_new, rinfo_old)) {
- /* merge the nexthop lists */
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route changed (same attribs): %s",
- area->area_tag, buff);
-#ifdef EXTREME_DEBUG
- zlog_info ("Old nexthops");
- nexthops6_print (rinfo_old->nexthops6);
- zlog_info ("New nexthops");
- nexthops6_print (rinfo_new->nexthops6);
-#endif /* EXTREME_DEBUG */
- isis_route_info_merge (rinfo_new, rinfo_old, family);
- isis_route_info_delete (rinfo_new);
- route_info = rinfo_old;
- } else {
- if (isis_route_info_prefer_new (rinfo_new, rinfo_old)) {
+ zlog_info ("ISIS-Rte (%s) route already exists: %s", area->area_tag,
+ buff);
+
+ if (isis_route_info_same (rinfo_new, rinfo_old, family))
+ {
if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route changed: %s", area->area_tag, buff);
- isis_route_info_delete (rinfo_old);
- route_info = rinfo_new;
- } else {
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte (%s) route rejected: %s", area->area_tag, buff);
+ zlog_info ("ISIS-Rte (%s) route unchanged: %s", area->area_tag, buff);
isis_route_info_delete (rinfo_new);
route_info = rinfo_old;
}
- }
-
+ else if (isis_route_info_same_attrib (rinfo_new, rinfo_old))
+ {
+ /* merge the nexthop lists */
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte (%s) route changed (same attribs): %s",
+ area->area_tag, buff);
+#ifdef EXTREME_DEBUG
+ zlog_info ("Old nexthops");
+ nexthops6_print (rinfo_old->nexthops6);
+ zlog_info ("New nexthops");
+ nexthops6_print (rinfo_new->nexthops6);
+#endif /* EXTREME_DEBUG */
+ isis_route_info_merge (rinfo_new, rinfo_old, family);
+ isis_route_info_delete (rinfo_new);
+ route_info = rinfo_old;
+ }
+ else
+ {
+ if (isis_route_info_prefer_new (rinfo_new, rinfo_old))
+ {
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte (%s) route changed: %s", area->area_tag,
+ buff);
+ isis_route_info_delete (rinfo_old);
+ route_info = rinfo_new;
+ }
+ else
+ {
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte (%s) route rejected: %s", area->area_tag,
+ buff);
+ isis_route_info_delete (rinfo_new);
+ route_info = rinfo_old;
+ }
+ }
+
SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ACTIVE);
route_node->info = route_info;
-
+
return route_info;
}
@@ -549,21 +579,23 @@
rode = route_node_get (table, prefix);
rinfo = rode->info;
- if (rinfo == NULL) {
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte: tried to delete non-existant route %s", buff);
- return;
- }
+ if (rinfo == NULL)
+ {
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte: tried to delete non-existant route %s", buff);
+ return;
+ }
- if (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC)) {
- UNSET_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE);
- if (isis->debugs & DEBUG_RTE_EVENTS)
- zlog_info ("ISIS-Rte: route delete %s", buff);
- isis_zebra_route_update (prefix, rinfo);
- }
+ if (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
+ {
+ UNSET_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE);
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ zlog_info ("ISIS-Rte: route delete %s", buff);
+ isis_zebra_route_update (prefix, rinfo);
+ }
isis_route_info_delete (rinfo);
rode->info = NULL;
-
+
return;
}
@@ -581,27 +613,29 @@
area = THREAD_ARG (thread);
table = area->route_table;
#ifdef HAVE_IPV6
- again:
+again:
#endif
- for (rode = route_top (table); rode; rode = route_next (rode)) {
- if (rode->info == NULL)
- continue;
- rinfo = rode->info;
-
- if (isis->debugs & DEBUG_RTE_EVENTS) {
- prefix2str (&rode->p, buff, BUFSIZ);
- zlog_info ("ISIS-Rte (%s): route validate: %s %s %s",
- area->area_tag,
- (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC) ?
- "sync'ed": "nosync"),
- (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE) ?
- "active": "inactive"), buff);
+ for (rode = route_top (table); rode; rode = route_next (rode))
+ {
+ if (rode->info == NULL)
+ continue;
+ rinfo = rode->info;
+
+ if (isis->debugs & DEBUG_RTE_EVENTS)
+ {
+ prefix2str (&rode->p, buff, BUFSIZ);
+ zlog_info ("ISIS-Rte (%s): route validate: %s %s %s",
+ area->area_tag,
+ (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC) ?
+ "sync'ed" : "nosync"),
+ (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE) ?
+ "active" : "inactive"), buff);
+ }
+
+ isis_zebra_route_update (&rode->p, rinfo);
+ if (!CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE))
+ isis_route_delete (&rode->p, area->route_table);
}
-
- isis_zebra_route_update (&rode->p, rinfo);
- if (!CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE))
- isis_route_delete (&rode->p, area->route_table);
- }
#ifdef HAVE_IPV6
if (v6done)
return ISIS_OK;
diff --git a/isisd/isis_route.h b/isisd/isis_route.h
index 7137948..59b6c22 100644
--- a/isisd/isis_route.h
+++ b/isisd/isis_route.h
@@ -26,35 +26,38 @@
#define _ZEBRA_ISIS_ROUTE_H
#ifdef HAVE_IPV6
-struct isis_nexthop6 {
+struct isis_nexthop6
+{
unsigned int ifindex;
struct in6_addr ip6;
unsigned int lock;
};
#endif /* HAVE_IPV6 */
-struct isis_nexthop {
+struct isis_nexthop
+{
unsigned int ifindex;
struct in_addr ip;
unsigned int lock;
};
-struct isis_route_info {
+struct isis_route_info
+{
#define ISIS_ROUTE_FLAG_ZEBRA_SYNC 0x01
#define ISIS_ROUTE_FLAG_ACTIVE 0x02
- u_char flag;
+ u_char flag;
u_int32_t cost;
u_int32_t depth;
struct list *nexthops;
#ifdef HAVE_IPV6
struct list *nexthops6;
-#endif /* HAVE_IPV6 */
+#endif /* HAVE_IPV6 */
};
-struct isis_route_info *isis_route_create (struct prefix *prefix,
- u_int32_t cost, u_int32_t depth,
- struct list *adjacencies,
- struct isis_area *area);
+struct isis_route_info *isis_route_create (struct prefix *prefix,
+ u_int32_t cost, u_int32_t depth,
+ struct list *adjacencies,
+ struct isis_area *area);
int isis_route_validate (struct thread *thread);
diff --git a/isisd/isis_routemap.c b/isisd/isis_routemap.c
index 9a8df61..56e44b8 100644
--- a/isisd/isis_routemap.c
+++ b/isisd/isis_routemap.c
@@ -52,48 +52,49 @@
extern struct isis *isis;
void
-isis_route_map_upd()
+isis_route_map_upd ()
{
int i = 0;
-
+
if (!isis)
return;
-
- for (i = 0; i <= ZEBRA_ROUTE_MAX; i++) {
- if (isis->rmap[i].name)
- isis->rmap[i].map = isis->rmap[i].map =
- route_map_lookup_by_name (isis->rmap[i].name);
- else
- isis->rmap[i].map = NULL;
- }
+
+ for (i = 0; i <= ZEBRA_ROUTE_MAX; i++)
+ {
+ if (isis->rmap[i].name)
+ isis->rmap[i].map = isis->rmap[i].map =
+ route_map_lookup_by_name (isis->rmap[i].name);
+ else
+ isis->rmap[i].map = NULL;
+ }
/* FIXME: do the address family sub-mode AF_INET6 here ? */
}
void
-isis_route_map_event(route_map_event_t event, char *name)
+isis_route_map_event (route_map_event_t event, char *name)
{
int type;
if (!isis)
return;
- for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
- if (isis->rmap[type].name && isis->rmap[type].map &&
- !strcmp (isis->rmap[type].name, name)) {
- isis_distribute_list_update (type);
+ for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
+ {
+ if (isis->rmap[type].name && isis->rmap[type].map &&
+ !strcmp (isis->rmap[type].name, name))
+ {
+ isis_distribute_list_update (type);
+ }
}
- }
}
-
void
isis_route_map_init (void)
{
route_map_init ();
route_map_init_vty ();
-
+
route_map_add_hook (isis_route_map_upd);
route_map_delete_hook (isis_route_map_upd);
route_map_event_hook (isis_route_map_event);
-
}
diff --git a/isisd/isis_spf.c b/isisd/isis_spf.c
index 1e414c6..bd79659 100644
--- a/isisd/isis_spf.c
+++ b/isisd/isis_spf.c
@@ -60,73 +60,81 @@
/* performace issue ???? */
void
-union_adjlist( struct list *target, struct list *source )
+union_adjlist (struct list *target, struct list *source)
{
struct isis_adjacency *adj, *adj2;
struct listnode *node, *node2;
-
+
zlog_info ("Union adjlist!");
- for (node = listhead (source); node; nextnode (node)) {
- adj = getdata (node);
-
- /* lookup adjacency in the source list */
- for (node2 = listhead (target); node2; nextnode (node2)) {
- adj2 = getdata(node2);
- if (adj == adj2) break;
+ for (node = listhead (source); node; nextnode (node))
+ {
+ adj = getdata (node);
+
+ /* lookup adjacency in the source list */
+ for (node2 = listhead (target); node2; nextnode (node2))
+ {
+ adj2 = getdata (node2);
+ if (adj == adj2)
+ break;
+ }
+
+ if (!node2)
+ listnode_add (target, adj);
}
-
- if (!node2) listnode_add (target, adj);
- }
}
-
/* 7.2.7 */
-void
+void
remove_excess_adjs (struct list *adjs)
{
struct listnode *node, *excess = NULL;
struct isis_adjacency *adj, *candidate = NULL;
int comp;
- for (node = listhead (adjs); node; nextnode (node)) {
- if (excess == NULL)
- excess = node;
- candidate = getdata (excess);
- adj = getdata (node);
- if (candidate->sys_type < adj->sys_type) {
- excess = node;
- candidate = adj;
- continue;
- }
- if (candidate->sys_type > adj->sys_type)
- continue;
-
- comp = memcmp (candidate->sysid, adj->sysid, ISIS_SYS_ID_LEN);
- if (comp > 0) {
- excess = node;
- candidate = adj;
- continue;
- }
- if (comp < 0)
- continue;
-
- if (candidate->circuit->circuit_id > adj->circuit->circuit_id) {
- excess = node;
- candidate = adj;
- continue;
+ for (node = listhead (adjs); node; nextnode (node))
+ {
+ if (excess == NULL)
+ excess = node;
+ candidate = getdata (excess);
+ adj = getdata (node);
+ if (candidate->sys_type < adj->sys_type)
+ {
+ excess = node;
+ candidate = adj;
+ continue;
+ }
+ if (candidate->sys_type > adj->sys_type)
+ continue;
+
+ comp = memcmp (candidate->sysid, adj->sysid, ISIS_SYS_ID_LEN);
+ if (comp > 0)
+ {
+ excess = node;
+ candidate = adj;
+ continue;
+ }
+ if (comp < 0)
+ continue;
+
+ if (candidate->circuit->circuit_id > adj->circuit->circuit_id)
+ {
+ excess = node;
+ candidate = adj;
+ continue;
+ }
+
+ if (candidate->circuit->circuit_id < adj->circuit->circuit_id)
+ continue;
+
+ comp = memcmp (candidate->snpa, adj->snpa, ETH_ALEN);
+ if (comp > 0)
+ {
+ excess = node;
+ candidate = adj;
+ continue;
+ }
}
- if (candidate->circuit->circuit_id < adj->circuit->circuit_id)
- continue;
-
- comp = memcmp (candidate->snpa, adj->snpa, ETH_ALEN);
- if (comp > 0) {
- excess = node;
- candidate = adj;
- continue;
- }
- }
-
list_delete_node (adjs, excess);
return;
@@ -135,59 +143,61 @@
const char *
vtype2string (enum vertextype vtype)
{
- switch (vtype) {
- case VTYPE_PSEUDO_IS:
- return "pseudo_IS";
- break;
- case VTYPE_NONPSEUDO_IS:
- return "IS";
- break;
- case VTYPE_ES:
- return "ES";
- break;
- case VTYPE_IPREACH_INTERNAL:
- return "IP internal";
- break;
- case VTYPE_IPREACH_EXTERNAL:
- return "IP external";
- break;
+ switch (vtype)
+ {
+ case VTYPE_PSEUDO_IS:
+ return "pseudo_IS";
+ break;
+ case VTYPE_NONPSEUDO_IS:
+ return "IS";
+ break;
+ case VTYPE_ES:
+ return "ES";
+ break;
+ case VTYPE_IPREACH_INTERNAL:
+ return "IP internal";
+ break;
+ case VTYPE_IPREACH_EXTERNAL:
+ return "IP external";
+ break;
#ifdef HAVE_IPV6
- case VTYPE_IP6REACH_INTERNAL:
- return "IP6 internal";
- break;
- case VTYPE_IP6REACH_EXTERNAL:
- return "IP6 external";
- break;
-#endif /* HAVE_IPV6 */
- default:
- return "UNKNOWN";
- }
- return NULL; /* Not reached */
+ case VTYPE_IP6REACH_INTERNAL:
+ return "IP6 internal";
+ break;
+ case VTYPE_IP6REACH_EXTERNAL:
+ return "IP6 external";
+ break;
+#endif /* HAVE_IPV6 */
+ default:
+ return "UNKNOWN";
+ }
+ return NULL; /* Not reached */
}
char *
-vid2string (struct isis_vertex *vertex, u_char *buff)
+vid2string (struct isis_vertex *vertex, u_char * buff)
{
- switch (vertex->type) {
- case VTYPE_PSEUDO_IS:
- return rawlspid_print (vertex->N.id);
- break;
- case VTYPE_NONPSEUDO_IS:
- case VTYPE_ES:
- return sysid_print (vertex->N.id);
- break;
- case VTYPE_IPREACH_INTERNAL:
- case VTYPE_IPREACH_EXTERNAL:
+ switch (vertex->type)
+ {
+ case VTYPE_PSEUDO_IS:
+ return rawlspid_print (vertex->N.id);
+ break;
+ case VTYPE_NONPSEUDO_IS:
+ case VTYPE_ES:
+ return sysid_print (vertex->N.id);
+ break;
+ case VTYPE_IPREACH_INTERNAL:
+ case VTYPE_IPREACH_EXTERNAL:
#ifdef HAVE_IPV6
- case VTYPE_IP6REACH_INTERNAL:
- case VTYPE_IP6REACH_EXTERNAL:
-#endif /* HAVE_IPV6 */
- prefix2str ((struct prefix *)&vertex->N.prefix, buff, BUFSIZ);
- break;
- default:
- return "UNKNOWN";
- }
-
+ case VTYPE_IP6REACH_INTERNAL:
+ case VTYPE_IP6REACH_EXTERNAL:
+#endif /* HAVE_IPV6 */
+ prefix2str ((struct prefix *) &vertex->N.prefix, buff, BUFSIZ);
+ break;
+ default:
+ return "UNKNOWN";
+ }
+
return buff;
}
@@ -197,36 +207,35 @@
struct isis_spftree *tree;
tree = XMALLOC (MTYPE_ISIS_SPFTREE, sizeof (struct isis_spftree));
- if (tree == NULL) {
- zlog_err ("ISIS-Spf: isis_spftree_new Out of memory!");
- return NULL;
- }
+ if (tree == NULL)
+ {
+ zlog_err ("ISIS-Spf: isis_spftree_new Out of memory!");
+ return NULL;
+ }
memset (tree, 0, sizeof (struct isis_spftree));
tree->tents = list_new ();
- tree->paths = list_new ();
+ tree->paths = list_new ();
return tree;
}
void
isis_vertex_del (struct isis_vertex *vertex)
{
-
list_delete (vertex->Adj_N);
XFREE (MTYPE_ISIS_VERTEX, vertex);
-
+
return;
}
void
isis_spftree_del (struct isis_spftree *spftree)
{
-
- spftree->tents->del = (void *)isis_vertex_del;
+ spftree->tents->del = (void *) isis_vertex_del;
list_delete (spftree->tents);
-
- spftree->paths->del = (void *)isis_vertex_del;
+
+ spftree->paths->del = (void *) isis_vertex_del;
list_delete (spftree->paths);
XFREE (MTYPE_ISIS_SPFTREE, spftree);
@@ -234,28 +243,29 @@
return;
}
-void
+void
spftree_area_init (struct isis_area *area)
{
-
- if ((area->is_type & IS_LEVEL_1) && area->spftree[0] == NULL) {
- area->spftree[0] = isis_spftree_new ();
+ if ((area->is_type & IS_LEVEL_1) && area->spftree[0] == NULL)
+ {
+ area->spftree[0] = isis_spftree_new ();
#ifdef HAVE_IPV6
- area->spftree6[0] = isis_spftree_new ();
+ area->spftree6[0] = isis_spftree_new ();
#endif
- /* thread_add_timer (master, isis_run_spf_l1, area,
- isis_jitter (PERIODIC_SPF_INTERVAL, 10)); */
- }
-
- if ((area->is_type & IS_LEVEL_2) && area->spftree[1] == NULL) {
- area->spftree[1] = isis_spftree_new ();
+ /* thread_add_timer (master, isis_run_spf_l1, area,
+ isis_jitter (PERIODIC_SPF_INTERVAL, 10)); */
+ }
+
+ if ((area->is_type & IS_LEVEL_2) && area->spftree[1] == NULL)
+ {
+ area->spftree[1] = isis_spftree_new ();
#ifdef HAVE_IPV6
- area->spftree6[1] = isis_spftree_new ();
+ area->spftree6[1] = isis_spftree_new ();
#endif
- /* thread_add_timer (master, isis_run_spf_l2, area,
- isis_jitter (PERIODIC_SPF_INTERVAL, 10)); */
- }
+ /* thread_add_timer (master, isis_run_spf_l2, area,
+ isis_jitter (PERIODIC_SPF_INTERVAL, 10)); */
+ }
return;
}
@@ -266,36 +276,38 @@
struct isis_vertex *vertex;
vertex = XMALLOC (MTYPE_ISIS_VERTEX, sizeof (struct isis_vertex));
- if (vertex == NULL) {
- zlog_err ("isis_vertex_new Out of memory!");
- return NULL;
- }
-
+ if (vertex == NULL)
+ {
+ zlog_err ("isis_vertex_new Out of memory!");
+ return NULL;
+ }
+
memset (vertex, 0, sizeof (struct isis_vertex));
vertex->type = vtype;
- switch (vtype) {
- case VTYPE_ES:
- case VTYPE_NONPSEUDO_IS:
- memcpy (vertex->N.id, (u_char *)id, ISIS_SYS_ID_LEN);
- break;
- case VTYPE_PSEUDO_IS:
- memcpy (vertex->N.id, (u_char *)id, ISIS_SYS_ID_LEN + 1);
- break;
- case VTYPE_IPREACH_INTERNAL:
- case VTYPE_IPREACH_EXTERNAL:
+ switch (vtype)
+ {
+ case VTYPE_ES:
+ case VTYPE_NONPSEUDO_IS:
+ memcpy (vertex->N.id, (u_char *) id, ISIS_SYS_ID_LEN);
+ break;
+ case VTYPE_PSEUDO_IS:
+ memcpy (vertex->N.id, (u_char *) id, ISIS_SYS_ID_LEN + 1);
+ break;
+ case VTYPE_IPREACH_INTERNAL:
+ case VTYPE_IPREACH_EXTERNAL:
#ifdef HAVE_IPV6
- case VTYPE_IP6REACH_INTERNAL:
- case VTYPE_IP6REACH_EXTERNAL:
-#endif /* HAVE_IPV6 */
- memcpy (&vertex->N.prefix, (struct prefix *)id,
- sizeof (struct prefix));
- break;
- default:
- zlog_err ("WTF!");
- }
+ case VTYPE_IP6REACH_INTERNAL:
+ case VTYPE_IP6REACH_EXTERNAL:
+#endif /* HAVE_IPV6 */
+ memcpy (&vertex->N.prefix, (struct prefix *) id,
+ sizeof (struct prefix));
+ break;
+ default:
+ zlog_err ("WTF!");
+ }
vertex->Adj_N = list_new ();
-
+
return vertex;
}
@@ -304,7 +316,7 @@
*/
void
isis_spf_add_self (struct isis_spftree *spftree, struct isis_area *area,
- int level)
+ int level)
{
struct isis_vertex *vertex;
struct isis_lsp *lsp;
@@ -313,14 +325,14 @@
u_char buff[BUFSIZ];
#endif /* EXTREME_DEBUG */
memcpy (lspid, isis->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID(lspid) = 0;
- LSP_FRAGMENT(lspid) = 0;
-
+ LSP_PSEUDO_ID (lspid) = 0;
+ LSP_FRAGMENT (lspid) = 0;
+
lsp = lsp_search (lspid, area->lspdb[level - 1]);
-
+
if (lsp == NULL)
zlog_warn ("ISIS-Spf: could not find own l%d LSP!", level);
-
+
vertex = isis_vertex_new (isis->sysid, VTYPE_NONPSEUDO_IS);
vertex->lsp = lsp;
@@ -328,143 +340,156 @@
#ifdef EXTREME_DEBUG
zlog_info ("ISIS-Spf: added this IS %s %s depth %d dist %d to PATHS",
- vtype2string(vertex->type), vid2string(vertex, buff),
- vertex->depth, vertex->d_N);
+ vtype2string (vertex->type), vid2string (vertex, buff),
+ vertex->depth, vertex->d_N);
#endif /* EXTREME_DEBUG */
return;
}
struct isis_vertex *
-isis_find_vertex (struct list *list, void *id, enum vertextype vtype)
+isis_find_vertex (struct list *list, void *id, enum vertextype vtype)
{
struct listnode *node;
struct isis_vertex *vertex;
struct prefix *p1, *p2;
- for (node = listhead (list); node; nextnode (node)) {
- vertex = getdata (node);
- if (vertex->type != vtype)
- continue;
- switch (vtype) {
- case VTYPE_ES:
- case VTYPE_NONPSEUDO_IS:
- if (memcmp ((u_char *)id, vertex->N.id, ISIS_SYS_ID_LEN) == 0)
- return vertex;
- break;
- case VTYPE_PSEUDO_IS:
- if (memcmp ((u_char *)id, vertex->N.id, ISIS_SYS_ID_LEN + 1) == 0)
- return vertex;
- break;
- case VTYPE_IPREACH_INTERNAL:
- case VTYPE_IPREACH_EXTERNAL:
+ for (node = listhead (list); node; nextnode (node))
+ {
+ vertex = getdata (node);
+ if (vertex->type != vtype)
+ continue;
+ switch (vtype)
+ {
+ case VTYPE_ES:
+ case VTYPE_NONPSEUDO_IS:
+ if (memcmp ((u_char *) id, vertex->N.id, ISIS_SYS_ID_LEN) == 0)
+ return vertex;
+ break;
+ case VTYPE_PSEUDO_IS:
+ if (memcmp ((u_char *) id, vertex->N.id, ISIS_SYS_ID_LEN + 1) == 0)
+ return vertex;
+ break;
+ case VTYPE_IPREACH_INTERNAL:
+ case VTYPE_IPREACH_EXTERNAL:
#ifdef HAVE_IPV6
- case VTYPE_IP6REACH_INTERNAL:
- case VTYPE_IP6REACH_EXTERNAL:
+ case VTYPE_IP6REACH_INTERNAL:
+ case VTYPE_IP6REACH_EXTERNAL:
#endif /* HAVE_IPV6 */
- p1 = (struct prefix *)id;
- p2 = (struct prefix *)&vertex->N.id;
- if (p1->family == p2->family && p1->prefixlen == p2->prefixlen &&
- memcmp (&p1->u.prefix, &p2->u.prefix, PSIZE (p1->prefixlen)) == 0)
- return vertex;
- break;
+ p1 = (struct prefix *) id;
+ p2 = (struct prefix *) &vertex->N.id;
+ if (p1->family == p2->family && p1->prefixlen == p2->prefixlen &&
+ memcmp (&p1->u.prefix, &p2->u.prefix,
+ PSIZE (p1->prefixlen)) == 0)
+ return vertex;
+ break;
+ }
}
- }
return NULL;
}
-
-
/*
* Add a vertex to TENT sorted by cost and by vertextype on tie break situation
*/
struct isis_vertex *
-isis_spf_add2tent (struct isis_spftree *spftree, enum vertextype vtype,
- void *id, struct isis_adjacency *adj, u_int16_t cost,
- int depth, int family)
+isis_spf_add2tent (struct isis_spftree *spftree, enum vertextype vtype,
+ void *id, struct isis_adjacency *adj, u_int16_t cost,
+ int depth, int family)
{
struct isis_vertex *vertex, *v;
struct listnode *node;
-#ifdef EXTREME_DEBUG
+#ifdef EXTREME_DEBUG
u_char buff[BUFSIZ];
#endif
vertex = isis_vertex_new (id, vtype);
vertex->d_N = cost;
vertex->depth = depth;
-
+
if (adj)
listnode_add (vertex->Adj_N, adj);
-#ifdef EXTREME_DEBUG
+#ifdef EXTREME_DEBUG
zlog_info ("ISIS-Spf: add to TENT %s %s depth %d dist %d",
- vtype2string(vertex->type), vid2string(vertex, buff),
- vertex->depth, vertex->d_N);
+ vtype2string (vertex->type), vid2string (vertex, buff),
+ vertex->depth, vertex->d_N);
#endif /* EXTREME_DEBUG */
- listnode_add (spftree->tents, vertex);
- if (list_isempty (spftree->tents)) {
- listnode_add (spftree->tents, vertex);
- return vertex;
- }
- for (node = listhead (spftree->tents); node; nextnode (node)) {
- v = getdata (node);
- if (v->d_N > vertex->d_N) {
- list_add_node_prev (spftree->tents, node, vertex);
- break;
- } else if (v->d_N == vertex->d_N) {
- /* Tie break, add according to type */
- while (v && v->d_N == vertex->d_N && v->type > vertex->type) {
- if (v->type > vertex->type) {
- break;
- }
- nextnode (node);
- (node) ? (v = getdata (node)) : (v = NULL);
- }
- list_add_node_prev (spftree->tents, node, vertex);
- break;
- } else if (node->next == NULL) {
- list_add_node_next (spftree->tents, node, vertex);
- break;
+ listnode_add (spftree->tents, vertex);
+ if (list_isempty (spftree->tents))
+ {
+ listnode_add (spftree->tents, vertex);
+ return vertex;
}
- }
+ for (node = listhead (spftree->tents); node; nextnode (node))
+ {
+ v = getdata (node);
+ if (v->d_N > vertex->d_N)
+ {
+ list_add_node_prev (spftree->tents, node, vertex);
+ break;
+ }
+ else if (v->d_N == vertex->d_N)
+ {
+ /* Tie break, add according to type */
+ while (v && v->d_N == vertex->d_N && v->type > vertex->type)
+ {
+ if (v->type > vertex->type)
+ {
+ break;
+ }
+ nextnode (node);
+ (node) ? (v = getdata (node)) : (v = NULL);
+ }
+ list_add_node_prev (spftree->tents, node, vertex);
+ break;
+ }
+ else if (node->next == NULL)
+ {
+ list_add_node_next (spftree->tents, node, vertex);
+ break;
+ }
+ }
return vertex;
}
struct isis_vertex *
-isis_spf_add_local (struct isis_spftree *spftree, enum vertextype vtype,
- void *id, struct isis_adjacency *adj, u_int16_t cost,
- int family)
+isis_spf_add_local (struct isis_spftree *spftree, enum vertextype vtype,
+ void *id, struct isis_adjacency *adj, u_int16_t cost,
+ int family)
{
struct isis_vertex *vertex;
-
- vertex = isis_find_vertex (spftree->tents, id, vtype);
-
- if (vertex) {
- /* C.2.5 c) */
- if (vertex->d_N == cost) {
- if (adj)
- listnode_add (vertex->Adj_N, adj);
- /* d) */
- if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
- remove_excess_adjs (vertex->Adj_N);
- }
- /* f) */
- else if (vertex->d_N > cost) {
- listnode_delete (spftree->tents, vertex);
- goto add2tent;
- }
- /* e) do nothing */
- return vertex;
- }
- add2tent:
+ vertex = isis_find_vertex (spftree->tents, id, vtype);
+
+ if (vertex)
+ {
+ /* C.2.5 c) */
+ if (vertex->d_N == cost)
+ {
+ if (adj)
+ listnode_add (vertex->Adj_N, adj);
+ /* d) */
+ if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
+ remove_excess_adjs (vertex->Adj_N);
+ }
+ /* f) */
+ else if (vertex->d_N > cost)
+ {
+ listnode_delete (spftree->tents, vertex);
+ goto add2tent;
+ }
+ /* e) do nothing */
+ return vertex;
+ }
+
+add2tent:
return isis_spf_add2tent (spftree, vtype, id, adj, cost, 1, family);
}
void
-process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id,
- u_int16_t dist, u_int16_t depth, struct isis_adjacency *adj,
- int family)
+process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id,
+ u_int16_t dist, u_int16_t depth, struct isis_adjacency *adj,
+ int family)
{
struct isis_vertex *vertex;
#ifdef EXTREME_DEBUG
@@ -476,39 +501,46 @@
return;
/* c) */
vertex = isis_find_vertex (spftree->paths, id, vtype);
- if (vertex) {
+ if (vertex)
+ {
#ifdef EXTREME_DEBUG
- zlog_info ("ISIS-Spf: process_N %s %s dist %d already found from PATH",
- vtype2string(vtype), vid2string(vertex, buff), dist);
+ zlog_info ("ISIS-Spf: process_N %s %s dist %d already found from PATH",
+ vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
- assert (dist >= vertex->d_N);
- return;
- }
+ assert (dist >= vertex->d_N);
+ return;
+ }
vertex = isis_find_vertex (spftree->tents, id, vtype);
- /* d) */
- if (vertex) {
- /* 1) */
+ /* d) */
+ if (vertex)
+ {
+ /* 1) */
#ifdef EXTREME_DEBUG
- zlog_info ("ISIS-Spf: process_N %s %s dist %d",
- vtype2string(vtype), vid2string(vertex, buff), dist);
+ zlog_info ("ISIS-Spf: process_N %s %s dist %d",
+ vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
- if (vertex->d_N == dist) {
- if (adj)
- listnode_add (vertex->Adj_N, adj);
- /* 2) */
- if (listcount(vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
- remove_excess_adjs (vertex->Adj_N);
- /* 3) */
- return;
- } else if (vertex->d_N < dist) {
- return;
- /* 4) */
- } else {
- listnode_delete (spftree->tents, vertex);
+ if (vertex->d_N == dist)
+ {
+ if (adj)
+ listnode_add (vertex->Adj_N, adj);
+ /* 2) */
+ if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
+ remove_excess_adjs (vertex->Adj_N);
+ /* 3) */
+ return;
+ }
+ else if (vertex->d_N < dist)
+ {
+ return;
+ /* 4) */
+ }
+ else
+ {
+ listnode_delete (spftree->tents, vertex);
+ }
}
- }
-
+
isis_spf_add2tent (spftree, vtype, id, adj, dist, depth, family);
return;
}
@@ -517,8 +549,8 @@
* C.2.6 Step 1
*/
int
-isis_spf_process_lsp (struct isis_spftree *spftree, struct isis_lsp *lsp,
- uint16_t cost, uint16_t depth, int family)
+isis_spf_process_lsp (struct isis_spftree *spftree, struct isis_lsp *lsp,
+ uint16_t cost, uint16_t depth, int family)
{
struct listnode *node, *fragnode = NULL;
u_int16_t dist;
@@ -529,147 +561,162 @@
#ifdef HAVE_IPV6
struct ipv6_reachability *ip6reach;
#endif /* HAVE_IPV6 */
-
+
if (!lsp->adj)
return ISIS_WARNING;
- if (lsp->tlv_data.nlpids == NULL ||
- !speaks (lsp->tlv_data.nlpids, family))
+ if (lsp->tlv_data.nlpids == NULL || !speaks (lsp->tlv_data.nlpids, family))
return ISIS_OK;
- lspfragloop:
- if (lsp->lsp_header->seq_num == 0) {
- zlog_warn ("isis_spf_process_lsp(): lsp with 0 seq_num"
- " - do not process");
- return ISIS_WARNING;
- }
+lspfragloop:
+ if (lsp->lsp_header->seq_num == 0)
+ {
+ zlog_warn ("isis_spf_process_lsp(): lsp with 0 seq_num"
+ " - do not process");
+ return ISIS_WARNING;
+ }
- if (!ISIS_MASK_LSP_OL_BIT(lsp->lsp_header->lsp_bits)) {
- if (lsp->tlv_data.is_neighs) {
- for (node = listhead (lsp->tlv_data.is_neighs); node; nextnode (node)) {
- is_neigh = getdata (node);
- /* C.2.6 a) */
- /* Two way connectivity */
- if (!memcmp (is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN))
- continue;
- dist = cost + is_neigh->metrics.metric_default;
- vtype = LSP_PSEUDO_ID(is_neigh->neigh_id) ? VTYPE_PSEUDO_IS
- : VTYPE_NONPSEUDO_IS;
- process_N (spftree, vtype, (void *)is_neigh->neigh_id, dist, depth+1,
- lsp->adj, family);
- }
- }
- if (family == AF_INET && lsp->tlv_data.ipv4_int_reachs) {
- prefix.family = AF_INET;
- for (node = listhead (lsp->tlv_data.ipv4_int_reachs); node;
- nextnode (node)) {
- ipreach = getdata (node);
- dist = cost + ipreach->metrics.metric_default;
- vtype = VTYPE_IPREACH_INTERNAL;
- prefix.u.prefix4 = ipreach->prefix;
- prefix.prefixlen = ip_masklen (ipreach->mask);
- process_N (spftree, vtype, (void *)&prefix, dist, depth + 1,
- lsp->adj, family);
- }
- }
-
- if (family == AF_INET && lsp->tlv_data.ipv4_ext_reachs) {
- prefix.family = AF_INET;
- for (node = listhead (lsp->tlv_data.ipv4_ext_reachs); node;
- nextnode (node)) {
- ipreach = getdata (node);
- dist = cost + ipreach->metrics.metric_default;
- vtype = VTYPE_IPREACH_EXTERNAL;
- prefix.u.prefix4 = ipreach->prefix;
- prefix.prefixlen = ip_masklen (ipreach->mask);
- process_N (spftree, vtype, (void *)&prefix, dist, depth + 1,
- lsp->adj, family);
- }
- }
+ if (!ISIS_MASK_LSP_OL_BIT (lsp->lsp_header->lsp_bits))
+ {
+ if (lsp->tlv_data.is_neighs)
+ {
+ for (node = listhead (lsp->tlv_data.is_neighs); node;
+ nextnode (node))
+ {
+ is_neigh = getdata (node);
+ /* C.2.6 a) */
+ /* Two way connectivity */
+ if (!memcmp (is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN))
+ continue;
+ dist = cost + is_neigh->metrics.metric_default;
+ vtype = LSP_PSEUDO_ID (is_neigh->neigh_id) ? VTYPE_PSEUDO_IS
+ : VTYPE_NONPSEUDO_IS;
+ process_N (spftree, vtype, (void *) is_neigh->neigh_id, dist,
+ depth + 1, lsp->adj, family);
+ }
+ }
+ if (family == AF_INET && lsp->tlv_data.ipv4_int_reachs)
+ {
+ prefix.family = AF_INET;
+ for (node = listhead (lsp->tlv_data.ipv4_int_reachs); node;
+ nextnode (node))
+ {
+ ipreach = getdata (node);
+ dist = cost + ipreach->metrics.metric_default;
+ vtype = VTYPE_IPREACH_INTERNAL;
+ prefix.u.prefix4 = ipreach->prefix;
+ prefix.prefixlen = ip_masklen (ipreach->mask);
+ process_N (spftree, vtype, (void *) &prefix, dist, depth + 1,
+ lsp->adj, family);
+ }
+ }
+
+ if (family == AF_INET && lsp->tlv_data.ipv4_ext_reachs)
+ {
+ prefix.family = AF_INET;
+ for (node = listhead (lsp->tlv_data.ipv4_ext_reachs); node;
+ nextnode (node))
+ {
+ ipreach = getdata (node);
+ dist = cost + ipreach->metrics.metric_default;
+ vtype = VTYPE_IPREACH_EXTERNAL;
+ prefix.u.prefix4 = ipreach->prefix;
+ prefix.prefixlen = ip_masklen (ipreach->mask);
+ process_N (spftree, vtype, (void *) &prefix, dist, depth + 1,
+ lsp->adj, family);
+ }
+ }
#ifdef HAVE_IPV6
- if (family == AF_INET6 && lsp->tlv_data.ipv6_reachs) {
- prefix.family = AF_INET6;
- for (node = listhead (lsp->tlv_data.ipv6_reachs); node;
- nextnode (node)) {
- ip6reach = getdata (node);
- dist = cost + ip6reach->metric;
- vtype = (ip6reach->control_info & CTRL_INFO_DISTRIBUTION) ?
- VTYPE_IP6REACH_EXTERNAL : VTYPE_IP6REACH_INTERNAL;
- prefix.prefixlen = ip6reach->prefix_len;
- memcpy (&prefix.u.prefix6.s6_addr, ip6reach->prefix,
- PSIZE(ip6reach->prefix_len));
- process_N (spftree, vtype, (void *)&prefix, dist, depth + 1,
- lsp->adj, family);
- }
- }
+ if (family == AF_INET6 && lsp->tlv_data.ipv6_reachs)
+ {
+ prefix.family = AF_INET6;
+ for (node = listhead (lsp->tlv_data.ipv6_reachs); node;
+ nextnode (node))
+ {
+ ip6reach = getdata (node);
+ dist = cost + ip6reach->metric;
+ vtype = (ip6reach->control_info & CTRL_INFO_DISTRIBUTION) ?
+ VTYPE_IP6REACH_EXTERNAL : VTYPE_IP6REACH_INTERNAL;
+ prefix.prefixlen = ip6reach->prefix_len;
+ memcpy (&prefix.u.prefix6.s6_addr, ip6reach->prefix,
+ PSIZE (ip6reach->prefix_len));
+ process_N (spftree, vtype, (void *) &prefix, dist, depth + 1,
+ lsp->adj, family);
+ }
+ }
#endif /* HAVE_IPV6 */
- }
-
+ }
+
if (fragnode == NULL)
fragnode = listhead (lsp->lspu.frags);
- else
+ else
fragnode = nextnode (fragnode);
- if (fragnode) {
- lsp = getdata (fragnode);
- goto lspfragloop;
- }
-
+ if (fragnode)
+ {
+ lsp = getdata (fragnode);
+ goto lspfragloop;
+ }
+
return ISIS_OK;
}
int
-isis_spf_process_pseudo_lsp (struct isis_spftree *spftree,struct isis_lsp *lsp,
- uint16_t cost, uint16_t depth, int family)
+isis_spf_process_pseudo_lsp (struct isis_spftree *spftree,
+ struct isis_lsp *lsp, uint16_t cost,
+ uint16_t depth, int family)
{
struct listnode *node, *fragnode = NULL;
struct is_neigh *is_neigh;
enum vertextype vtype;
-
- pseudofragloop:
-
- if (lsp->lsp_header->seq_num == 0) {
- zlog_warn ("isis_spf_process_pseudo_lsp(): lsp with 0 seq_num"
- " - do not process");
- return ISIS_WARNING;
- }
-
- for (node = (lsp->tlv_data.is_neighs ?
- listhead (lsp->tlv_data.is_neighs) : NULL);
- node; nextnode (node)) {
- is_neigh = getdata (node);
- vtype = LSP_PSEUDO_ID(is_neigh->neigh_id) ? VTYPE_PSEUDO_IS
- : VTYPE_NONPSEUDO_IS;
- /* Two way connectivity */
- if (!memcmp (is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN))
- continue;
- if (isis_find_vertex (spftree->tents, (void *)is_neigh->neigh_id, vtype)
- == NULL &&
- isis_find_vertex (spftree->paths, (void *)is_neigh->neigh_id, vtype)
- == NULL) {
- /* C.2.5 i) */
- isis_spf_add2tent (spftree, vtype, is_neigh->neigh_id, lsp->adj,
- cost, depth, family);
+
+pseudofragloop:
+
+ if (lsp->lsp_header->seq_num == 0)
+ {
+ zlog_warn ("isis_spf_process_pseudo_lsp(): lsp with 0 seq_num"
+ " - do not process");
+ return ISIS_WARNING;
}
- }
-
+
+ for (node = (lsp->tlv_data.is_neighs ?
+ listhead (lsp->tlv_data.is_neighs) : NULL);
+ node; nextnode (node))
+ {
+ is_neigh = getdata (node);
+ vtype = LSP_PSEUDO_ID (is_neigh->neigh_id) ? VTYPE_PSEUDO_IS
+ : VTYPE_NONPSEUDO_IS;
+ /* Two way connectivity */
+ if (!memcmp (is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN))
+ continue;
+ if (isis_find_vertex
+ (spftree->tents, (void *) is_neigh->neigh_id, vtype) == NULL
+ && isis_find_vertex (spftree->paths, (void *) is_neigh->neigh_id,
+ vtype) == NULL)
+ {
+ /* C.2.5 i) */
+ isis_spf_add2tent (spftree, vtype, is_neigh->neigh_id, lsp->adj,
+ cost, depth, family);
+ }
+ }
+
if (fragnode == NULL)
fragnode = listhead (lsp->lspu.frags);
- else
+ else
fragnode = nextnode (fragnode);
- if (fragnode) {
- lsp = getdata (fragnode);
- goto pseudofragloop;
- }
+ if (fragnode)
+ {
+ lsp = getdata (fragnode);
+ goto pseudofragloop;
+ }
-
return ISIS_OK;
}
-
+
int
-isis_spf_preload_tent (struct isis_spftree *spftree,
- struct isis_area *area, int level, int family)
+isis_spf_preload_tent (struct isis_spftree *spftree,
+ struct isis_area *area, int level, int family)
{
struct isis_vertex *vertex;
struct isis_circuit *circuit;
@@ -685,148 +732,172 @@
#ifdef HAVE_IPV6
struct prefix_ipv6 *ipv6;
#endif /* HAVE_IPV6 */
-
- for (cnode = listhead (area->circuit_list); cnode; nextnode (cnode)) {
- circuit = getdata (cnode);
- if (circuit->state != C_STATE_UP)
- continue;
- if (!(circuit->circuit_is_type & level))
- continue;
- if (family == AF_INET && !circuit->ip_router)
- continue;
-#ifdef HAVE_IPV6
- if (family == AF_INET6 && !circuit->ipv6_router)
- continue;
-#endif /* HAVE_IPV6 */
- /*
- * Add IP(v6) addresses of this circuit
- */
- if (family == AF_INET) {
- prefix.family = AF_INET;
- for (ipnode = (circuit->ip_addrs ? listhead (circuit->ip_addrs) : NULL);
- ipnode; nextnode (ipnode)) {
- ipv4 = getdata (ipnode);
- prefix.u.prefix4 = ipv4->prefix;
- prefix.prefixlen = ipv4->prefixlen;
- isis_spf_add_local (spftree, VTYPE_IPREACH_INTERNAL, &prefix, NULL, 0,
- family);
- }
- }
-#ifdef HAVE_IPV6
- if (family == AF_INET6) {
- prefix.family = AF_INET6;
- for (ipnode = (circuit->ipv6_non_link ? listhead
- (circuit->ipv6_non_link) : NULL); ipnode;
- nextnode (ipnode)) {
- ipv6 = getdata (ipnode);
- prefix.prefixlen = ipv6->prefixlen;
- prefix.u.prefix6 = ipv6->prefix;
- isis_spf_add_local (spftree, VTYPE_IP6REACH_INTERNAL,
- &prefix, NULL, 0, family);
- }
- }
-#endif /* HAVE_IPV6 */
- if (circuit->circ_type == CIRCUIT_T_BROADCAST ) {
- /*
- * Add the adjacencies
- */
- adj_list = list_new ();
- adjdb = circuit->u.bc.adjdb[level - 1];
- isis_adj_build_up_list (adjdb, adj_list);
- if (listcount (adj_list) == 0) {
- list_delete (adj_list);
- zlog_warn ("ISIS-Spf: no L%d adjacencies on circuit %s",
- level, circuit->interface->name);
+
+ for (cnode = listhead (area->circuit_list); cnode; nextnode (cnode))
+ {
+ circuit = getdata (cnode);
+ if (circuit->state != C_STATE_UP)
continue;
- }
- anode = listhead (adj_list);
- while (anode) {
- adj = getdata (anode);
- if (!speaks (&adj->nlpids, family)) {
- anode = nextnode (anode);
- continue;
- }
- switch (adj->sys_type) {
- case ISIS_SYSTYPE_ES:
- isis_spf_add_local (spftree, VTYPE_ES, adj->sysid, adj,
- circuit->metrics[level - 1].metric_default,
- family);
- break;
- case ISIS_SYSTYPE_IS:
- case ISIS_SYSTYPE_L1_IS:
- case ISIS_SYSTYPE_L2_IS:
- vertex =
- isis_spf_add_local (spftree, VTYPE_NONPSEUDO_IS,
- adj->sysid, adj,
- circuit->metrics[level - 1].metric_default,
- family);
- memcpy (lsp_id, adj->sysid, ISIS_SYS_ID_LEN);
- LSP_PSEUDO_ID(lsp_id) = 0;
- LSP_FRAGMENT(lsp_id) = 0;
- lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
- if (!lsp)
- zlog_warn ("No lsp found for IS adjacency");
- /* else {
- isis_spf_process_lsp (spftree, lsp, vertex->d_N, 1, family);
- } */
- break;
- case ISIS_SYSTYPE_UNKNOWN:
- default:
- zlog_warn ("isis_spf_preload_tent unknow adj type");
- }
- anode = nextnode (anode);
- }
- list_delete (adj_list);
- /*
- * Add the pseudonode
+ if (!(circuit->circuit_is_type & level))
+ continue;
+ if (family == AF_INET && !circuit->ip_router)
+ continue;
+#ifdef HAVE_IPV6
+ if (family == AF_INET6 && !circuit->ipv6_router)
+ continue;
+#endif /* HAVE_IPV6 */
+ /*
+ * Add IP(v6) addresses of this circuit
*/
- if (level == 1)
- memcpy (lsp_id, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
+ if (family == AF_INET)
+ {
+ prefix.family = AF_INET;
+ for (ipnode =
+ (circuit->ip_addrs ? listhead (circuit->ip_addrs) : NULL);
+ ipnode; nextnode (ipnode))
+ {
+ ipv4 = getdata (ipnode);
+ prefix.u.prefix4 = ipv4->prefix;
+ prefix.prefixlen = ipv4->prefixlen;
+ isis_spf_add_local (spftree, VTYPE_IPREACH_INTERNAL, &prefix,
+ NULL, 0, family);
+ }
+ }
+#ifdef HAVE_IPV6
+ if (family == AF_INET6)
+ {
+ prefix.family = AF_INET6;
+ for (ipnode = (circuit->ipv6_non_link ? listhead
+ (circuit->ipv6_non_link) : NULL); ipnode;
+ nextnode (ipnode))
+ {
+ ipv6 = getdata (ipnode);
+ prefix.prefixlen = ipv6->prefixlen;
+ prefix.u.prefix6 = ipv6->prefix;
+ isis_spf_add_local (spftree, VTYPE_IP6REACH_INTERNAL,
+ &prefix, NULL, 0, family);
+ }
+ }
+#endif /* HAVE_IPV6 */
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ /*
+ * Add the adjacencies
+ */
+ adj_list = list_new ();
+ adjdb = circuit->u.bc.adjdb[level - 1];
+ isis_adj_build_up_list (adjdb, adj_list);
+ if (listcount (adj_list) == 0)
+ {
+ list_delete (adj_list);
+ zlog_warn ("ISIS-Spf: no L%d adjacencies on circuit %s",
+ level, circuit->interface->name);
+ continue;
+ }
+ anode = listhead (adj_list);
+ while (anode)
+ {
+ adj = getdata (anode);
+ if (!speaks (&adj->nlpids, family))
+ {
+ anode = nextnode (anode);
+ continue;
+ }
+ switch (adj->sys_type)
+ {
+ case ISIS_SYSTYPE_ES:
+ isis_spf_add_local (spftree, VTYPE_ES, adj->sysid, adj,
+ circuit->metrics[level -
+ 1].metric_default,
+ family);
+ break;
+ case ISIS_SYSTYPE_IS:
+ case ISIS_SYSTYPE_L1_IS:
+ case ISIS_SYSTYPE_L2_IS:
+ vertex =
+ isis_spf_add_local (spftree, VTYPE_NONPSEUDO_IS,
+ adj->sysid, adj,
+ circuit->metrics[level -
+ 1].metric_default,
+ family);
+ memcpy (lsp_id, adj->sysid, ISIS_SYS_ID_LEN);
+ LSP_PSEUDO_ID (lsp_id) = 0;
+ LSP_FRAGMENT (lsp_id) = 0;
+ lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
+ if (!lsp)
+ zlog_warn ("No lsp found for IS adjacency");
+ /* else {
+ isis_spf_process_lsp (spftree, lsp, vertex->d_N, 1, family);
+ } */
+ break;
+ case ISIS_SYSTYPE_UNKNOWN:
+ default:
+ zlog_warn ("isis_spf_preload_tent unknow adj type");
+ }
+ anode = nextnode (anode);
+ }
+ list_delete (adj_list);
+ /*
+ * Add the pseudonode
+ */
+ if (level == 1)
+ memcpy (lsp_id, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
+ else
+ memcpy (lsp_id, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
+ lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
+ adj = isis_adj_lookup (lsp_id, adjdb);
+ /* if no adj, we are the dis or error */
+ if (!adj && !circuit->u.bc.is_dr[level - 1])
+ {
+ zlog_warn ("ISIS-Spf: No adjacency found for DR");
+ }
+ if (lsp == NULL || lsp->lsp_header->rem_lifetime == 0)
+ {
+ zlog_warn ("ISIS-Spf: No lsp found for DR");
+ }
+ else
+ {
+ isis_spf_process_pseudo_lsp
+ (spftree, lsp, circuit->metrics[level - 1].metric_default, 0,
+ family);
+
+ }
+ }
+ else if (circuit->circ_type == CIRCUIT_T_P2P)
+ {
+ adj = circuit->u.p2p.neighbor;
+ if (!adj)
+ continue;
+ switch (adj->sys_type)
+ {
+ case ISIS_SYSTYPE_ES:
+ isis_spf_add_local (spftree, VTYPE_ES, adj->sysid, adj,
+ circuit->metrics[level - 1].metric_default,
+ family);
+ break;
+ case ISIS_SYSTYPE_IS:
+ case ISIS_SYSTYPE_L1_IS:
+ case ISIS_SYSTYPE_L2_IS:
+ if (speaks (&adj->nlpids, family))
+ isis_spf_add_local (spftree, VTYPE_NONPSEUDO_IS, adj->sysid,
+ adj,
+ circuit->metrics[level -
+ 1].metric_default,
+ family);
+ break;
+ case ISIS_SYSTYPE_UNKNOWN:
+ default:
+ zlog_warn ("isis_spf_preload_tent unknow adj type");
+ break;
+ }
+ }
else
- memcpy (lsp_id, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
- lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
- adj = isis_adj_lookup (lsp_id, adjdb);
- /* if no adj, we are the dis or error */
- if (!adj && !circuit->u.bc.is_dr[level - 1]) {
- zlog_warn ("ISIS-Spf: No adjacency found for DR");
- }
- if (lsp == NULL || lsp->lsp_header->rem_lifetime == 0) {
- zlog_warn ("ISIS-Spf: No lsp found for DR");
- } else {
- isis_spf_process_pseudo_lsp
- (spftree, lsp, circuit->metrics[level - 1].metric_default, 0,
- family);
-
- }
- } else if (circuit->circ_type == CIRCUIT_T_P2P ) {
- adj = circuit->u.p2p.neighbor;
- if (!adj)
- continue;
- switch (adj->sys_type) {
- case ISIS_SYSTYPE_ES:
- isis_spf_add_local (spftree, VTYPE_ES, adj->sysid, adj,
- circuit->metrics[level - 1].metric_default,
- family);
- break;
- case ISIS_SYSTYPE_IS:
- case ISIS_SYSTYPE_L1_IS:
- case ISIS_SYSTYPE_L2_IS:
- if (speaks (&adj->nlpids, family))
- isis_spf_add_local (spftree, VTYPE_NONPSEUDO_IS, adj->sysid, adj,
- circuit->metrics[level - 1].metric_default,
- family);
- break;
- case ISIS_SYSTYPE_UNKNOWN:
- default:
- zlog_warn ("isis_spf_preload_tent unknow adj type");
- break;
- }
- } else {
- zlog_warn ("isis_spf_preload_tent unsupported media");
- retval = ISIS_WARNING;
+ {
+ zlog_warn ("isis_spf_preload_tent unsupported media");
+ retval = ISIS_WARNING;
+ }
+
}
-
- }
return retval;
}
@@ -837,39 +908,38 @@
*/
void
add_to_paths (struct isis_spftree *spftree, struct isis_vertex *vertex,
- struct isis_area *area)
+ struct isis_area *area)
{
-
#ifdef EXTREME_DEBUG
u_char buff[BUFSIZ];
#endif /* EXTREME_DEBUG */
listnode_add (spftree->paths, vertex);
-#ifdef EXTREME_DEBUG
+#ifdef EXTREME_DEBUG
zlog_info ("ISIS-Spf: added %s %s depth %d dist %d to PATHS",
- vtype2string(vertex->type), vid2string(vertex, buff),
- vertex->depth, vertex->d_N);
-#endif /* EXTREME_DEBUG */
- if (vertex->type > VTYPE_ES) {
- if (listcount(vertex->Adj_N) > 0)
- isis_route_create ((struct prefix *)&vertex->N.prefix,
- vertex->d_N, vertex->depth, vertex->Adj_N, area);
- else if (isis->debugs & DEBUG_SPF_EVENTS)
- zlog_info ("ISIS-Spf: no adjacencies do not install route");
- }
-
+ vtype2string (vertex->type), vid2string (vertex, buff),
+ vertex->depth, vertex->d_N);
+#endif /* EXTREME_DEBUG */
+ if (vertex->type > VTYPE_ES)
+ {
+ if (listcount (vertex->Adj_N) > 0)
+ isis_route_create ((struct prefix *) &vertex->N.prefix,
+ vertex->d_N, vertex->depth, vertex->Adj_N, area);
+ else if (isis->debugs & DEBUG_SPF_EVENTS)
+ zlog_info ("ISIS-Spf: no adjacencies do not install route");
+ }
+
return;
}
-
void
init_spt (struct isis_spftree *spftree)
{
- spftree->tents->del = spftree->paths->del = (void *)isis_vertex_del;
+ spftree->tents->del = spftree->paths->del = (void *) isis_vertex_del;
list_delete_all_node (spftree->tents);
list_delete_all_node (spftree->paths);
spftree->tents->del = spftree->paths->del = NULL;
-
+
return;
}
@@ -879,17 +949,17 @@
int retval = ISIS_OK;
struct listnode *node;
struct isis_vertex *vertex;
- struct isis_spftree *spftree = NULL;
+ struct isis_spftree *spftree = NULL;
u_char lsp_id[ISIS_SYS_ID_LEN + 2];
struct isis_lsp *lsp;
-
+
if (family == AF_INET)
spftree = area->spftree[level - 1];
#ifdef HAVE_IPV6
else if (family == AF_INET6)
spftree = area->spftree6[level - 1];
#endif
-
+
assert (spftree);
/*
@@ -900,60 +970,72 @@
isis_spf_add_self (spftree, area, level);
/* b) */
retval = isis_spf_preload_tent (spftree, area, level, family);
-
+
/*
* C.2.7 Step 2
*/
- if (listcount (spftree->tents) == 0) {
- zlog_warn ("ISIS-Spf: TENT is empty");
- spftree->lastrun = time (NULL);
- return retval;
- }
-
- while (listcount (spftree->tents) > 0) {
- node = listhead (spftree->tents);
- vertex = getdata (node);
- /* Remove from tent list */
- list_delete_node (spftree->tents, node);
- if (isis_find_vertex (spftree->paths, vertex->N.id, vertex->type))
- continue;
- add_to_paths (spftree, vertex, area);
- if (vertex->type == VTYPE_PSEUDO_IS ||
- vertex->type == VTYPE_NONPSEUDO_IS) {
- memcpy (lsp_id, vertex->N.id, ISIS_SYS_ID_LEN + 1);
- LSP_FRAGMENT(lsp_id) = 0;
- lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
- if (lsp) {
- if (LSP_PSEUDO_ID (lsp_id)) {
- isis_spf_process_pseudo_lsp (spftree, lsp, vertex->d_N,
- vertex->depth, family);
-
- } else {
- isis_spf_process_lsp (spftree, lsp, vertex->d_N, vertex->depth,
- family);
- }
- } else {
- zlog_warn ("ISIS-Spf: No LSP found for %s", rawlspid_print (lsp_id));
- }
+ if (listcount (spftree->tents) == 0)
+ {
+ zlog_warn ("ISIS-Spf: TENT is empty");
+ spftree->lastrun = time (NULL);
+ return retval;
}
- }
-
+
+ while (listcount (spftree->tents) > 0)
+ {
+ node = listhead (spftree->tents);
+ vertex = getdata (node);
+ /* Remove from tent list */
+ list_delete_node (spftree->tents, node);
+ if (isis_find_vertex (spftree->paths, vertex->N.id, vertex->type))
+ continue;
+ add_to_paths (spftree, vertex, area);
+ if (vertex->type == VTYPE_PSEUDO_IS ||
+ vertex->type == VTYPE_NONPSEUDO_IS)
+ {
+ memcpy (lsp_id, vertex->N.id, ISIS_SYS_ID_LEN + 1);
+ LSP_FRAGMENT (lsp_id) = 0;
+ lsp = lsp_search (lsp_id, area->lspdb[level - 1]);
+ if (lsp)
+ {
+ if (LSP_PSEUDO_ID (lsp_id))
+ {
+ isis_spf_process_pseudo_lsp (spftree, lsp, vertex->d_N,
+ vertex->depth, family);
+
+ }
+ else
+ {
+ isis_spf_process_lsp (spftree, lsp, vertex->d_N,
+ vertex->depth, family);
+ }
+ }
+ else
+ {
+ zlog_warn ("ISIS-Spf: No LSP found for %s",
+ rawlspid_print (lsp_id));
+ }
+ }
+ }
+
thread_add_event (master, isis_route_validate, area, 0);
spftree->lastrun = time (NULL);
spftree->pending = 0;
-
- if (level == 1) {
- /* FIXME: Should do it earlier. */
- spftree->t_spf_periodic = NULL;
- THREAD_TIMER_ON(master, spftree->t_spf_periodic, isis_run_spf_l1, area,
- isis_jitter(PERIODIC_SPF_INTERVAL, 10));
- }
- else {
- /* FIXME: Should do it earlier. */
- spftree->t_spf_periodic = NULL;
- THREAD_TIMER_ON(master, spftree->t_spf_periodic, isis_run_spf_l2, area,
- isis_jitter(PERIODIC_SPF_INTERVAL, 10));
- }
+
+ if (level == 1)
+ {
+ /* FIXME: Should do it earlier. */
+ spftree->t_spf_periodic = NULL;
+ THREAD_TIMER_ON (master, spftree->t_spf_periodic, isis_run_spf_l1, area,
+ isis_jitter (PERIODIC_SPF_INTERVAL, 10));
+ }
+ else
+ {
+ /* FIXME: Should do it earlier. */
+ spftree->t_spf_periodic = NULL;
+ THREAD_TIMER_ON (master, spftree->t_spf_periodic, isis_run_spf_l2, area,
+ isis_jitter (PERIODIC_SPF_INTERVAL, 10));
+ }
return retval;
}
@@ -964,21 +1046,24 @@
struct isis_area *area;
int retval = ISIS_OK;
- area = THREAD_ARG(thread);
+ area = THREAD_ARG (thread);
assert (area);
- if (!(area->is_type & IS_LEVEL_1)) {
- if (isis->debugs & DEBUG_SPF_EVENTS) {
- zlog_warn ("ISIS-SPF (%s) area does not share level", area->area_tag);
+ if (!(area->is_type & IS_LEVEL_1))
+ {
+ if (isis->debugs & DEBUG_SPF_EVENTS)
+ {
+ zlog_warn ("ISIS-SPF (%s) area does not share level",
+ area->area_tag);
+ }
+ return ISIS_WARNING;
}
- return ISIS_WARNING;
- }
- if (isis->debugs & DEBUG_SPF_EVENTS) {
- zlog_info ("ISIS-Spf (%s) L1 SPF needed, periodic SPF",
- area->area_tag);
- }
-
+ if (isis->debugs & DEBUG_SPF_EVENTS)
+ {
+ zlog_info ("ISIS-Spf (%s) L1 SPF needed, periodic SPF", area->area_tag);
+ }
+
if (area->ip_circuits)
retval = isis_run_spf (area, 1, AF_INET);
#ifdef HAVE_IPV6
@@ -994,20 +1079,23 @@
struct isis_area *area;
int retval = ISIS_OK;
- area = THREAD_ARG(thread);
+ area = THREAD_ARG (thread);
assert (area);
-
- if (!(area->is_type & IS_LEVEL_2)) {
- if (isis->debugs & DEBUG_SPF_EVENTS) {
- zlog_warn ("ISIS-SPF (%s) area does not share level", area->area_tag);
+
+ if (!(area->is_type & IS_LEVEL_2))
+ {
+ if (isis->debugs & DEBUG_SPF_EVENTS)
+ {
+ zlog_warn ("ISIS-SPF (%s) area does not share level",
+ area->area_tag);
+ }
+ return ISIS_WARNING;
}
- return ISIS_WARNING;
- }
-
- if (isis->debugs & DEBUG_SPF_EVENTS) {
- zlog_info ("ISIS-Spf (%s) L2 SPF needed, periodic SPF",
- area->area_tag);
- }
+
+ if (isis->debugs & DEBUG_SPF_EVENTS)
+ {
+ zlog_info ("ISIS-Spf (%s) L2 SPF needed, periodic SPF", area->area_tag);
+ }
if (area->ip_circuits)
retval = isis_run_spf (area, 2, AF_INET);
@@ -1019,7 +1107,7 @@
return retval;
}
-int
+int
isis_spf_schedule (struct isis_area *area, int level)
{
int retval = ISIS_OK;
@@ -1029,43 +1117,45 @@
if (spftree->pending)
return retval;
- diff = now - spftree->lastrun;
+ diff = now - spftree->lastrun;
/* FIXME: let's wait a minute before doing the SPF */
- if (now - isis->uptime < 60 || isis->uptime == 0) {
- if (level == 1)
- thread_add_timer (master, isis_run_spf_l1, area,
- 60);
- else
- thread_add_timer (master, isis_run_spf_l2, area,
- 60);
+ if (now - isis->uptime < 60 || isis->uptime == 0)
+ {
+ if (level == 1)
+ thread_add_timer (master, isis_run_spf_l1, area, 60);
+ else
+ thread_add_timer (master, isis_run_spf_l2, area, 60);
- spftree->pending = 1;
- return retval;
- }
+ spftree->pending = 1;
+ return retval;
+ }
/* FIXME: This stuff is just mess. All spf thread add/cancel
logic should be reviewed. */
- THREAD_TIMER_OFF(spftree->t_spf_periodic);
+ THREAD_TIMER_OFF (spftree->t_spf_periodic);
- if (diff < MINIMUM_SPF_INTERVAL) {
- if (level == 1)
- thread_add_timer (master, isis_run_spf_l1, area,
- MINIMUM_SPF_INTERVAL - diff);
- else
- thread_add_timer (master, isis_run_spf_l2, area,
- MINIMUM_SPF_INTERVAL - diff);
+ if (diff < MINIMUM_SPF_INTERVAL)
+ {
+ if (level == 1)
+ thread_add_timer (master, isis_run_spf_l1, area,
+ MINIMUM_SPF_INTERVAL - diff);
+ else
+ thread_add_timer (master, isis_run_spf_l2, area,
+ MINIMUM_SPF_INTERVAL - diff);
- spftree->pending = 1;
- } else {
- spftree->pending = 0;
- retval = isis_run_spf (area, level, AF_INET);
- }
+ spftree->pending = 1;
+ }
+ else
+ {
+ spftree->pending = 0;
+ retval = isis_run_spf (area, level, AF_INET);
+ }
return retval;
}
#ifdef HAVE_IPV6
-int
+int
isis_spf_schedule6 (struct isis_area *area, int level)
{
int retval = ISIS_OK;
@@ -1075,37 +1165,39 @@
if (spftree->pending)
return retval;
- diff = now - spftree->lastrun;
-
- THREAD_TIMER_OFF(spftree->t_spf_periodic);
-
+ diff = now - spftree->lastrun;
+
+ THREAD_TIMER_OFF (spftree->t_spf_periodic);
+
/* FIXME: let's wait a minute before doing the SPF */
- if (now - isis->uptime < 60 || isis->uptime == 0) {
- if (level == 1)
- thread_add_timer (master, isis_run_spf_l1, area,
- 60);
- else
- thread_add_timer (master, isis_run_spf_l2, area,
- 60);
+ if (now - isis->uptime < 60 || isis->uptime == 0)
+ {
+ if (level == 1)
+ thread_add_timer (master, isis_run_spf_l1, area, 60);
+ else
+ thread_add_timer (master, isis_run_spf_l2, area, 60);
- spftree->pending = 1;
- return retval;
- }
+ spftree->pending = 1;
+ return retval;
+ }
- if (diff < MINIMUM_SPF_INTERVAL) {
- if (level == 1)
- thread_add_timer (master, isis_run_spf_l1, area,
- MINIMUM_SPF_INTERVAL - diff);
- else
- thread_add_timer (master, isis_run_spf_l2, area,
- MINIMUM_SPF_INTERVAL - diff);
+ if (diff < MINIMUM_SPF_INTERVAL)
+ {
+ if (level == 1)
+ thread_add_timer (master, isis_run_spf_l1, area,
+ MINIMUM_SPF_INTERVAL - diff);
+ else
+ thread_add_timer (master, isis_run_spf_l2, area,
+ MINIMUM_SPF_INTERVAL - diff);
- spftree->pending = 1;
- } else {
- spftree->pending = 0;
- retval = isis_run_spf (area, level, AF_INET6);
- }
+ spftree->pending = 1;
+ }
+ else
+ {
+ spftree->pending = 0;
+ retval = isis_run_spf (area, level, AF_INET6);
+ }
return retval;
}
@@ -1121,43 +1213,47 @@
struct isis_adjacency *adj;
#ifdef EXTREME_DEBUG
u_char buff[255];
-#endif
+#endif
vty_out (vty, "System Id Metric Next-Hop"
- " Interface SNPA%s", VTY_NEWLINE);
- for (node = listhead (paths); node; nextnode (node)) {
- vertex = getdata (node);
- if (vertex->type != VTYPE_NONPSEUDO_IS)
- continue;
- if (memcmp (vertex->N.id, isis->sysid, ISIS_SYS_ID_LEN) == 0) {
- vty_out (vty, "%s --%s", host.name, VTY_NEWLINE);
- } else {
- dyn = dynhn_find_by_id ((u_char *)vertex->N.id);
- anode = listhead (vertex->Adj_N);
- adj = getdata (anode);
- if (adj) {
- nh_dyn = dynhn_find_by_id (adj->sysid);
- vty_out (vty, "%-20s %-10u %-20s %-11s %-5s%s",
- (dyn != NULL) ? dyn->name.name :
- (u_char *)rawlspid_print ((u_char *)vertex->N.id),
- vertex->d_N, (nh_dyn != NULL) ? nh_dyn->name.name :
- (u_char *)rawlspid_print (adj->sysid),
- adj->circuit->interface->name,
- snpa_print (adj->snpa), VTY_NEWLINE);
- } else {
- vty_out (vty, "%s %u %s", dyn ? dyn->name.name :
- (u_char *)rawlspid_print (vertex->N.id),
- vertex->d_N, VTY_NEWLINE);
- }
-
- }
+ " Interface SNPA%s", VTY_NEWLINE);
+ for (node = listhead (paths); node; nextnode (node))
+ {
+ vertex = getdata (node);
+ if (vertex->type != VTYPE_NONPSEUDO_IS)
+ continue;
+ if (memcmp (vertex->N.id, isis->sysid, ISIS_SYS_ID_LEN) == 0)
+ {
+ vty_out (vty, "%s --%s", host.name, VTY_NEWLINE);
+ }
+ else
+ {
+ dyn = dynhn_find_by_id ((u_char *) vertex->N.id);
+ anode = listhead (vertex->Adj_N);
+ adj = getdata (anode);
+ if (adj)
+ {
+ nh_dyn = dynhn_find_by_id (adj->sysid);
+ vty_out (vty, "%-20s %-10u %-20s %-11s %-5s%s",
+ (dyn != NULL) ? dyn->name.name :
+ (u_char *) rawlspid_print ((u_char *) vertex->N.id),
+ vertex->d_N, (nh_dyn != NULL) ? nh_dyn->name.name :
+ (u_char *) rawlspid_print (adj->sysid),
+ adj->circuit->interface->name,
+ snpa_print (adj->snpa), VTY_NEWLINE);
+ }
+ else
+ {
+ vty_out (vty, "%s %u %s", dyn ? dyn->name.name :
+ (u_char *) rawlspid_print (vertex->N.id),
+ vertex->d_N, VTY_NEWLINE);
+ }
+ }
#if 0
- vty_out (vty, "%s %s %u %s", vtype2string(vertex->type),
- vid2string(vertex, buff), vertex->d_N, VTY_NEWLINE);
+ vty_out (vty, "%s %s %u %s", vtype2string (vertex->type),
+ vid2string (vertex, buff), vertex->d_N, VTY_NEWLINE);
#endif
- }
-
-
+ }
}
DEFUN (show_isis_topology,
@@ -1170,37 +1266,41 @@
struct listnode *node;
struct isis_area *area;
int level;
-
+
if (!isis->area_list || isis->area_list->count == 0)
return CMD_SUCCESS;
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
- vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
- VTY_NEWLINE);
-
- for (level=0; level < ISIS_LEVELS; level++) {
- if (area->ip_circuits > 0 && area->spftree[level]
- && area->spftree[level]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-%d routers that speak IP%s",
- level+1, VTY_NEWLINE);
- isis_print_paths (vty, area->spftree[level]->paths);
- }
+ vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
+ VTY_NEWLINE);
+
+ for (level = 0; level < ISIS_LEVELS; level++)
+ {
+ if (area->ip_circuits > 0 && area->spftree[level]
+ && area->spftree[level]->paths->count > 0)
+ {
+ vty_out (vty, "IS-IS paths to level-%d routers that speak IP%s",
+ level + 1, VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree[level]->paths);
+ }
#ifdef HAVE_IPV6
- if (area->ipv6_circuits > 0 && area->spftree6[level]
- && area->spftree6[level]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-%d routers that speak IPv6%s",
- level+1, VTY_NEWLINE);
- isis_print_paths (vty, area->spftree6[level]->paths);
- }
+ if (area->ipv6_circuits > 0 && area->spftree6[level]
+ && area->spftree6[level]->paths->count > 0)
+ {
+ vty_out (vty,
+ "IS-IS paths to level-%d routers that speak IPv6%s",
+ level + 1, VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree6[level]->paths);
+ }
#endif /* HAVE_IPV6 */
+ }
}
- }
return CMD_SUCCESS;
-}
-
+}
DEFUN (show_isis_topology_l1,
show_isis_topology_l1_cmd,
@@ -1212,35 +1312,37 @@
{
struct listnode *node;
struct isis_area *area;
-
+
if (!isis->area_list || isis->area_list->count == 0)
return CMD_SUCCESS;
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
- vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
- VTY_NEWLINE);
-
- if (area->ip_circuits > 0 && area->spftree[0]
- && area->spftree[0]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-1 routers that speak IP%s",
- VTY_NEWLINE);
- isis_print_paths (vty, area->spftree[0]->paths);
- }
+ vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
+ VTY_NEWLINE);
+
+ if (area->ip_circuits > 0 && area->spftree[0]
+ && area->spftree[0]->paths->count > 0)
+ {
+ vty_out (vty, "IS-IS paths to level-1 routers that speak IP%s",
+ VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree[0]->paths);
+ }
#ifdef HAVE_IPV6
- if (area->ipv6_circuits > 0 && area->spftree6[0]
- && area->spftree6[0]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-1 routers that speak IPv6%s",
- VTY_NEWLINE);
- isis_print_paths (vty, area->spftree6[0]->paths);
- }
+ if (area->ipv6_circuits > 0 && area->spftree6[0]
+ && area->spftree6[0]->paths->count > 0)
+ {
+ vty_out (vty, "IS-IS paths to level-1 routers that speak IPv6%s",
+ VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree6[0]->paths);
+ }
#endif /* HAVE_IPV6 */
}
-
return CMD_SUCCESS;
-}
+}
DEFUN (show_isis_topology_l2,
show_isis_topology_l2_cmd,
@@ -1252,36 +1354,37 @@
{
struct listnode *node;
struct isis_area *area;
-
+
if (!isis->area_list || isis->area_list->count == 0)
return CMD_SUCCESS;
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
- vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
- VTY_NEWLINE);
-
- if (area->ip_circuits > 0 && area->spftree[1]
- && area->spftree[1]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-2 routers that speak IP%s",
- VTY_NEWLINE);
- isis_print_paths (vty, area->spftree[1]->paths);
- }
+ vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
+ VTY_NEWLINE);
+
+ if (area->ip_circuits > 0 && area->spftree[1]
+ && area->spftree[1]->paths->count > 0)
+ {
+ vty_out (vty, "IS-IS paths to level-2 routers that speak IP%s",
+ VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree[1]->paths);
+ }
#ifdef HAVE_IPV6
- if (area->ipv6_circuits > 0 && area->spftree6[1]
- && area->spftree6[1]->paths->count > 0) {
- vty_out (vty, "IS-IS paths to level-2 routers that speak IPv6%s",
- VTY_NEWLINE);
- isis_print_paths (vty, area->spftree6[1]->paths);
- }
+ if (area->ipv6_circuits > 0 && area->spftree6[1]
+ && area->spftree6[1]->paths->count > 0)
+ {
+ vty_out (vty, "IS-IS paths to level-2 routers that speak IPv6%s",
+ VTY_NEWLINE);
+ isis_print_paths (vty, area->spftree6[1]->paths);
+ }
#endif /* HAVE_IPV6 */
}
-
return CMD_SUCCESS;
-}
-
+}
void
isis_spf_cmds_init ()
diff --git a/isisd/isis_spf.h b/isisd/isis_spf.h
index 59e4b6b..432f846 100644
--- a/isisd/isis_spf.h
+++ b/isisd/isis_spf.h
@@ -24,17 +24,18 @@
#ifndef _ZEBRA_ISIS_SPF_H
#define _ZEBRA_ISIS_SPF_H
-enum vertextype {
+enum vertextype
+{
VTYPE_PSEUDO_IS = 1,
VTYPE_NONPSEUDO_IS,
VTYPE_ES,
VTYPE_IPREACH_INTERNAL,
VTYPE_IPREACH_EXTERNAL
#ifdef HAVE_IPV6
- ,
+ ,
VTYPE_IP6REACH_INTERNAL,
VTYPE_IP6REACH_EXTERNAL
-#endif /* HAVE_IPV6 */
+#endif /* HAVE_IPV6 */
};
/*
@@ -44,28 +45,28 @@
{
enum vertextype type;
- union {
- u_char id [ISIS_SYS_ID_LEN + 1];
+ union
+ {
+ u_char id[ISIS_SYS_ID_LEN + 1];
struct prefix prefix;
} N;
-
+
struct isis_lsp *lsp;
- u_int32_t d_N; /* d(N) Distance from this IS */
- u_int16_t depth; /* The depth in the imaginary tree */
+ u_int32_t d_N; /* d(N) Distance from this IS */
+ u_int16_t depth; /* The depth in the imaginary tree */
- struct list *Adj_N; /* {Adj(N)} */
-};
-
+ struct list *Adj_N; /* {Adj(N)} */
+};
struct isis_spftree
{
- struct thread *t_spf_periodic; /* periodic spf threads */
- time_t lastrun; /* for scheduling */
- int pending; /* already scheduled */
- struct list *paths; /* the SPT */
- struct list *tents; /* TENT */
+ struct thread *t_spf_periodic; /* periodic spf threads */
+ time_t lastrun; /* for scheduling */
+ int pending; /* already scheduled */
+ struct list *paths; /* the SPT */
+ struct list *tents; /* TENT */
- u_int32_t timerun; /* statistics */
+ u_int32_t timerun; /* statistics */
};
void spftree_area_init (struct isis_area *area);
@@ -75,11 +76,3 @@
int isis_spf_schedule6 (struct isis_area *area, int level);
#endif
#endif /* _ZEBRA_ISIS_SPF_H */
-
-
-
-
-
-
-
-
diff --git a/isisd/isis_tlv.c b/isisd/isis_tlv.c
index d7bbb91..a35b687 100644
--- a/isisd/isis_tlv.c
+++ b/isisd/isis_tlv.c
@@ -48,58 +48,71 @@
void
free_tlv (void *val)
{
- XFREE (MTYPE_ISIS_TLV, val);
-
- return;
+ XFREE (MTYPE_ISIS_TLV, val);
+
+ return;
}
/*
* Called after parsing of a PDU. There shouldn't be any tlv's left, so this
* is only a caution to avoid memory leaks
*/
-void
+void
free_tlvs (struct tlvs *tlvs)
{
- if (tlvs->area_addrs) {
- list_delete (tlvs->area_addrs);
- }
- if (tlvs->is_neighs) {
- list_delete (tlvs->is_neighs);
- }
- if (tlvs->te_is_neighs) {
- list_delete (tlvs->te_is_neighs);
- }
- if (tlvs->es_neighs) {
- list_delete (tlvs->es_neighs);
- }
- if (tlvs->lsp_entries) {
- list_delete (tlvs->lsp_entries);
- }
- if (tlvs->lan_neighs) {
- list_delete (tlvs->lan_neighs);
- }
- if (tlvs->prefix_neighs) {
- list_delete (tlvs->prefix_neighs);
- }
- if (tlvs->ipv4_addrs) {
- list_delete (tlvs->ipv4_addrs);
- }
- if (tlvs->ipv4_int_reachs) {
- list_delete (tlvs->ipv4_int_reachs);
- }
- if (tlvs->ipv4_ext_reachs) {
- list_delete (tlvs->ipv4_ext_reachs);
- }
- if (tlvs->te_ipv4_reachs) {
- list_delete (tlvs->te_ipv4_reachs);
- }
+ if (tlvs->area_addrs)
+ {
+ list_delete (tlvs->area_addrs);
+ }
+ if (tlvs->is_neighs)
+ {
+ list_delete (tlvs->is_neighs);
+ }
+ if (tlvs->te_is_neighs)
+ {
+ list_delete (tlvs->te_is_neighs);
+ }
+ if (tlvs->es_neighs)
+ {
+ list_delete (tlvs->es_neighs);
+ }
+ if (tlvs->lsp_entries)
+ {
+ list_delete (tlvs->lsp_entries);
+ }
+ if (tlvs->lan_neighs)
+ {
+ list_delete (tlvs->lan_neighs);
+ }
+ if (tlvs->prefix_neighs)
+ {
+ list_delete (tlvs->prefix_neighs);
+ }
+ if (tlvs->ipv4_addrs)
+ {
+ list_delete (tlvs->ipv4_addrs);
+ }
+ if (tlvs->ipv4_int_reachs)
+ {
+ list_delete (tlvs->ipv4_int_reachs);
+ }
+ if (tlvs->ipv4_ext_reachs)
+ {
+ list_delete (tlvs->ipv4_ext_reachs);
+ }
+ if (tlvs->te_ipv4_reachs)
+ {
+ list_delete (tlvs->te_ipv4_reachs);
+ }
#ifdef HAVE_IPV6
- if (tlvs->ipv6_addrs) {
- list_delete (tlvs->ipv6_addrs);
- }
- if (tlvs->ipv6_reachs) {
- list_delete (tlvs->ipv6_reachs);
- }
+ if (tlvs->ipv6_addrs)
+ {
+ list_delete (tlvs->ipv6_addrs);
+ }
+ if (tlvs->ipv6_reachs)
+ {
+ list_delete (tlvs->ipv6_reachs);
+ }
#endif /* HAVE_IPV6 */
return;
}
@@ -108,534 +121,584 @@
* Parses the tlvs found in the variant length part of the PDU.
* Caller tells with flags in "expected" which TLV's it is interested in.
*/
-int
-parse_tlvs (char *areatag, u_char *stream, int size, u_int32_t *expected,
- u_int32_t *found, struct tlvs *tlvs)
+int
+parse_tlvs (char *areatag, u_char * stream, int size, u_int32_t * expected,
+ u_int32_t * found, struct tlvs *tlvs)
{
- u_char type, length;
- struct lan_neigh *lan_nei;
- struct area_addr *area_addr;
- struct is_neigh *is_nei;
- struct te_is_neigh *te_is_nei;
- struct es_neigh *es_nei;
- struct lsp_entry *lsp_entry;
- struct in_addr *ipv4_addr;
- struct ipv4_reachability *ipv4_reach;
- struct te_ipv4_reachability *te_ipv4_reach;
+ u_char type, length;
+ struct lan_neigh *lan_nei;
+ struct area_addr *area_addr;
+ struct is_neigh *is_nei;
+ struct te_is_neigh *te_is_nei;
+ struct es_neigh *es_nei;
+ struct lsp_entry *lsp_entry;
+ struct in_addr *ipv4_addr;
+ struct ipv4_reachability *ipv4_reach;
+ struct te_ipv4_reachability *te_ipv4_reach;
#ifdef HAVE_IPV6
- struct in6_addr *ipv6_addr;
- struct ipv6_reachability *ipv6_reach;
- int prefix_octets;
+ struct in6_addr *ipv6_addr;
+ struct ipv6_reachability *ipv6_reach;
+ int prefix_octets;
#endif /* HAVE_IPV6 */
- u_char virtual;
- int value_len, retval = ISIS_OK;
- u_char *pnt = stream;
+ u_char virtual;
+ int value_len, retval = ISIS_OK;
+ u_char *pnt = stream;
*found = 0;
memset (tlvs, 0, sizeof (struct tlvs));
-
- while (pnt < stream + size - 2) {
- type = *pnt;
- length = *(pnt+1);
- pnt += 2;
- value_len = 0;
- if ( pnt + length > stream + size ) {
- zlog_warn ("ISIS-TLV (%s): TLV (type %d, length %d) exceeds packet "
- "boundaries", areatag, type, length);
- retval = ISIS_WARNING;
- break;
- }
- switch (type) {
- case AREA_ADDRESSES:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Address Length |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Area Address |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_AREA_ADDRS;
+
+ while (pnt < stream + size - 2)
+ {
+ type = *pnt;
+ length = *(pnt + 1);
+ pnt += 2;
+ value_len = 0;
+ if (pnt + length > stream + size)
+ {
+ zlog_warn ("ISIS-TLV (%s): TLV (type %d, length %d) exceeds packet "
+ "boundaries", areatag, type, length);
+ retval = ISIS_WARNING;
+ break;
+ }
+ switch (type)
+ {
+ case AREA_ADDRESSES:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Address Length |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Area Address |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_AREA_ADDRS;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("TLV Area Adresses len %d", length);
+ zlog_info ("TLV Area Adresses len %d", length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_AREA_ADDRS) {
- while (length > value_len) {
- area_addr = (struct area_addr*)pnt;
- value_len += area_addr->addr_len + 1;
- pnt += area_addr->addr_len + 1;
- if (!tlvs->area_addrs) tlvs->area_addrs = list_new ();
- listnode_add (tlvs->area_addrs, area_addr);
- }
- } else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_AREA_ADDRS)
+ {
+ while (length > value_len)
+ {
+ area_addr = (struct area_addr *) pnt;
+ value_len += area_addr->addr_len + 1;
+ pnt += area_addr->addr_len + 1;
+ if (!tlvs->area_addrs)
+ tlvs->area_addrs = list_new ();
+ listnode_add (tlvs->area_addrs, area_addr);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case IS_NEIGHBOURS:
- *found |= TLVFLAG_IS_NEIGHS;
+ case IS_NEIGHBOURS:
+ *found |= TLVFLAG_IS_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IS Neighbours length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): IS Neighbours length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (TLVFLAG_IS_NEIGHS & *expected) {
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Virtual Flag |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- */
- virtual = *pnt; /* FIXME: what is the use for this? */
- pnt++;
- value_len ++;
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | 0 | I/E | Default Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Delay Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Expense Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Error Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Neighbour ID |
- * +---------------------------------------------------------------+
- * : :
- */
- while (length > value_len) {
- is_nei = (struct is_neigh*)pnt;
- value_len += 4 + ISIS_SYS_ID_LEN + 1;
- pnt += 4 + ISIS_SYS_ID_LEN + 1;
- if (!tlvs->is_neighs) tlvs->is_neighs = list_new ();
- listnode_add (tlvs->is_neighs, is_nei);
- }
- } else {
- pnt += length;
- }
- break;
+ if (TLVFLAG_IS_NEIGHS & *expected)
+ {
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Virtual Flag |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ */
+ virtual = *pnt; /* FIXME: what is the use for this? */
+ pnt++;
+ value_len++;
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | 0 | I/E | Default Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Delay Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Expense Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Error Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Neighbour ID |
+ * +---------------------------------------------------------------+
+ * : :
+ */
+ while (length > value_len)
+ {
+ is_nei = (struct is_neigh *) pnt;
+ value_len += 4 + ISIS_SYS_ID_LEN + 1;
+ pnt += 4 + ISIS_SYS_ID_LEN + 1;
+ if (!tlvs->is_neighs)
+ tlvs->is_neighs = list_new ();
+ listnode_add (tlvs->is_neighs, is_nei);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case TE_IS_NEIGHBOURS:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Neighbour ID | 7
- * +---------------------------------------------------------------+
- * | TE Metric | 3
- * +---------------------------------------------------------------+
- * | SubTLVs Length | 1
- * +---------------------------------------------------------------+
- * : :
- */
- *found |= TLVFLAG_TE_IS_NEIGHS;
+ case TE_IS_NEIGHBOURS:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Neighbour ID | 7
+ * +---------------------------------------------------------------+
+ * | TE Metric | 3
+ * +---------------------------------------------------------------+
+ * | SubTLVs Length | 1
+ * +---------------------------------------------------------------+
+ * : :
+ */
+ *found |= TLVFLAG_TE_IS_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): Extended IS Neighbours length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): Extended IS Neighbours length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (TLVFLAG_TE_IS_NEIGHS & *expected) {
- while (length > value_len) {
- te_is_nei = (struct te_is_neigh*)pnt;
- value_len += 11;
- pnt += 11;
- /* FIXME - subtlvs are handled here, for now we skip */
- value_len += te_is_nei->sub_tlvs_length;
- pnt += te_is_nei->sub_tlvs_length;
+ if (TLVFLAG_TE_IS_NEIGHS & *expected)
+ {
+ while (length > value_len)
+ {
+ te_is_nei = (struct te_is_neigh *) pnt;
+ value_len += 11;
+ pnt += 11;
+ /* FIXME - subtlvs are handled here, for now we skip */
+ value_len += te_is_nei->sub_tlvs_length;
+ pnt += te_is_nei->sub_tlvs_length;
+ if (!tlvs->te_is_neighs)
+ tlvs->te_is_neighs = list_new ();
+ listnode_add (tlvs->te_is_neighs, te_is_nei);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- if (!tlvs->te_is_neighs) tlvs->te_is_neighs = list_new ();
- listnode_add (tlvs->te_is_neighs, te_is_nei);
- }
- } else {
- pnt += length;
- }
- break;
-
- case ES_NEIGHBOURS:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | 0 | I/E | Default Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Delay Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Expense Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Error Metric |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Neighbour ID |
- * +---------------------------------------------------------------+
- * | Neighbour ID |
- * +---------------------------------------------------------------+
- * : :
- */
+ case ES_NEIGHBOURS:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | 0 | I/E | Default Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Delay Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Expense Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Error Metric |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Neighbour ID |
+ * +---------------------------------------------------------------+
+ * | Neighbour ID |
+ * +---------------------------------------------------------------+
+ * : :
+ */
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): ES Neighbours length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): ES Neighbours length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- *found |= TLVFLAG_ES_NEIGHS;
- if (*expected & TLVFLAG_ES_NEIGHS) {
- es_nei = (struct es_neigh*)pnt;
- value_len += 4;
- pnt += 4;
- while (length > value_len) {
- /* FIXME FIXME FIXME - add to the list */
- /* sys_id->id = pnt;*/
- value_len += ISIS_SYS_ID_LEN;
- pnt += ISIS_SYS_ID_LEN;
- /* if (!es_nei->neigh_ids) es_nei->neigh_ids = sysid;*/
- }
- if (!tlvs->es_neighs) tlvs->es_neighs = list_new ();
- listnode_add (tlvs->es_neighs, es_nei);
- } else {
- pnt += length;
- }
- break;
+ *found |= TLVFLAG_ES_NEIGHS;
+ if (*expected & TLVFLAG_ES_NEIGHS)
+ {
+ es_nei = (struct es_neigh *) pnt;
+ value_len += 4;
+ pnt += 4;
+ while (length > value_len)
+ {
+ /* FIXME FIXME FIXME - add to the list */
+ /* sys_id->id = pnt; */
+ value_len += ISIS_SYS_ID_LEN;
+ pnt += ISIS_SYS_ID_LEN;
+ /* if (!es_nei->neigh_ids) es_nei->neigh_ids = sysid; */
+ }
+ if (!tlvs->es_neighs)
+ tlvs->es_neighs = list_new ();
+ listnode_add (tlvs->es_neighs, es_nei);
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case LAN_NEIGHBOURS:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | LAN Address |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_LAN_NEIGHS;
- #ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): LAN Neigbours length %d",
- areatag,
- length);
- #endif /* EXTREME_TLV_DEBUG */
- if (TLVFLAG_LAN_NEIGHS & *expected) {
- while (length > value_len) {
- lan_nei = (struct lan_neigh*)pnt;
- if (!tlvs->lan_neighs) tlvs->lan_neighs = list_new ();
- listnode_add (tlvs->lan_neighs, lan_nei);
- value_len += ETH_ALEN;
- pnt += ETH_ALEN;
- }
- } else {
- pnt += length;
- }
- break;
-
- case PADDING:
+ case LAN_NEIGHBOURS:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | LAN Address |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_LAN_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("TLV padding %d", length);
+ zlog_info ("ISIS-TLV (%s): LAN Neigbours length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- pnt += length;
- break;
+ if (TLVFLAG_LAN_NEIGHS & *expected)
+ {
+ while (length > value_len)
+ {
+ lan_nei = (struct lan_neigh *) pnt;
+ if (!tlvs->lan_neighs)
+ tlvs->lan_neighs = list_new ();
+ listnode_add (tlvs->lan_neighs, lan_nei);
+ value_len += ETH_ALEN;
+ pnt += ETH_ALEN;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case LSP_ENTRIES:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Remaining Lifetime | 2
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | LSP ID | id+2
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | LSP Sequence Number | 4
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Checksum | 2
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- */
+ case PADDING:
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("LSP Entries length %d",
- areatag,
- length);
+ zlog_info ("TLV padding %d", length);
#endif /* EXTREME_TLV_DEBUG */
- *found |= TLVFLAG_LSP_ENTRIES;
- if (TLVFLAG_LSP_ENTRIES & *expected) {
- while (length > value_len) {
- lsp_entry = (struct lsp_entry*)pnt;
- value_len += 10 + ISIS_SYS_ID_LEN;
- pnt += 10 + ISIS_SYS_ID_LEN;
- if (!tlvs->lsp_entries) tlvs->lsp_entries = list_new ();
- listnode_add (tlvs->lsp_entries, lsp_entry);
- }
- } else {
- pnt += length;
- }
- break;
+ pnt += length;
+ break;
- case CHECKSUM:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | 16 bit fletcher CHECKSUM |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_CHECKSUM;
+ case LSP_ENTRIES:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Remaining Lifetime | 2
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | LSP ID | id+2
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | LSP Sequence Number | 4
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Checksum | 2
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ */
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): Checksum length %d",
- areatag,
- length);
+ zlog_info ("LSP Entries length %d", areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_CHECKSUM) {
- tlvs->checksum = (struct checksum*)pnt;
- }
- pnt += length;
- break;
+ *found |= TLVFLAG_LSP_ENTRIES;
+ if (TLVFLAG_LSP_ENTRIES & *expected)
+ {
+ while (length > value_len)
+ {
+ lsp_entry = (struct lsp_entry *) pnt;
+ value_len += 10 + ISIS_SYS_ID_LEN;
+ pnt += 10 + ISIS_SYS_ID_LEN;
+ if (!tlvs->lsp_entries)
+ tlvs->lsp_entries = list_new ();
+ listnode_add (tlvs->lsp_entries, lsp_entry);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case PROTOCOLS_SUPPORTED:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | NLPID |
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_NLPID;
+ case CHECKSUM:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | 16 bit fletcher CHECKSUM |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_CHECKSUM;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): Protocols Supported length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): Checksum length %d", areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_NLPID) {
- tlvs->nlpids = (struct nlpids*)(pnt-1);
- }
- pnt += length;
- break;
+ if (*expected & TLVFLAG_CHECKSUM)
+ {
+ tlvs->checksum = (struct checksum *) pnt;
+ }
+ pnt += length;
+ break;
- case IPV4_ADDR:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * + IP version 4 address + 4
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_IPV4_ADDR;
+ case PROTOCOLS_SUPPORTED:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | NLPID |
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_NLPID;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IPv4 Address length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): Protocols Supported length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_IPV4_ADDR) {
- while (length > value_len) {
- ipv4_addr = (struct in_addr*)pnt;
- zlog_info ("ISIS-TLV (%s) : IP ADDR %s, pnt %p", areatag,
- inet_ntoa (*ipv4_addr), pnt);
- if (!tlvs->ipv4_addrs) tlvs->ipv4_addrs = list_new();
- listnode_add (tlvs->ipv4_addrs, ipv4_addr);
- value_len += 4;
- pnt += 4;
- }
- } else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_NLPID)
+ {
+ tlvs->nlpids = (struct nlpids *) (pnt - 1);
+ }
+ pnt += length;
+ break;
- case AUTH_INFO:
- *found |= TLVFLAG_AUTH_INFO;
+ case IPV4_ADDR:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * + IP version 4 address + 4
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_IPV4_ADDR;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IS-IS Authentication Information",
- areatag);
+ zlog_info ("ISIS-TLV (%s): IPv4 Address length %d",
+ areatag, length);
+#endif /* EXTREME_TLV_DEBUG */
+ if (*expected & TLVFLAG_IPV4_ADDR)
+ {
+ while (length > value_len)
+ {
+ ipv4_addr = (struct in_addr *) pnt;
+ zlog_info ("ISIS-TLV (%s) : IP ADDR %s, pnt %p", areatag,
+ inet_ntoa (*ipv4_addr), pnt);
+ if (!tlvs->ipv4_addrs)
+ tlvs->ipv4_addrs = list_new ();
+ listnode_add (tlvs->ipv4_addrs, ipv4_addr);
+ value_len += 4;
+ pnt += 4;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
+
+ case AUTH_INFO:
+ *found |= TLVFLAG_AUTH_INFO;
+#ifdef EXTREME_TLV_DEBUG
+ zlog_info ("ISIS-TLV (%s): IS-IS Authentication Information",
+ areatag);
#endif
- if (*expected & TLVFLAG_AUTH_INFO) {
- tlvs->auth_info.type = *pnt;
- pnt++;
- memcpy (tlvs->auth_info.passwd, pnt, length - 1);
- pnt += length - 1;
- }
- else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_AUTH_INFO)
+ {
+ tlvs->auth_info.type = *pnt;
+ pnt++;
+ memcpy (tlvs->auth_info.passwd, pnt, length - 1);
+ pnt += length - 1;
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case DYNAMIC_HOSTNAME:
- *found |= TLVFLAG_DYN_HOSTNAME;
+ case DYNAMIC_HOSTNAME:
+ *found |= TLVFLAG_DYN_HOSTNAME;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): Dynamic Hostname length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): Dynamic Hostname length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_DYN_HOSTNAME) {
- /* the length is also included in the pointed struct */
- tlvs->hostname = (struct hostname*)(pnt - 1);
- }
- pnt += length;
- break;
+ if (*expected & TLVFLAG_DYN_HOSTNAME)
+ {
+ /* the length is also included in the pointed struct */
+ tlvs->hostname = (struct hostname *) (pnt - 1);
+ }
+ pnt += length;
+ break;
- case TE_ROUTER_ID:
- /* +---------------------------------------------------------------+
- * + Router ID + 4
- * +---------------------------------------------------------------+
- */
- *found |= TLVFLAG_TE_ROUTER_ID;
+ case TE_ROUTER_ID:
+ /* +---------------------------------------------------------------+
+ * + Router ID + 4
+ * +---------------------------------------------------------------+
+ */
+ *found |= TLVFLAG_TE_ROUTER_ID;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): TE Router ID %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): TE Router ID %d", areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_TE_ROUTER_ID) {
- tlvs->router_id = (struct te_router_id*)(pnt);
- }
- pnt += length;
- break;
+ if (*expected & TLVFLAG_TE_ROUTER_ID)
+ {
+ tlvs->router_id = (struct te_router_id *) (pnt);
+ }
+ pnt += length;
+ break;
- case IPV4_INT_REACHABILITY:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | 0 | I/E | Default Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Delay Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Expense Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Error Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | ip address | 4
- * +---------------------------------------------------------------+
- * | address mask | 4
- * +---------------------------------------------------------------+
- * : :
- */
- *found |= TLVFLAG_IPV4_INT_REACHABILITY;
+ case IPV4_INT_REACHABILITY:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | 0 | I/E | Default Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Delay Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Expense Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Error Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | ip address | 4
+ * +---------------------------------------------------------------+
+ * | address mask | 4
+ * +---------------------------------------------------------------+
+ * : :
+ */
+ *found |= TLVFLAG_IPV4_INT_REACHABILITY;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IPv4 internal Reachability length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): IPv4 internal Reachability length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_IPV4_INT_REACHABILITY) {
- while (length > value_len) {
- ipv4_reach = (struct ipv4_reachability*)pnt;
- if (!tlvs->ipv4_int_reachs) tlvs->ipv4_int_reachs = list_new();
- listnode_add (tlvs->ipv4_int_reachs, ipv4_reach);
- value_len += 12;
- pnt += 12;
- }
- }
- else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_IPV4_INT_REACHABILITY)
+ {
+ while (length > value_len)
+ {
+ ipv4_reach = (struct ipv4_reachability *) pnt;
+ if (!tlvs->ipv4_int_reachs)
+ tlvs->ipv4_int_reachs = list_new ();
+ listnode_add (tlvs->ipv4_int_reachs, ipv4_reach);
+ value_len += 12;
+ pnt += 12;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case IPV4_EXT_REACHABILITY:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | 0 | I/E | Default Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Delay Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Expense Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | S | I/E | Error Metric | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | ip address | 4
- * +---------------------------------------------------------------+
- * | address mask | 4
- * +---------------------------------------------------------------+
- * : :
- */
- *found |= TLVFLAG_IPV4_EXT_REACHABILITY;
+ case IPV4_EXT_REACHABILITY:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | 0 | I/E | Default Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Delay Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Expense Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | S | I/E | Error Metric | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | ip address | 4
+ * +---------------------------------------------------------------+
+ * | address mask | 4
+ * +---------------------------------------------------------------+
+ * : :
+ */
+ *found |= TLVFLAG_IPV4_EXT_REACHABILITY;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IPv4 external Reachability length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): IPv4 external Reachability length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_IPV4_EXT_REACHABILITY) {
- while (length > value_len) {
- ipv4_reach = (struct ipv4_reachability*)pnt;
- if (!tlvs->ipv4_ext_reachs)
- tlvs->ipv4_ext_reachs = list_new();
- listnode_add (tlvs->ipv4_ext_reachs, ipv4_reach);
- value_len += 12;
- pnt += 12;
- }
- }
- else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_IPV4_EXT_REACHABILITY)
+ {
+ while (length > value_len)
+ {
+ ipv4_reach = (struct ipv4_reachability *) pnt;
+ if (!tlvs->ipv4_ext_reachs)
+ tlvs->ipv4_ext_reachs = list_new ();
+ listnode_add (tlvs->ipv4_ext_reachs, ipv4_reach);
+ value_len += 12;
+ pnt += 12;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case TE_IPV4_REACHABILITY:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | TE Metric | 4
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | U/D | sTLV? | Prefix Mask Len | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Prefix | 0-4
- * +---------------------------------------------------------------+
- * | sub tlvs |
- * +---------------------------------------------------------------+
- * : :
- */
- *found |= TLVFLAG_TE_IPV4_REACHABILITY;
+ case TE_IPV4_REACHABILITY:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | TE Metric | 4
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | U/D | sTLV? | Prefix Mask Len | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Prefix | 0-4
+ * +---------------------------------------------------------------+
+ * | sub tlvs |
+ * +---------------------------------------------------------------+
+ * : :
+ */
+ *found |= TLVFLAG_TE_IPV4_REACHABILITY;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IPv4 extended Reachability length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): IPv4 extended Reachability length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_TE_IPV4_REACHABILITY) {
- while (length > value_len) {
- te_ipv4_reach = (struct te_ipv4_reachability*)pnt;
- if (!tlvs->te_ipv4_reachs) tlvs->te_ipv4_reachs = list_new();
- listnode_add (tlvs->te_ipv4_reachs, te_ipv4_reach);
- /* this trickery is permitable since no subtlvs are defined */
- value_len += 5 + ((te_ipv4_reach->control & 0x3F) ?
- ((((te_ipv4_reach->control & 0x3F)-1)>>3)+1) : 0);
- pnt += 5 + ((te_ipv4_reach->control & 0x3F) ?
- ((((te_ipv4_reach->control & 0x3F)-1)>>3)+1) : 0);
- }
- }
- else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_TE_IPV4_REACHABILITY)
+ {
+ while (length > value_len)
+ {
+ te_ipv4_reach = (struct te_ipv4_reachability *) pnt;
+ if (!tlvs->te_ipv4_reachs)
+ tlvs->te_ipv4_reachs = list_new ();
+ listnode_add (tlvs->te_ipv4_reachs, te_ipv4_reach);
+ /* this trickery is permitable since no subtlvs are defined */
+ value_len += 5 + ((te_ipv4_reach->control & 0x3F) ?
+ ((((te_ipv4_reach->control & 0x3F) -
+ 1) >> 3) + 1) : 0);
+ pnt += 5 + ((te_ipv4_reach->control & 0x3F) ?
+ ((((te_ipv4_reach->control & 0x3F) - 1) >> 3) + 1) : 0);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
#ifdef HAVE_IPV6
- case IPV6_ADDR:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * + IP version 6 address + 16
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * : :
- */
- *found |= TLVFLAG_IPV6_ADDR;
+ case IPV6_ADDR:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * + IP version 6 address + 16
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * : :
+ */
+ *found |= TLVFLAG_IPV6_ADDR;
#ifdef EXTREME_TLV_DEBUG
- zlog_info ("ISIS-TLV (%s): IPv6 Address length %d",
- areatag,
- length);
+ zlog_info ("ISIS-TLV (%s): IPv6 Address length %d",
+ areatag, length);
#endif /* EXTREME_TLV_DEBUG */
- if (*expected & TLVFLAG_IPV6_ADDR) {
- while (length > value_len) {
- ipv6_addr = (struct in6_addr*)pnt;
- if (!tlvs->ipv6_addrs) tlvs->ipv6_addrs = list_new();
- listnode_add (tlvs->ipv6_addrs, ipv6_addr);
- value_len += 16;
- pnt += 16;
- }
- } else {
- pnt += length;
- }
- break;
+ if (*expected & TLVFLAG_IPV6_ADDR)
+ {
+ while (length > value_len)
+ {
+ ipv6_addr = (struct in6_addr *) pnt;
+ if (!tlvs->ipv6_addrs)
+ tlvs->ipv6_addrs = list_new ();
+ listnode_add (tlvs->ipv6_addrs, ipv6_addr);
+ value_len += 16;
+ pnt += 16;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
- case IPV6_REACHABILITY:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Default Metric | 4
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Control Informantion |
- * +---------------------------------------------------------------+
- * | IPv6 Prefix Length |--+
- * +---------------------------------------------------------------+ |
- * | IPv6 Prefix |<-+
- * +---------------------------------------------------------------+
- */
- *found |= TLVFLAG_IPV6_REACHABILITY;
- if (*expected & TLVFLAG_IPV6_REACHABILITY) {
- while (length > value_len) {
- ipv6_reach = (struct ipv6_reachability*)pnt;
- prefix_octets = ((ipv6_reach->prefix_len + 7) / 8);
- value_len += prefix_octets + 6;
- pnt += prefix_octets + 6;
- /* FIXME: sub-tlvs */
- if (!tlvs->ipv6_reachs) tlvs->ipv6_reachs = list_new();
- listnode_add (tlvs->ipv6_reachs, ipv6_reach);
- }
- } else {
- pnt += length;
- }
- break;
+ case IPV6_REACHABILITY:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Default Metric | 4
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Control Informantion |
+ * +---------------------------------------------------------------+
+ * | IPv6 Prefix Length |--+
+ * +---------------------------------------------------------------+ |
+ * | IPv6 Prefix |<-+
+ * +---------------------------------------------------------------+
+ */
+ *found |= TLVFLAG_IPV6_REACHABILITY;
+ if (*expected & TLVFLAG_IPV6_REACHABILITY)
+ {
+ while (length > value_len)
+ {
+ ipv6_reach = (struct ipv6_reachability *) pnt;
+ prefix_octets = ((ipv6_reach->prefix_len + 7) / 8);
+ value_len += prefix_octets + 6;
+ pnt += prefix_octets + 6;
+ /* FIXME: sub-tlvs */
+ if (!tlvs->ipv6_reachs)
+ tlvs->ipv6_reachs = list_new ();
+ listnode_add (tlvs->ipv6_reachs, ipv6_reach);
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
+ break;
#endif /* HAVE_IPV6 */
- case WAY3_HELLO:
- /* +---------------------------------------------------------------+
- * | Adjacency state | 1
- * +---------------------------------------------------------------+
- * | Extended Local Circuit ID | 4
- * +---------------------------------------------------------------+
- * | Neighbor System ID (If known) | 0-8
- * (probably 6)
- * +---------------------------------------------------------------+
- * | Neighbor Local Circuit ID (If known) | 4
- * +---------------------------------------------------------------+
- */
- *found |= TLVFLAG_3WAY_HELLO;
- if (*expected & TLVFLAG_3WAY_HELLO) {
- while (length > value_len) {
- /* FIXME: make this work */
+ case WAY3_HELLO:
+ /* +---------------------------------------------------------------+
+ * | Adjacency state | 1
+ * +---------------------------------------------------------------+
+ * | Extended Local Circuit ID | 4
+ * +---------------------------------------------------------------+
+ * | Neighbor System ID (If known) | 0-8
+ * (probably 6)
+ * +---------------------------------------------------------------+
+ * | Neighbor Local Circuit ID (If known) | 4
+ * +---------------------------------------------------------------+
+ */
+ *found |= TLVFLAG_3WAY_HELLO;
+ if (*expected & TLVFLAG_3WAY_HELLO)
+ {
+ while (length > value_len)
+ {
+ /* FIXME: make this work */
/* Adjacency State (one octet):
0 = Up
1 = Initializing
@@ -644,56 +707,58 @@
Neighbor System ID if known (zero to eight octets)
Neighbor Extended Local Circuit ID (four octets, if Neighbor
System ID is present) */
- pnt += length;
- }
- } else {
- pnt += length;
- }
+ pnt += length;
+ }
+ }
+ else
+ {
+ pnt += length;
+ }
- break;
- case GRACEFUL_RESTART:
- /* +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Reserved | SA | RA | RR | 1
- * +-------+-------+-------+-------+-------+-------+-------+-------+
- * | Remaining Time | 2
- * +---------------------------------------------------------------+
- * | Restarting Neighbor ID (If known) | 0-8
- * +---------------------------------------------------------------+
- */
- *found |= TLVFLAG_GRACEFUL_RESTART;
- if (*expected & TLVFLAG_GRACEFUL_RESTART) {
- /* FIXME: make this work */
- }
- pnt += length;
- break;
+ break;
+ case GRACEFUL_RESTART:
+ /* +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Reserved | SA | RA | RR | 1
+ * +-------+-------+-------+-------+-------+-------+-------+-------+
+ * | Remaining Time | 2
+ * +---------------------------------------------------------------+
+ * | Restarting Neighbor ID (If known) | 0-8
+ * +---------------------------------------------------------------+
+ */
+ *found |= TLVFLAG_GRACEFUL_RESTART;
+ if (*expected & TLVFLAG_GRACEFUL_RESTART)
+ {
+ /* FIXME: make this work */
+ }
+ pnt += length;
+ break;
- default:
- zlog_warn ("ISIS-TLV (%s): unsupported TLV type %d, length %d",
- areatag,
- type,
- length);
+ default:
+ zlog_warn ("ISIS-TLV (%s): unsupported TLV type %d, length %d",
+ areatag, type, length);
- retval = ISIS_WARNING;
- pnt += length;
- break;
+ retval = ISIS_WARNING;
+ pnt += length;
+ break;
+ }
}
- }
-
+
return retval;
}
int
-add_tlv (u_char tag, u_char len, u_char *value, struct stream *stream)
+add_tlv (u_char tag, u_char len, u_char * value, struct stream *stream)
{
- if (STREAM_SIZE (stream) - stream_get_putp (stream) < len + 2) {
- zlog_warn ("No room for TLV of type %d", tag);
- return ISIS_WARNING;
- }
+ if (STREAM_SIZE (stream) - stream_get_putp (stream) < len + 2)
+ {
+ zlog_warn ("No room for TLV of type %d", tag);
+ return ISIS_WARNING;
+ }
- stream_putc (stream, tag); /* TAG */
- stream_putc (stream, len); /* LENGTH */
- stream_put (stream, value, (int)len); /* VALUE */
+ stream_putc (stream, tag); /* TAG */
+ stream_putc (stream, len); /* LENGTH */
+ stream_put (stream, value, (int) len); /* VALUE */
#ifdef EXTREME_DEBUG
zlog_info ("Added TLV %d len %d", tag, len);
@@ -701,93 +766,96 @@
return ISIS_OK;
}
-
int
-tlv_add_area_addrs (struct list *area_addrs, struct stream *stream)
+tlv_add_area_addrs (struct list *area_addrs, struct stream *stream)
{
struct listnode *node;
struct area_addr *area_addr;
- u_char value [255];
+ u_char value[255];
u_char *pos = value;
-
- for (node = listhead (area_addrs); node; nextnode (node)) {
- area_addr = getdata (node);
- if (pos - value + area_addr->addr_len > 255)
- goto err;
- *pos = area_addr->addr_len;
- pos ++;
- memcpy (pos, area_addr->area_addr, (int)area_addr->addr_len);
- pos += area_addr->addr_len;
- }
-
+
+ for (node = listhead (area_addrs); node; nextnode (node))
+ {
+ area_addr = getdata (node);
+ if (pos - value + area_addr->addr_len > 255)
+ goto err;
+ *pos = area_addr->addr_len;
+ pos++;
+ memcpy (pos, area_addr->area_addr, (int) area_addr->addr_len);
+ pos += area_addr->addr_len;
+ }
+
return add_tlv (AREA_ADDRESSES, pos - value, value, stream);
- err:
+err:
zlog_warn ("tlv_add_area_addrs(): TLV longer than 255");
return ISIS_WARNING;
}
-int tlv_add_is_neighs (struct list *is_neighs, struct stream *stream)
+int
+tlv_add_is_neighs (struct list *is_neighs, struct stream *stream)
{
struct listnode *node;
struct is_neigh *is_neigh;
- u_char value [255];
+ u_char value[255];
u_char *pos = value;
int retval;
- *pos = 0; /*is_neigh->virtual; */
- pos ++;
+ *pos = 0; /*is_neigh->virtual; */
+ pos++;
- for (node = listhead (is_neighs); node; nextnode (node)) {
- is_neigh = getdata (node);
- if (pos - value + IS_NEIGHBOURS_LEN > 255) {
- retval = add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+ for (node = listhead (is_neighs); node; nextnode (node))
+ {
+ is_neigh = getdata (node);
+ if (pos - value + IS_NEIGHBOURS_LEN > 255)
+ {
+ retval = add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ *pos = is_neigh->metrics.metric_default;
+ pos++;
+ *pos = is_neigh->metrics.metric_delay;
+ pos++;
+ *pos = is_neigh->metrics.metric_expense;
+ pos++;
+ *pos = is_neigh->metrics.metric_error;
+ pos++;
+ memcpy (pos, is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
+ pos += ISIS_SYS_ID_LEN + 1;
}
- *pos = is_neigh->metrics.metric_default;
- pos ++;
- *pos = is_neigh->metrics.metric_delay;
- pos ++;
- *pos = is_neigh->metrics.metric_expense;
- pos ++;
- *pos = is_neigh->metrics.metric_error;
- pos ++;
- memcpy (pos, is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
- pos += ISIS_SYS_ID_LEN + 1;
- }
return add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
}
-
int
tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream)
{
struct listnode *node;
u_char *snpa;
- u_char value [255];
+ u_char value[255];
u_char *pos = value;
int retval;
- for (node = listhead (lan_neighs); node; nextnode (node)) {
- snpa = getdata (node);
- if (pos - value + ETH_ALEN > 255) {
- retval = add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+ for (node = listhead (lan_neighs); node; nextnode (node))
+ {
+ snpa = getdata (node);
+ if (pos - value + ETH_ALEN > 255)
+ {
+ retval = add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ memcpy (pos, snpa, ETH_ALEN);
+ pos += ETH_ALEN;
}
- memcpy (pos, snpa, ETH_ALEN);
- pos += ETH_ALEN;
- }
return add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
}
-
/*
u_char value[255];
u_char *pos = value;
@@ -805,13 +873,13 @@
int
tlv_add_nlpid (struct nlpids *nlpids, struct stream *stream)
{
-
- return add_tlv (PROTOCOLS_SUPPORTED, nlpids->count,
- nlpids->nlpids, stream);
+
+ return add_tlv (PROTOCOLS_SUPPORTED, nlpids->count, nlpids->nlpids, stream);
}
-int tlv_add_authinfo (char auth_type, char auth_len, char *auth_value,
- struct stream *stream)
+int
+tlv_add_authinfo (char auth_type, char auth_len, char *auth_value,
+ struct stream *stream)
{
u_char value[255];
u_char *pos = value;
@@ -825,9 +893,8 @@
tlv_add_checksum (struct checksum *checksum, struct stream *stream)
{
u_char value[255];
- u_char *pos = value;
- return add_tlv (CHECKSUM, pos - value,
- value, stream);
+ u_char *pos = value;
+ return add_tlv (CHECKSUM, pos - value, value, stream);
}
int
@@ -839,93 +906,101 @@
u_char *pos = value;
int retval;
- for (node = listhead (ip_addrs); node; nextnode (node)) {
- ipv4 = getdata (node);
- if (pos - value + IPV4_MAX_BYTELEN > 255) {
- retval = add_tlv (IPV4_ADDR, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+ for (node = listhead (ip_addrs); node; nextnode (node))
+ {
+ ipv4 = getdata (node);
+ if (pos - value + IPV4_MAX_BYTELEN > 255)
+ {
+ retval = add_tlv (IPV4_ADDR, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ *(u_int32_t *) pos = ipv4->prefix.s_addr;
+ pos += IPV4_MAX_BYTELEN;
}
- *(u_int32_t*)pos = ipv4->prefix.s_addr;
- pos += IPV4_MAX_BYTELEN;
- }
-
+
return add_tlv (IPV4_ADDR, pos - value, value, stream);
}
int
tlv_add_dynamic_hostname (struct hostname *hostname, struct stream *stream)
{
- return add_tlv (DYNAMIC_HOSTNAME, hostname->namelen, hostname->name, stream);
+ return add_tlv (DYNAMIC_HOSTNAME, hostname->namelen, hostname->name,
+ stream);
}
-int
+int
tlv_add_lsp_entries (struct list *lsps, struct stream *stream)
{
struct listnode *node;
struct isis_lsp *lsp;
- u_char value [255];
+ u_char value[255];
u_char *pos = value;
int retval;
- for (node = listhead (lsps); node; nextnode (node)) {
- lsp = getdata (node);
- if (pos - value + LSP_ENTRIES_LEN > 255) {
- retval = add_tlv (LSP_ENTRIES, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+ for (node = listhead (lsps); node; nextnode (node))
+ {
+ lsp = getdata (node);
+ if (pos - value + LSP_ENTRIES_LEN > 255)
+ {
+ retval = add_tlv (LSP_ENTRIES, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ *((u_int16_t *) pos) = lsp->lsp_header->rem_lifetime;
+ pos += 2;
+ memcpy (pos, lsp->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 2);
+ pos += ISIS_SYS_ID_LEN + 2;
+ *((u_int32_t *) pos) = lsp->lsp_header->seq_num;
+ pos += 4;
+ *((u_int16_t *) pos) = lsp->lsp_header->checksum;
+ pos += 2;
}
- *((u_int16_t*)pos) = lsp->lsp_header->rem_lifetime;
- pos += 2;
- memcpy (pos, lsp->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 2);
- pos += ISIS_SYS_ID_LEN + 2;
- *((u_int32_t*)pos) = lsp->lsp_header->seq_num;
- pos += 4;
- *((u_int16_t*)pos) = lsp->lsp_header->checksum;
- pos += 2;
- }
-
+
return add_tlv (LSP_ENTRIES, pos - value, value, stream);
}
-int
+int
tlv_add_ipv4_reachs (struct list *ipv4_reachs, struct stream *stream)
{
struct listnode *node;
struct ipv4_reachability *reach;
- u_char value [255];
+ u_char value[255];
u_char *pos = value;
int retval;
- for (node = listhead (ipv4_reachs); node; nextnode (node)) {
- reach = getdata (node);
- if (pos - value + IPV4_REACH_LEN > 255) {
- retval = add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+ for (node = listhead (ipv4_reachs); node; nextnode (node))
+ {
+ reach = getdata (node);
+ if (pos - value + IPV4_REACH_LEN > 255)
+ {
+ retval =
+ add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ *pos = reach->metrics.metric_default;
+ pos++;
+ *pos = reach->metrics.metric_delay;
+ pos++;
+ *pos = reach->metrics.metric_expense;
+ pos++;
+ *pos = reach->metrics.metric_error;
+ pos++;
+ *(u_int32_t *) pos = reach->prefix.s_addr;
+ pos += IPV4_MAX_BYTELEN;
+ *(u_int32_t *) pos = reach->mask.s_addr;
+ pos += IPV4_MAX_BYTELEN;
}
- *pos = reach->metrics.metric_default;
- pos ++;
- *pos = reach->metrics.metric_delay;
- pos ++;
- *pos = reach->metrics.metric_expense;
- pos ++;
- *pos = reach->metrics.metric_error;
- pos ++;
- *(u_int32_t*)pos = reach->prefix.s_addr;
- pos += IPV4_MAX_BYTELEN;
- *(u_int32_t*)pos = reach->mask.s_addr;
- pos += IPV4_MAX_BYTELEN;
- }
-
-
+
+
return add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
}
-#ifdef HAVE_IPV6
+#ifdef HAVE_IPV6
int
tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream)
{
@@ -934,19 +1009,21 @@
u_char value[255];
u_char *pos = value;
int retval;
-
- for (node = listhead (ipv6_addrs); node; nextnode (node)) {
- ipv6 = getdata (node);
- if (pos - value + IPV6_MAX_BYTELEN > 255) {
- retval = add_tlv (IPV6_ADDR, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+
+ for (node = listhead (ipv6_addrs); node; nextnode (node))
+ {
+ ipv6 = getdata (node);
+ if (pos - value + IPV6_MAX_BYTELEN > 255)
+ {
+ retval = add_tlv (IPV6_ADDR, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ memcpy (pos, ipv6->prefix.s6_addr, IPV6_MAX_BYTELEN);
+ pos += IPV6_MAX_BYTELEN;
}
- memcpy (pos, ipv6->prefix.s6_addr, IPV6_MAX_BYTELEN);
- pos += IPV6_MAX_BYTELEN;
- }
-
+
return add_tlv (IPV6_ADDR, pos - value, value, stream);
}
@@ -958,26 +1035,28 @@
u_char value[255];
u_char *pos = value;
int retval, prefix_octets;
-
- for (node = listhead (ipv6_reachs); node; nextnode (node)) {
- ip6reach = getdata (node);
- if (pos - value + IPV6_MAX_BYTELEN + 6 > 255) {
- retval = add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
- if (retval != ISIS_OK)
- return retval;
- pos = value;
+
+ for (node = listhead (ipv6_reachs); node; nextnode (node))
+ {
+ ip6reach = getdata (node);
+ if (pos - value + IPV6_MAX_BYTELEN + 6 > 255)
+ {
+ retval = add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
+ if (retval != ISIS_OK)
+ return retval;
+ pos = value;
+ }
+ *(uint32_t *) pos = ip6reach->metric;
+ pos += 4;
+ *pos = ip6reach->control_info;
+ pos++;
+ prefix_octets = ((ip6reach->prefix_len + 7) / 8);
+ *pos = ip6reach->prefix_len;
+ pos++;
+ memcpy (pos, ip6reach->prefix, prefix_octets);
+ pos += prefix_octets;
}
- *(uint32_t*)pos = ip6reach->metric;
- pos += 4;
- *pos = ip6reach->control_info;
- pos++;
- prefix_octets = ((ip6reach->prefix_len + 7) / 8);
- *pos = ip6reach->prefix_len;
- pos++;
- memcpy (pos, ip6reach->prefix, prefix_octets);
- pos += prefix_octets;
- }
-
+
return add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
}
#endif /* HAVE_IPV6 */
@@ -986,36 +1065,38 @@
tlv_add_padding (struct stream *stream)
{
unsigned long putp, endp;
- int fullpads, i, left;
-
+ int fullpads, i, left;
+
/*
* How many times can we add full padding ?
*/
- fullpads = (STREAM_SIZE(stream) - stream_get_endp (stream)) / 257;
- for (i = 0; i < fullpads; i ++) {
- if (!stream_putc (stream, (u_char)PADDING)) /* TAG */
- goto err;
- if (!stream_putc (stream, (u_char)255)) /* LENGHT */
- goto err;
- endp = stream_get_endp (stream);
- putp = stream_get_putp (stream);
- if (putp != endp)
- zlog_warn ("tvl_add_padding endp %ld while putp %ld", endp, putp);
- stream_set_putp (stream, putp + 255); /* VALUE */
- stream->endp = stream->putp;
- }
-
- left = STREAM_SIZE(stream) - stream_get_putp (stream);
-
+ fullpads = (STREAM_SIZE (stream) - stream_get_endp (stream)) / 257;
+ for (i = 0; i < fullpads; i++)
+ {
+ if (!stream_putc (stream, (u_char) PADDING)) /* TAG */
+ goto err;
+ if (!stream_putc (stream, (u_char) 255)) /* LENGHT */
+ goto err;
+ endp = stream_get_endp (stream);
+ putp = stream_get_putp (stream);
+ if (putp != endp)
+ zlog_warn ("tvl_add_padding endp %ld while putp %ld", endp, putp);
+ stream_set_putp (stream, putp + 255); /* VALUE */
+ stream->endp = stream->putp;
+ }
+
+ left = STREAM_SIZE (stream) - stream_get_putp (stream);
+
if (left < 2)
return ISIS_OK;
-
- if (left == 2) {
- stream_putc (stream, PADDING);
- stream_putc (stream, 0);
- return ISIS_OK;
- }
-
+
+ if (left == 2)
+ {
+ stream_putc (stream, PADDING);
+ stream_putc (stream, 0);
+ return ISIS_OK;
+ }
+
stream_putc (stream, PADDING);
stream_putc (stream, left - 2);
stream_set_putp (stream, stream_get_putp (stream) + left - 2);
@@ -1023,7 +1104,7 @@
return ISIS_OK;
- err:
+err:
zlog_warn ("tlv_add_padding(): no room for tlv");
return ISIS_WARNING;
}
diff --git a/isisd/isis_tlv.h b/isisd/isis_tlv.h
index e030385..e4fd9e0 100644
--- a/isisd/isis_tlv.h
+++ b/isisd/isis_tlv.h
@@ -95,86 +95,98 @@
#define IS_NEIGHBOURS_LEN (ISIS_SYS_ID_LEN + 5)
#define LAN_NEIGHBOURS_LEN 6
-#define LSP_ENTRIES_LEN (10 + ISIS_SYS_ID_LEN) /* FIXME: should be entry */
+#define LSP_ENTRIES_LEN (10 + ISIS_SYS_ID_LEN) /* FIXME: should be entry */
#define IPV4_REACH_LEN 12
#define IPV6_REACH_LEN 22
/* struct for neighbor */
-struct is_neigh{
- struct metric metrics;
- u_char neigh_id[ISIS_SYS_ID_LEN + 1];
+struct is_neigh
+{
+ struct metric metrics;
+ u_char neigh_id[ISIS_SYS_ID_LEN + 1];
};
/* struct for te is neighbor */
-struct te_is_neigh{
- u_char neigh_id[ISIS_SYS_ID_LEN + 1];
- u_char te_metric[3];
- u_char sub_tlvs_length;
+struct te_is_neigh
+{
+ u_char neigh_id[ISIS_SYS_ID_LEN + 1];
+ u_char te_metric[3];
+ u_char sub_tlvs_length;
};
/* struct for es neighbors */
-struct es_neigh{
- struct metric metrics;
+struct es_neigh
+{
+ struct metric metrics;
/* approximate position of first, we use the
* length ((uchar*)metric-1) to know all */
- u_char first_es_neigh[ISIS_SYS_ID_LEN];
-
+ u_char first_es_neigh[ISIS_SYS_ID_LEN];
+
};
-struct partition_desig_level2_is{
- struct list *isis_system_ids;
+struct partition_desig_level2_is
+{
+ struct list *isis_system_ids;
};
/* struct for lan neighbors */
-struct lan_neigh{
- u_char LAN_addr[6];
+struct lan_neigh
+{
+ u_char LAN_addr[6];
};
/* struct for LSP entry */
-struct lsp_entry {
- u_int16_t rem_lifetime;
- u_char lsp_id[ISIS_SYS_ID_LEN + 2];
- u_int32_t seq_num;
- u_int16_t checksum;
-} __attribute__((packed));
+struct lsp_entry
+{
+ u_int16_t rem_lifetime;
+ u_char lsp_id[ISIS_SYS_ID_LEN + 2];
+ u_int32_t seq_num;
+ u_int16_t checksum;
+} __attribute__ ((packed));
/* struct for checksum */
-struct checksum {
+struct checksum
+{
u_int16_t checksum;
};
/* ipv4 reachability */
-struct ipv4_reachability {
+struct ipv4_reachability
+{
struct metric metrics;
struct in_addr prefix;
- struct in_addr mask;
+ struct in_addr mask;
};
/* te router id */
-struct te_router_id {
- struct in_addr id;
+struct te_router_id
+{
+ struct in_addr id;
};
/* te ipv4 reachability */
-struct te_ipv4_reachability {
- u_int32_t te_metric;
- u_char control;
- u_char prefix_start; /* since this is variable length by nature it only */
-}; /* points to an approximate location */
+struct te_ipv4_reachability
+{
+ u_int32_t te_metric;
+ u_char control;
+ u_char prefix_start; /* since this is variable length by nature it only */
+}; /* points to an approximate location */
-struct idrp_info {
+struct idrp_info
+{
u_char len;
u_char *value;
};
#ifdef HAVE_IPV6
-struct ipv6_reachability {
- u_int32_t metric;
- u_char control_info;
- u_char prefix_len;
- u_char prefix[16];
+struct ipv6_reachability
+{
+ u_int32_t metric;
+ u_char control_info;
+ u_char prefix_len;
+ u_char prefix[16];
};
#endif /* HAVE_IPV6 */
@@ -190,27 +202,28 @@
/*
* Pointer to each tlv type, filled by parse_tlvs()
*/
-struct tlvs {
- struct list *area_addrs;
- struct list *is_neighs;
- struct list *te_is_neighs;
- struct list *es_neighs;
- struct list *lsp_entries;
- struct list *prefix_neighs;
- struct list *lan_neighs;
- struct checksum *checksum;
- struct nlpids *nlpids;
- struct list *ipv4_addrs;
- struct list *ipv4_int_reachs;
- struct list *ipv4_ext_reachs;
- struct list *te_ipv4_reachs;
- struct hostname *hostname;
- struct te_router_id *router_id;
+struct tlvs
+{
+ struct list *area_addrs;
+ struct list *is_neighs;
+ struct list *te_is_neighs;
+ struct list *es_neighs;
+ struct list *lsp_entries;
+ struct list *prefix_neighs;
+ struct list *lan_neighs;
+ struct checksum *checksum;
+ struct nlpids *nlpids;
+ struct list *ipv4_addrs;
+ struct list *ipv4_int_reachs;
+ struct list *ipv4_ext_reachs;
+ struct list *te_ipv4_reachs;
+ struct hostname *hostname;
+ struct te_router_id *router_id;
#ifdef HAVE_IPV6
- struct list *ipv6_addrs;
- struct list *ipv6_reachs;
+ struct list *ipv6_addrs;
+ struct list *ipv6_reachs;
#endif
- struct isis_passwd auth_info;
+ struct isis_passwd auth_info;
};
/*
@@ -240,32 +253,29 @@
#define TLVFLAG_CHECKSUM (1<<20)
#define TLVFLAG_GRACEFUL_RESTART (1<<21)
-void init_tlvs (struct tlvs *tlvs, uint32_t expected);
-void free_tlvs (struct tlvs *tlvs);
-int parse_tlvs (char *areatag, u_char *stream, int size, u_int32_t *expected,
- u_int32_t *found, struct tlvs *tlvs);
-void free_tlv (void *val);
+void init_tlvs (struct tlvs *tlvs, uint32_t expected);
+void free_tlvs (struct tlvs *tlvs);
+int parse_tlvs (char *areatag, u_char * stream, int size,
+ u_int32_t * expected, u_int32_t * found, struct tlvs *tlvs);
+void free_tlv (void *val);
-int tlv_add_area_addrs (struct list *area_addrs, struct stream *stream);
-int tlv_add_is_neighs (struct list *is_neighs, struct stream *stream);
-int tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream);
-int tlv_add_nlpid (struct nlpids *nlpids, struct stream *stream);
-int tlv_add_checksum (struct checksum *checksum,
+int tlv_add_area_addrs (struct list *area_addrs, struct stream *stream);
+int tlv_add_is_neighs (struct list *is_neighs, struct stream *stream);
+int tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream);
+int tlv_add_nlpid (struct nlpids *nlpids, struct stream *stream);
+int tlv_add_checksum (struct checksum *checksum, struct stream *stream);
+int tlv_add_authinfo (char auth_type, char authlen, char *auth_value,
+ struct stream *stream);
+int tlv_add_ip_addrs (struct list *ip_addrs, struct stream *stream);
+int tlv_add_dynamic_hostname (struct hostname *hostname,
struct stream *stream);
-int tlv_add_authinfo (char auth_type, char authlen, char *auth_value,
- struct stream *stream);
-int tlv_add_ip_addrs (struct list *ip_addrs, struct stream *stream);
-int tlv_add_dynamic_hostname (struct hostname *hostname,struct stream *stream);
-int tlv_add_lsp_entries (struct list *lsps, struct stream *stream);
-int tlv_add_ipv4_reachs (struct list *ipv4_reachs, struct stream *stream);
+int tlv_add_lsp_entries (struct list *lsps, struct stream *stream);
+int tlv_add_ipv4_reachs (struct list *ipv4_reachs, struct stream *stream);
#ifdef HAVE_IPV6
-int tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream);
-int tlv_add_ipv6_reachs (struct list *ipv6_reachs, struct stream *stream);
+int tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream);
+int tlv_add_ipv6_reachs (struct list *ipv6_reachs, struct stream *stream);
#endif /* HAVE_IPV6 */
-int tlv_add_padding (struct stream *stream);
+int tlv_add_padding (struct stream *stream);
#endif /* _ZEBRA_ISIS_TLV_H */
-
-
-
diff --git a/isisd/isis_zebra.c b/isisd/isis_zebra.c
index 136d2b5..ad5a050 100644
--- a/isisd/isis_zebra.c
+++ b/isisd/isis_zebra.c
@@ -44,20 +44,20 @@
extern struct thread_master *master;
-int
+int
isis_zebra_if_add (int command, struct zclient *zclient, zebra_size_t length)
{
struct interface *ifp;
ifp = zebra_interface_add_read (zclient->ibuf);
-
+
zlog_info ("Zebra I/F add: %s index %d flags %ld metric %d mtu %d",
ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
-
+
if (if_is_up (ifp))
isis_csm_state_change (IF_UP_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
-
+
return 0;
}
@@ -69,19 +69,19 @@
s = zclient->ibuf;
ifp = zebra_interface_state_read (s);
-
+
if (!ifp)
return 0;
if (if_is_up (ifp))
zlog_warn ("Zebra: got delete of %s, but interface is still up",
- ifp->name);
+ ifp->name);
zlog_info ("Zebra I/F delete: %s index %d flags %ld metric %d mtu %d",
ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
if_delete (ifp);
-
+
isis_csm_state_change (IF_DOWN_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
return 0;
@@ -120,103 +120,104 @@
}
int
-isis_zebra_if_state_up (int command, struct zclient *zclient,
+isis_zebra_if_state_up (int command, struct zclient *zclient,
zebra_size_t length)
{
struct interface *ifp;
-
+
ifp = zebra_interface_if_lookup (zclient->ibuf);
-
+
if (!ifp)
return 0;
-
- if (if_is_up (ifp)) {
- zebra_interface_if_set_value (zclient->ibuf, ifp);
- isis_circuit_update_params (circuit_scan_by_ifp (ifp), ifp);
- return 0;
- }
-
+
+ if (if_is_up (ifp))
+ {
+ zebra_interface_if_set_value (zclient->ibuf, ifp);
+ isis_circuit_update_params (circuit_scan_by_ifp (ifp), ifp);
+ return 0;
+ }
+
zebra_interface_if_set_value (zclient->ibuf, ifp);
isis_csm_state_change (IF_UP_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
-
+
return 0;
}
-
int
-isis_zebra_if_state_down (int command, struct zclient *zclient,
+isis_zebra_if_state_down (int command, struct zclient *zclient,
zebra_size_t length)
{
struct interface *ifp;
-
+
ifp = zebra_interface_if_lookup (zclient->ibuf);
-
+
if (ifp == NULL)
return 0;
-
- if (if_is_up (ifp)) {
- zebra_interface_if_set_value (zclient->ibuf, ifp);
- isis_csm_state_change (IF_DOWN_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
- }
-
+
+ if (if_is_up (ifp))
+ {
+ zebra_interface_if_set_value (zclient->ibuf, ifp);
+ isis_csm_state_change (IF_DOWN_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
+ }
+
return 0;
}
int
-isis_zebra_if_address_add (int command, struct zclient *zclient,
- zebra_size_t length)
+isis_zebra_if_address_add (int command, struct zclient *zclient,
+ zebra_size_t length)
{
struct connected *c;
struct prefix *p;
u_char buf[BUFSIZ];
- c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
- zclient->ibuf);
-
+ c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
+ zclient->ibuf);
+
if (c == NULL)
return 0;
-
+
p = c->address;
-
+
prefix2str (p, buf, BUFSIZ);
#ifdef EXTREME_DEBUG
- if (p->family == AF_INET)
+ if (p->family == AF_INET)
zlog_info ("connected IP address %s", buf);
#ifdef HAVE_IPV6
if (p->family == AF_INET6)
zlog_info ("connected IPv6 address %s", buf);
#endif /* HAVE_IPV6 */
#endif /* EXTREME_DEBUG */
- isis_circuit_add_addr (circuit_scan_by_ifp (c->ifp), c);
+ isis_circuit_add_addr (circuit_scan_by_ifp (c->ifp), c);
return 0;
}
int
-isis_zebra_if_address_del (int command, struct zclient *client,
- zebra_size_t length)
+isis_zebra_if_address_del (int command, struct zclient *client,
+ zebra_size_t length)
{
struct connected *c;
struct interface *ifp;
- c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
- zclient->ibuf);
-
+ c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
+ zclient->ibuf);
+
if (c == NULL)
return 0;
-
+
ifp = c->ifp;
-
+
connected_free (c);
-
+
isis_circuit_del_addr (circuit_scan_by_ifp (ifp), c);
-
+
return 0;
}
void
-isis_zebra_route_add_ipv4 (struct prefix *prefix,
- struct isis_route_info *route_info)
+isis_zebra_route_add_ipv4 (struct prefix *prefix,
+ struct isis_route_info *route_info)
{
u_char message, flags;
int psize;
@@ -227,83 +228,89 @@
if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
return;
- if (zclient->redist[ZEBRA_ROUTE_ISIS]) {
- message = 0;
- flags = 0;
-
- SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
- SET_FLAG (message, ZAPI_MESSAGE_METRIC);
-#if 0
- SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
-#endif
-
- stream = zclient->obuf;
- stream_reset (stream);
- /* Length place holder. */
- stream_putw (stream, 0);
- /* command */
- stream_putc (stream, ZEBRA_IPV4_ROUTE_ADD);
- /* type */
- stream_putc (stream, ZEBRA_ROUTE_ISIS);
- /* flags */
- stream_putc (stream, flags);
- /* message */
- stream_putc (stream, message);
- /* prefix information */
- psize = PSIZE (prefix->prefixlen);
- stream_putc (stream, prefix->prefixlen);
- stream_write (stream, (u_char *)&prefix->u.prefix4, psize);
+ if (zclient->redist[ZEBRA_ROUTE_ISIS])
+ {
+ message = 0;
+ flags = 0;
- stream_putc (stream, listcount (route_info->nexthops));
-
- /* Nexthop, ifindex, distance and metric information */
- for (node = listhead (route_info->nexthops); node; nextnode (node)) {
- nexthop = getdata (node);
- /* FIXME: can it be ? */
- if (nexthop->ip.s_addr != INADDR_ANY) {
- stream_putc (stream, ZEBRA_NEXTHOP_IPV4);
- stream_put_in_addr (stream, &nexthop->ip);
- } else {
- stream_putc (stream, ZEBRA_NEXTHOP_IFINDEX);
- stream_putl (stream, nexthop->ifindex);
- }
- }
+ SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
+ SET_FLAG (message, ZAPI_MESSAGE_METRIC);
#if 0
- if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
- stream_putc (stream, route_info->depth);
+ SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
#endif
- if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
- stream_putl (stream, route_info->cost);
-
- stream_putw_at (stream, 0, stream_get_endp (stream));
- writen (zclient->sock, stream->data, stream_get_endp (stream));
- }
+
+ stream = zclient->obuf;
+ stream_reset (stream);
+ /* Length place holder. */
+ stream_putw (stream, 0);
+ /* command */
+ stream_putc (stream, ZEBRA_IPV4_ROUTE_ADD);
+ /* type */
+ stream_putc (stream, ZEBRA_ROUTE_ISIS);
+ /* flags */
+ stream_putc (stream, flags);
+ /* message */
+ stream_putc (stream, message);
+ /* prefix information */
+ psize = PSIZE (prefix->prefixlen);
+ stream_putc (stream, prefix->prefixlen);
+ stream_write (stream, (u_char *) & prefix->u.prefix4, psize);
+
+ stream_putc (stream, listcount (route_info->nexthops));
+
+ /* Nexthop, ifindex, distance and metric information */
+ for (node = listhead (route_info->nexthops); node; nextnode (node))
+ {
+ nexthop = getdata (node);
+ /* FIXME: can it be ? */
+ if (nexthop->ip.s_addr != INADDR_ANY)
+ {
+ stream_putc (stream, ZEBRA_NEXTHOP_IPV4);
+ stream_put_in_addr (stream, &nexthop->ip);
+ }
+ else
+ {
+ stream_putc (stream, ZEBRA_NEXTHOP_IFINDEX);
+ stream_putl (stream, nexthop->ifindex);
+ }
+ }
+#if 0
+ if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
+ stream_putc (stream, route_info->depth);
+#endif
+ if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
+ stream_putl (stream, route_info->cost);
+
+ stream_putw_at (stream, 0, stream_get_endp (stream));
+ writen (zclient->sock, stream->data, stream_get_endp (stream));
+ }
}
void
-isis_zebra_route_del_ipv4 (struct prefix *prefix,
- struct isis_route_info *route_info)
+isis_zebra_route_del_ipv4 (struct prefix *prefix,
+ struct isis_route_info *route_info)
{
struct zapi_ipv4 api;
struct prefix_ipv4 prefix4;
-
- if (zclient->redist[ZEBRA_ROUTE_ISIS]) {
- api.type = ZEBRA_ROUTE_ISIS;
- api.flags = 0;
- api.message = 0;
- prefix4.family = AF_INET;
- prefix4.prefixlen = prefix->prefixlen;
- prefix4.prefix = prefix->u.prefix4;
- zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, &prefix4, &api);
- }
-
+
+ if (zclient->redist[ZEBRA_ROUTE_ISIS])
+ {
+ api.type = ZEBRA_ROUTE_ISIS;
+ api.flags = 0;
+ api.message = 0;
+ prefix4.family = AF_INET;
+ prefix4.prefixlen = prefix->prefixlen;
+ prefix4.prefix = prefix->u.prefix4;
+ zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, &prefix4, &api);
+ }
+
return;
}
#ifdef HAVE_IPV6
void
isis_zebra_route_add_ipv6 (struct prefix *prefix,
- struct isis_route_info *route_info)
+ struct isis_route_info *route_info)
{
struct zapi_ipv6 api;
struct in6_addr **nexthop_list;
@@ -315,7 +322,7 @@
if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
return;
-
+
api.type = ZEBRA_ROUTE_ISIS;
api.flags = 0;
api.message = 0;
@@ -329,61 +336,66 @@
#endif
api.nexthop_num = listcount (route_info->nexthops6);
api.ifindex_num = listcount (route_info->nexthops6);
-
+
/* allocate memory for nexthop_list */
size = sizeof (struct isis_nexthop6 *) * listcount (route_info->nexthops6);
nexthop_list = (struct in6_addr **) XMALLOC (MTYPE_ISIS_TMP, size);
- if (!nexthop_list) {
- zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
- return;
- }
-
+ if (!nexthop_list)
+ {
+ zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
+ return;
+ }
+
/* allocate memory for ifindex_list */
size = sizeof (unsigned int) * listcount (route_info->nexthops6);
ifindex_list = (unsigned int *) XMALLOC (MTYPE_ISIS_TMP, size);
- if (!ifindex_list) {
- zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
- XFREE (MTYPE_ISIS_TMP, nexthop_list);
- return;
- }
-
+ if (!ifindex_list)
+ {
+ zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
+ XFREE (MTYPE_ISIS_TMP, nexthop_list);
+ return;
+ }
+
/* for each nexthop */
i = 0;
- for (node = listhead (route_info->nexthops6); node; nextnode (node)) {
- nexthop6 = getdata (node);
-
- if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
- !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6)) {
- api.nexthop_num--;
- api.ifindex_num--;
- continue;
+ for (node = listhead (route_info->nexthops6); node; nextnode (node))
+ {
+ nexthop6 = getdata (node);
+
+ if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
+ !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6))
+ {
+ api.nexthop_num--;
+ api.ifindex_num--;
+ continue;
+ }
+
+ nexthop_list[i] = &nexthop6->ip6;
+ ifindex_list[i] = nexthop6->ifindex;
+ i++;
}
-
- nexthop_list[i] = &nexthop6->ip6;
- ifindex_list[i] = nexthop6->ifindex;
- i++;
- }
-
+
api.nexthop = nexthop_list;
api.ifindex = ifindex_list;
-
- if (api.nexthop_num && api.ifindex_num) {
- prefix6.family = AF_INET6;
- prefix6.prefixlen = prefix->prefixlen;
- memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
- zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, &prefix6, &api);
- SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
- }
-
+
+ if (api.nexthop_num && api.ifindex_num)
+ {
+ prefix6.family = AF_INET6;
+ prefix6.prefixlen = prefix->prefixlen;
+ memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
+ zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, &prefix6, &api);
+ SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
+ }
+
XFREE (MTYPE_ISIS_TMP, nexthop_list);
XFREE (MTYPE_ISIS_TMP, ifindex_list);
-
+
return;
}
void
-isis_zebra_route_del_ipv6 (struct prefix *prefix,
- struct isis_route_info *route_info)
+isis_zebra_route_del_ipv6 (struct prefix *prefix,
+ struct isis_route_info *route_info)
{
struct zapi_ipv6 api;
struct in6_addr **nexthop_list;
@@ -395,7 +407,7 @@
if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
return;
-
+
api.type = ZEBRA_ROUTE_ISIS;
api.flags = 0;
api.message = 0;
@@ -403,64 +415,66 @@
SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
api.nexthop_num = listcount (route_info->nexthops6);
api.ifindex_num = listcount (route_info->nexthops6);
-
+
/* allocate memory for nexthop_list */
size = sizeof (struct isis_nexthop6 *) * listcount (route_info->nexthops6);
nexthop_list = (struct in6_addr **) XMALLOC (MTYPE_ISIS_TMP, size);
- if (!nexthop_list) {
- zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
- return;
- }
-
+ if (!nexthop_list)
+ {
+ zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
+ return;
+ }
+
/* allocate memory for ifindex_list */
size = sizeof (unsigned int) * listcount (route_info->nexthops6);
ifindex_list = (unsigned int *) XMALLOC (MTYPE_ISIS_TMP, size);
- if (!ifindex_list) {
- zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
- XFREE (MTYPE_ISIS_TMP, nexthop_list);
- return;
- }
-
+ if (!ifindex_list)
+ {
+ zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
+ XFREE (MTYPE_ISIS_TMP, nexthop_list);
+ return;
+ }
+
/* for each nexthop */
i = 0;
- for (node = listhead (route_info->nexthops6); node; nextnode (node)) {
- nexthop6 = getdata (node);
-
- if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
- !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6)) {
- api.nexthop_num--;
- api.ifindex_num--;
- continue;
+ for (node = listhead (route_info->nexthops6); node; nextnode (node))
+ {
+ nexthop6 = getdata (node);
+
+ if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
+ !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6))
+ {
+ api.nexthop_num--;
+ api.ifindex_num--;
+ continue;
+ }
+
+ nexthop_list[i] = &nexthop6->ip6;
+ ifindex_list[i] = nexthop6->ifindex;
+ i++;
}
-
- nexthop_list[i] = &nexthop6->ip6;
- ifindex_list[i] = nexthop6->ifindex;
- i++;
- }
-
+
api.nexthop = nexthop_list;
api.ifindex = ifindex_list;
-
- if (api.nexthop_num && api.ifindex_num) {
- prefix6.family = AF_INET6;
- prefix6.prefixlen = prefix->prefixlen;
- memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
- zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, &prefix6, &api);
- UNSET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
- }
-
- XFREE (MTYPE_ISIS_TMP, nexthop_list);
- XFREE (MTYPE_ISIS_TMP, ifindex_list);
-}
+ if (api.nexthop_num && api.ifindex_num)
+ {
+ prefix6.family = AF_INET6;
+ prefix6.prefixlen = prefix->prefixlen;
+ memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
+ zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, &prefix6, &api);
+ UNSET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
+ }
+
+ XFREE (MTYPE_ISIS_TMP, nexthop_list);
+ XFREE (MTYPE_ISIS_TMP, ifindex_list);
+}
#endif /* HAVE_IPV6 */
-
-
void
isis_zebra_route_update (struct prefix *prefix,
- struct isis_route_info *route_info)
+ struct isis_route_info *route_info)
{
if (zclient->sock < 0)
return;
@@ -468,27 +482,29 @@
if (!zclient->redist[ZEBRA_ROUTE_ISIS])
return;
- if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ACTIVE)) {
- if (prefix->family == AF_INET)
- isis_zebra_route_add_ipv4 (prefix, route_info);
+ if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ACTIVE))
+ {
+ if (prefix->family == AF_INET)
+ isis_zebra_route_add_ipv4 (prefix, route_info);
#ifdef HAVE_IPV6
- else if (prefix->family == AF_INET6)
- isis_zebra_route_add_ipv6 (prefix, route_info);
+ else if (prefix->family == AF_INET6)
+ isis_zebra_route_add_ipv6 (prefix, route_info);
#endif /* HAVE_IPV6 */
- } else {
- if (prefix->family == AF_INET)
- isis_zebra_route_del_ipv4 (prefix, route_info);
+ }
+ else
+ {
+ if (prefix->family == AF_INET)
+ isis_zebra_route_del_ipv4 (prefix, route_info);
#ifdef HAVE_IPV6
- else if (prefix->family == AF_INET6)
- isis_zebra_route_del_ipv6 (prefix, route_info);
+ else if (prefix->family == AF_INET6)
+ isis_zebra_route_del_ipv6 (prefix, route_info);
#endif /* HAVE_IPV6 */
- }
+ }
return;
}
-
int
-isis_zebra_read_ipv4 (int command, struct zclient *zclient,
+isis_zebra_read_ipv4 (int command, struct zclient *zclient,
zebra_size_t length)
{
struct stream *stream;
@@ -501,42 +517,43 @@
memset (&p, 0, sizeof (struct prefix_ipv4));
ifindex = 0;
- api.type = stream_getc (stream);
- api.flags = stream_getc (stream);
+ api.type = stream_getc (stream);
+ api.flags = stream_getc (stream);
api.message = stream_getc (stream);
p.family = AF_INET;
p.prefixlen = stream_getc (stream);
stream_get (&p.prefix, stream, PSIZE (p.prefixlen));
-
- if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP)) {
+
+ if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
+ {
api.nexthop_num = stream_getc (stream);
nexthop.s_addr = stream_get_ipv4 (stream);
- }
- if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX)) {
- api.ifindex_num = stream_getc (stream);
- ifindex = stream_getl (stream);
- }
+ }
+ if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
+ {
+ api.ifindex_num = stream_getc (stream);
+ ifindex = stream_getl (stream);
+ }
if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
api.distance = stream_getc (stream);
if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
api.metric = stream_getl (stream);
else
api.metric = 0;
-
- if (command == ZEBRA_IPV4_ROUTE_ADD) {
- zlog_info ("IPv4 Route add from Z");
- }
+
+ if (command == ZEBRA_IPV4_ROUTE_ADD)
+ {
+ zlog_info ("IPv4 Route add from Z");
+ }
return 0;
}
-
-int
-isis_zebra_read_ipv6 (int command, struct zclient *zclient,
+int
+isis_zebra_read_ipv6 (int command, struct zclient *zclient,
zebra_size_t length)
{
-
return 0;
}
@@ -550,16 +567,15 @@
}
int
-isis_redistribute_default_set(int routetype, int metric_type, int metric_value)
+isis_redistribute_default_set (int routetype, int metric_type,
+ int metric_value)
{
return 0;
}
-
void
isis_zebra_init ()
{
-
zclient = zclient_new ();
zclient_init (zclient, ZEBRA_ROUTE_ISIS);
zclient->interface_add = isis_zebra_if_add;
@@ -581,17 +597,9 @@
void
isis_zebra_finish ()
{
-
zclient_stop (zclient);
zclient_free (zclient);
zclient = (struct zclient *) NULL;
return;
}
-
-
-
-
-
-
-
diff --git a/isisd/isis_zebra.h b/isisd/isis_zebra.h
index fabf720..0dce799 100644
--- a/isisd/isis_zebra.h
+++ b/isisd/isis_zebra.h
@@ -26,8 +26,8 @@
void isis_zebra_init (void);
void isis_zebra_finish (void);
-void isis_zebra_route_update (struct prefix *prefix,
- struct isis_route_info *route_info);
+void isis_zebra_route_update (struct prefix *prefix,
+ struct isis_route_info *route_info);
int isis_distribute_list_update (int routetype);
#endif /* _ZEBRA_ISIS_ZEBRA_H */
diff --git a/isisd/isisd.c b/isisd/isisd.c
index 8d0b3a2..3c499dc 100644
--- a/isisd/isisd.c
+++ b/isisd/isisd.c
@@ -56,19 +56,16 @@
#ifdef TOPOLOGY_GENERATE
#include "spgrid.h"
-u_char DEFAULT_TOPOLOGY_BASEIS[6] = {0xFE, 0xED, 0xFE, 0xED, 0x00, 0x00};
+u_char DEFAULT_TOPOLOGY_BASEIS[6] = { 0xFE, 0xED, 0xFE, 0xED, 0x00, 0x00 };
#endif /* TOPOLOGY_GENERATE */
-
struct isis *isis = NULL;
struct thread_master *master;
-
void
isis_new (unsigned long process_id)
{
-
- isis = XMALLOC (MTYPE_ISIS, sizeof(struct isis));
+ isis = XMALLOC (MTYPE_ISIS, sizeof (struct isis));
bzero (isis, sizeof (struct isis));
/*
* Default values
@@ -86,15 +83,14 @@
/*
* uncomment the next line for full debugs
*/
- /* isis->debugs = 0xFFFF; */
+ /* isis->debugs = 0xFFFF; */
}
struct isis_area *
isis_area_create ()
{
-
struct isis_area *area;
-
+
area = XMALLOC (MTYPE_ISIS_AREA, sizeof (struct isis_area));
memset (area, 0, sizeof (struct isis_area));
@@ -111,7 +107,7 @@
*/
area->lspdb[0] = lsp_db_init ();
area->lspdb[1] = lsp_db_init ();
-
+
spftree_area_init (area);
area->route_table = route_table_init ();
#ifdef HAVE_IPV6
@@ -119,17 +115,17 @@
#endif /* HAVE_IPV6 */
area->circuit_list = list_new ();
area->area_addrs = list_new ();
- THREAD_TIMER_ON(master, area->t_tick, lsp_tick, area, 1);
+ THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
area->flags.maxindex = -1;
/*
* Default values
*/
- area->max_lsp_lifetime[0] = MAX_AGE; /* 1200 */
- area->max_lsp_lifetime[1] = MAX_AGE; /* 1200 */
+ area->max_lsp_lifetime[0] = MAX_AGE; /* 1200 */
+ area->max_lsp_lifetime[1] = MAX_AGE; /* 1200 */
area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;
area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT;
- area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900 */
- area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900 */
+ area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900 */
+ area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900 */
area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
area->dynhostname = 1;
@@ -149,81 +145,83 @@
{
struct isis_area *area;
struct listnode *node;
-
+
LIST_LOOP (isis->area_list, area, node)
if ((area->area_tag == NULL && area_tag == NULL) ||
- (area->area_tag && area_tag && strcmp (area->area_tag, area_tag) == 0))
- return area;
-
+ (area->area_tag && area_tag
+ && strcmp (area->area_tag, area_tag) == 0))
+ return area;
+
return NULL;
}
-int
+int
isis_area_get (struct vty *vty, char *area_tag)
{
-
struct isis_area *area;
-
+
area = isis_area_lookup (area_tag);
-
- if (area) {
- vty->node = ISIS_NODE;
- vty->index = area;
- return CMD_SUCCESS;
- }
-
+
+ if (area)
+ {
+ vty->node = ISIS_NODE;
+ vty->index = area;
+ return CMD_SUCCESS;
+ }
+
area = isis_area_create ();
area->area_tag = strdup (area_tag);
listnode_add (isis->area_list, area);
-
+
zlog_info ("new IS-IS area instance %s", area->area_tag);
vty->node = ISIS_NODE;
vty->index = area;
-
+
return CMD_SUCCESS;
}
int
isis_area_destroy (struct vty *vty, char *area_tag)
{
-
struct isis_area *area;
struct listnode *node;
struct isis_circuit *circuit;
area = isis_area_lookup (area_tag);
-
- if (area == NULL) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
- if (area->circuit_list) {
- node = listhead (area->circuit_list);
- while (node) {
- circuit = getdata (node);
- nextnode (node);
- isis_circuit_del (circuit);
+ if (area == NULL)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
}
- list_delete (area->circuit_list);
- }
+
+ if (area->circuit_list)
+ {
+ node = listhead (area->circuit_list);
+ while (node)
+ {
+ circuit = getdata (node);
+ nextnode (node);
+ isis_circuit_del (circuit);
+ }
+ list_delete (area->circuit_list);
+ }
listnode_delete (isis->area_list, area);
- THREAD_TIMER_OFF(area->t_tick);
+ THREAD_TIMER_OFF (area->t_tick);
if (area->t_remove_aged)
thread_cancel (area->t_remove_aged);
- THREAD_TIMER_OFF(area->t_lsp_refresh[0]);
- THREAD_TIMER_OFF(area->t_lsp_refresh[1]);
+ THREAD_TIMER_OFF (area->t_lsp_refresh[0]);
+ THREAD_TIMER_OFF (area->t_lsp_refresh[1]);
XFREE (MTYPE_ISIS_AREA, area);
-
+
return CMD_SUCCESS;
}
-int
-area_net_title (struct vty *vty , char *net_title)
+int
+area_net_title (struct vty *vty, char *net_title)
{
-
struct isis_area *area;
struct area_addr *addr;
struct area_addr *addrp;
@@ -232,62 +230,73 @@
u_char buff[255];
area = vty->index;
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
/* We check that we are not over the maximal number of addresses */
- if (listcount (area->area_addrs) >= isis->max_area_addrs) {
- vty_out (vty, "Maximum of area addresses (%d) already reached %s",
- isis->max_area_addrs, VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (listcount (area->area_addrs) >= isis->max_area_addrs)
+ {
+ vty_out (vty, "Maximum of area addresses (%d) already reached %s",
+ isis->max_area_addrs, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
addr = XMALLOC (MTYPE_ISIS_AREA_ADDR, sizeof (struct area_addr));
addr->addr_len = dotformat2buff (buff, net_title);
memcpy (addr->area_addr, buff, addr->addr_len);
#ifdef EXTREME_DEBUG
- zlog_info ("added area address %s for area %s (address length %d)",
+ zlog_info ("added area address %s for area %s (address length %d)",
net_title, area->area_tag, addr->addr_len);
#endif /* EXTREME_DEBUG */
- if (addr->addr_len < 8 || addr->addr_len > 20) {
- zlog_warn ("area address must be at least 8..20 octets long (%d)",
- addr->addr_len);
- XFREE (MTYPE_ISIS_AREA_ADDR, addr);
- return CMD_WARNING;
- }
-
- if (isis->sysid_set == 0) {
- /*
- * First area address - get the SystemID for this router
- */
- memcpy (isis->sysid, GETSYSID(addr, ISIS_SYS_ID_LEN), ISIS_SYS_ID_LEN);
- isis->sysid_set = 1;
- zlog_info ("Router has SystemID %s", sysid_print (isis->sysid));
- } else {
- /*
- * Check that the SystemID portions match
- */
- if (memcmp (isis->sysid, GETSYSID(addr, ISIS_SYS_ID_LEN),
- ISIS_SYS_ID_LEN)) {
- vty_out (vty, "System ID must not change when defining additional area"
- " addresses%s", VTY_NEWLINE);
+ if (addr->addr_len < 8 || addr->addr_len > 20)
+ {
+ zlog_warn ("area address must be at least 8..20 octets long (%d)",
+ addr->addr_len);
XFREE (MTYPE_ISIS_AREA_ADDR, addr);
return CMD_WARNING;
}
- /* now we see that we don't already have this address */
- LIST_LOOP (area->area_addrs, addrp, node) {
- if ((addrp->addr_len+ ISIS_SYS_ID_LEN + 1) == (addr->addr_len)) {
- if (!memcmp (addrp->area_addr, addr->area_addr,addr->addr_len)) {
- XFREE (MTYPE_ISIS_AREA_ADDR, addr);
- return CMD_SUCCESS; /* silent fail */
- }
- }
+ if (isis->sysid_set == 0)
+ {
+ /*
+ * First area address - get the SystemID for this router
+ */
+ memcpy (isis->sysid, GETSYSID (addr, ISIS_SYS_ID_LEN), ISIS_SYS_ID_LEN);
+ isis->sysid_set = 1;
+ zlog_info ("Router has SystemID %s", sysid_print (isis->sysid));
}
+ else
+ {
+ /*
+ * Check that the SystemID portions match
+ */
+ if (memcmp (isis->sysid, GETSYSID (addr, ISIS_SYS_ID_LEN),
+ ISIS_SYS_ID_LEN))
+ {
+ vty_out (vty,
+ "System ID must not change when defining additional area"
+ " addresses%s", VTY_NEWLINE);
+ XFREE (MTYPE_ISIS_AREA_ADDR, addr);
+ return CMD_WARNING;
+ }
- }
+ /* now we see that we don't already have this address */
+ LIST_LOOP (area->area_addrs, addrp, node)
+ {
+ if ((addrp->addr_len + ISIS_SYS_ID_LEN + 1) == (addr->addr_len))
+ {
+ if (!memcmp (addrp->area_addr, addr->area_addr, addr->addr_len))
+ {
+ XFREE (MTYPE_ISIS_AREA_ADDR, addr);
+ return CMD_SUCCESS; /* silent fail */
+ }
+ }
+ }
+
+ }
/*
* Forget the systemID part of the address
*/
@@ -295,10 +304,11 @@
listnode_add (area->area_addrs, addr);
/* only now we can safely generate our LSPs for this area */
- if (listcount(area->area_addrs) > 0) {
- lsp_l1_generate (area);
- lsp_l2_generate (area);
- }
+ if (listcount (area->area_addrs) > 0)
+ {
+ lsp_l1_generate (area);
+ lsp_l2_generate (area);
+ }
return CMD_SUCCESS;
}
@@ -307,48 +317,50 @@
area_clear_net_title (struct vty *vty, char *net_title)
{
struct isis_area *area;
- struct area_addr addr, *addrp = NULL;
+ struct area_addr addr, *addrp = NULL;
struct listnode *node;
u_char buff[255];
area = vty->index;
- if (!area) {
- vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Can't find ISIS instance %s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
addr.addr_len = dotformat2buff (buff, net_title);
- if (addr.addr_len < 8 || addr.addr_len > 20) {
- vty_out (vty, "Unsupported area address length %d, should be 8...20 %s",
- addr.addr_len, VTY_NEWLINE);
- return CMD_WARNING;
- }
-
- memcpy(addr.area_addr, buff, (int)addr.addr_len);
-
+ if (addr.addr_len < 8 || addr.addr_len > 20)
+ {
+ vty_out (vty, "Unsupported area address length %d, should be 8...20 %s",
+ addr.addr_len, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
+ memcpy (addr.area_addr, buff, (int) addr.addr_len);
+
LIST_LOOP (area->area_addrs, addrp, node)
if (addrp->addr_len == addr.addr_len &&
!memcmp (addrp->area_addr, addr.area_addr, addr.addr_len))
- break;
-
- if (!addrp) {
- vty_out (vty, "No area address %s for area %s %s", net_title,
- area->area_tag, VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ break;
+
+ if (!addrp)
+ {
+ vty_out (vty, "No area address %s for area %s %s", net_title,
+ area->area_tag, VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
listnode_delete (area->area_addrs, addrp);
-
+
return CMD_SUCCESS;
}
-
/*
* 'show clns neighbors' command
*/
int
-show_clns_neigh (struct vty *vty, char detail)
+show_clns_neigh (struct vty *vty, char detail)
{
struct listnode *node_area, *node_circ;
struct isis_area *area;
@@ -356,53 +368,69 @@
struct list *db;
int i;
- if (!isis) {
- vty_out (vty, "IS-IS Routing Process not enabled%s", VTY_NEWLINE);
- return CMD_SUCCESS;
- }
+ if (!isis)
+ {
+ vty_out (vty, "IS-IS Routing Process not enabled%s", VTY_NEWLINE);
+ return CMD_SUCCESS;
+ }
for (node_area = listhead (isis->area_list); node_area;
- nextnode (node_area)) {
- area = getdata (node_area);
- vty_out (vty, "Area %s:%s", area->area_tag, VTY_NEWLINE);
+ nextnode (node_area))
+ {
+ area = getdata (node_area);
+ vty_out (vty, "Area %s:%s", area->area_tag, VTY_NEWLINE);
- if (detail==ISIS_UI_LEVEL_BRIEF)
- vty_out (vty, " System Id Interface L State "
- "Holdtime SNPA%s", VTY_NEWLINE);
+ if (detail == ISIS_UI_LEVEL_BRIEF)
+ vty_out (vty, " System Id Interface L State "
+ "Holdtime SNPA%s", VTY_NEWLINE);
- for (node_circ = listhead (area->circuit_list); node_circ;
- nextnode (node_circ)) {
- circuit = getdata (node_circ);
- if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- for (i = 0; i < 2; i++) {
- db = circuit->u.bc.adjdb[i];
- if (db && db->count) {
- if (detail == ISIS_UI_LEVEL_BRIEF)
- isis_adjdb_iterate (db, (void (*) (struct isis_adjacency *,
- void *))
- isis_adj_print_vty, vty);
- if (detail == ISIS_UI_LEVEL_DETAIL)
- isis_adjdb_iterate (db, (void (*) (struct isis_adjacency *,
- void *))
- isis_adj_print_vty_detail, vty);
- if (detail == ISIS_UI_LEVEL_EXTENSIVE)
- isis_adjdb_iterate (db, (void (*) (struct isis_adjacency *,
- void *))
- isis_adj_print_vty_extensive, vty);
- }
- }
- } else if (circuit->circ_type == CIRCUIT_T_P2P &&
- circuit->u.p2p.neighbor) {
- if (detail==ISIS_UI_LEVEL_BRIEF)
- isis_adj_p2p_print_vty (circuit->u.p2p.neighbor, vty);
- if (detail==ISIS_UI_LEVEL_DETAIL)
- isis_adj_p2p_print_vty_detail (circuit->u.p2p.neighbor, vty);
- if (detail==ISIS_UI_LEVEL_EXTENSIVE)
- isis_adj_p2p_print_vty_extensive (circuit->u.p2p.neighbor, vty);
- }
+ for (node_circ = listhead (area->circuit_list); node_circ;
+ nextnode (node_circ))
+ {
+ circuit = getdata (node_circ);
+ if (circuit->circ_type == CIRCUIT_T_BROADCAST)
+ {
+ for (i = 0; i < 2; i++)
+ {
+ db = circuit->u.bc.adjdb[i];
+ if (db && db->count)
+ {
+ if (detail == ISIS_UI_LEVEL_BRIEF)
+ isis_adjdb_iterate (db,
+ (void (*)
+ (struct isis_adjacency *,
+ void *)) isis_adj_print_vty,
+ vty);
+ if (detail == ISIS_UI_LEVEL_DETAIL)
+ isis_adjdb_iterate (db,
+ (void (*)
+ (struct isis_adjacency *,
+ void *))
+ isis_adj_print_vty_detail, vty);
+ if (detail == ISIS_UI_LEVEL_EXTENSIVE)
+ isis_adjdb_iterate (db,
+ (void (*)
+ (struct isis_adjacency *,
+ void *))
+ isis_adj_print_vty_extensive,
+ vty);
+ }
+ }
+ }
+ else if (circuit->circ_type == CIRCUIT_T_P2P &&
+ circuit->u.p2p.neighbor)
+ {
+ if (detail == ISIS_UI_LEVEL_BRIEF)
+ isis_adj_p2p_print_vty (circuit->u.p2p.neighbor, vty);
+ if (detail == ISIS_UI_LEVEL_DETAIL)
+ isis_adj_p2p_print_vty_detail (circuit->u.p2p.neighbor, vty);
+ if (detail == ISIS_UI_LEVEL_EXTENSIVE)
+ isis_adj_p2p_print_vty_extensive (circuit->u.p2p.neighbor,
+ vty);
+ }
+ }
}
- }
-
+
return CMD_SUCCESS;
}
@@ -413,7 +441,7 @@
"clns network information\n"
"CLNS neighbor adjacencies\n")
{
- return show_clns_neigh(vty, ISIS_UI_LEVEL_BRIEF);
+ return show_clns_neigh (vty, ISIS_UI_LEVEL_BRIEF);
}
ALIAS (show_clns_neighbors,
@@ -431,7 +459,7 @@
"CLNS neighbor adjacencies\n"
"show detailed information\n")
{
- return show_clns_neigh(vty, ISIS_UI_LEVEL_DETAIL);
+ return show_clns_neigh (vty, ISIS_UI_LEVEL_DETAIL);
}
ALIAS (show_clns_neighbors_detail,
@@ -441,53 +469,49 @@
"IS-IS network information\n"
"IS-IS neighbor adjacencies\n"
"show detailed information\n")
-
/*
* 'isis debug', 'show debugging'
*/
-
void
print_debug (struct vty *vty, int flags, int onoff)
{
char onoffs[4];
if (onoff)
- strcpy (onoffs,"on");
+ strcpy (onoffs, "on");
else
- strcpy (onoffs,"off");
+ strcpy (onoffs, "off");
if (flags & DEBUG_ADJ_PACKETS)
- vty_out (vty,"IS-IS Adjacency related packets debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS Adjacency related packets debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_CHECKSUM_ERRORS)
- vty_out (vty,"IS-IS checksum errors debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS checksum errors debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_LOCAL_UPDATES)
- vty_out (vty,"IS-IS local updates debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS local updates debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_PROTOCOL_ERRORS)
- vty_out (vty,"IS-IS protocol errors debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS protocol errors debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_SNP_PACKETS)
- vty_out (vty,"IS-IS CSNP/PSNP packets debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS CSNP/PSNP packets debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_SPF_EVENTS)
- vty_out (vty,"IS-IS SPF events debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS SPF events debugging is %s%s", onoffs, VTY_NEWLINE);
if (flags & DEBUG_SPF_STATS)
- vty_out (vty,"IS-IS SPF Timing and Statistics Data debugging is %s%s",
- onoffs, VTY_NEWLINE);
+ vty_out (vty, "IS-IS SPF Timing and Statistics Data debugging is %s%s",
+ onoffs, VTY_NEWLINE);
if (flags & DEBUG_SPF_TRIGGERS)
- vty_out (vty,"IS-IS SPF triggering events debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS SPF triggering events debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_UPDATE_PACKETS)
- vty_out (vty,"IS-IS Update related packet debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS Update related packet debugging is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_RTE_EVENTS)
- vty_out (vty,"IS-IS Route related debuggin is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS Route related debuggin is %s%s", onoffs,
+ VTY_NEWLINE);
if (flags & DEBUG_EVENTS)
- vty_out (vty,"IS-IS Event debugging is %s%s", onoffs,
- VTY_NEWLINE);
+ vty_out (vty, "IS-IS Event debugging is %s%s", onoffs, VTY_NEWLINE);
}
@@ -497,17 +521,16 @@
SHOW_STR
"State of each debugging option\n")
{
- vty_out (vty,"IS-IS:%s", VTY_NEWLINE);
+ vty_out (vty, "IS-IS:%s", VTY_NEWLINE);
print_debug (vty, isis->debugs, 1);
return CMD_SUCCESS;
}
/* Debug node. */
-static struct cmd_node debug_node =
-{
+static struct cmd_node debug_node = {
DEBUG_NODE,
- "",
- 1
+ "",
+ 1
};
static int
@@ -516,61 +539,61 @@
int write = 0;
int flags = isis->debugs;
- if (flags & DEBUG_ADJ_PACKETS) {
- vty_out (vty, "debug isis adj-packets%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_CHECKSUM_ERRORS) {
- vty_out (vty, "debug isis checksum-errors%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_LOCAL_UPDATES) {
- vty_out (vty, "debug isis local-updates%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_PROTOCOL_ERRORS) {
- vty_out (vty, "debug isis protocol-errors%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_SNP_PACKETS) {
- vty_out (vty, "debug isis snp-packets%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_SPF_EVENTS) {
- vty_out (vty, "debug isis spf-events%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_SPF_STATS) {
- vty_out (vty, "debug isis spf-statistics%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_SPF_TRIGGERS) {
- vty_out (vty, "debug isis spf-triggers%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_UPDATE_PACKETS) {
- vty_out (vty, "debug isis update-packets%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_RTE_EVENTS) {
- vty_out (vty, "debug isis route-events%s",
- VTY_NEWLINE);
- write++;
- }
- if (flags & DEBUG_EVENTS) {
- vty_out (vty, "debug isis events%s",
- VTY_NEWLINE);
- write++;
- }
+ if (flags & DEBUG_ADJ_PACKETS)
+ {
+ vty_out (vty, "debug isis adj-packets%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_CHECKSUM_ERRORS)
+ {
+ vty_out (vty, "debug isis checksum-errors%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_LOCAL_UPDATES)
+ {
+ vty_out (vty, "debug isis local-updates%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_PROTOCOL_ERRORS)
+ {
+ vty_out (vty, "debug isis protocol-errors%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_SNP_PACKETS)
+ {
+ vty_out (vty, "debug isis snp-packets%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_SPF_EVENTS)
+ {
+ vty_out (vty, "debug isis spf-events%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_SPF_STATS)
+ {
+ vty_out (vty, "debug isis spf-statistics%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_SPF_TRIGGERS)
+ {
+ vty_out (vty, "debug isis spf-triggers%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_UPDATE_PACKETS)
+ {
+ vty_out (vty, "debug isis update-packets%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_RTE_EVENTS)
+ {
+ vty_out (vty, "debug isis route-events%s", VTY_NEWLINE);
+ write++;
+ }
+ if (flags & DEBUG_EVENTS)
+ {
+ vty_out (vty, "debug isis events%s", VTY_NEWLINE);
+ write++;
+ }
return write;
}
@@ -580,11 +603,10 @@
"debug isis adj-packets",
DEBUG_STR
"IS-IS information\n"
- "IS-IS Adjacency related packets\n"
- )
+ "IS-IS Adjacency related packets\n")
{
isis->debugs |= DEBUG_ADJ_PACKETS;
- print_debug (vty,DEBUG_ADJ_PACKETS,1);
+ print_debug (vty, DEBUG_ADJ_PACKETS, 1);
return CMD_SUCCESS;
}
@@ -594,24 +616,20 @@
"no debug isis adj-packets",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS Adjacency related packets\n"
- )
+ "IS-IS Adjacency related packets\n")
{
-
isis->debugs &= ~DEBUG_ADJ_PACKETS;
print_debug (vty, DEBUG_ADJ_PACKETS, 0);
return CMD_SUCCESS;
}
-
DEFUN (debug_isis_csum,
debug_isis_csum_cmd,
"debug isis checksum-errors",
DEBUG_STR
"IS-IS information\n"
- "IS-IS LSP checksum errors\n"
- )
+ "IS-IS LSP checksum errors\n")
{
isis->debugs |= DEBUG_CHECKSUM_ERRORS;
print_debug (vty, DEBUG_CHECKSUM_ERRORS, 1);
@@ -624,12 +642,11 @@
"no debug isis checksum-errors",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS LSP checksum errors\n"
- )
+ "IS-IS LSP checksum errors\n")
{
isis->debugs &= ~DEBUG_CHECKSUM_ERRORS;
print_debug (vty, DEBUG_CHECKSUM_ERRORS, 0);
-
+
return CMD_SUCCESS;
}
@@ -638,8 +655,7 @@
"debug isis local-updates",
DEBUG_STR
"IS-IS information\n"
- "IS-IS local update packets\n"
- )
+ "IS-IS local update packets\n")
{
isis->debugs |= DEBUG_LOCAL_UPDATES;
print_debug (vty, DEBUG_LOCAL_UPDATES, 1);
@@ -652,22 +668,20 @@
"no debug isis local-updates",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS local update packets\n"
- )
+ "IS-IS local update packets\n")
{
isis->debugs &= ~DEBUG_LOCAL_UPDATES;
- print_debug (vty, DEBUG_LOCAL_UPDATES , 0);
-
+ print_debug (vty, DEBUG_LOCAL_UPDATES, 0);
+
return CMD_SUCCESS;
}
DEFUN (debug_isis_err,
debug_isis_err_cmd,
- "debug isis protocol-errors",
+ "debug isis protocol-errors",
DEBUG_STR
"IS-IS information\n"
- "IS-IS LSP protocol errors\n"
- )
+ "IS-IS LSP protocol errors\n")
{
isis->debugs |= DEBUG_PROTOCOL_ERRORS;
print_debug (vty, DEBUG_PROTOCOL_ERRORS, 1);
@@ -680,12 +694,11 @@
"no debug isis protocol-errors",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS LSP protocol errors\n"
- )
+ "IS-IS LSP protocol errors\n")
{
isis->debugs &= ~DEBUG_PROTOCOL_ERRORS;
print_debug (vty, DEBUG_PROTOCOL_ERRORS, 0);
-
+
return CMD_SUCCESS;
}
@@ -694,8 +707,7 @@
"debug isis snp-packets",
DEBUG_STR
"IS-IS information\n"
- "IS-IS CSNP/PSNP packets\n"
- )
+ "IS-IS CSNP/PSNP packets\n")
{
isis->debugs |= DEBUG_SNP_PACKETS;
print_debug (vty, DEBUG_SNP_PACKETS, 1);
@@ -708,24 +720,20 @@
"no debug isis snp-packets",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS CSNP/PSNP packets\n"
- )
+ "IS-IS CSNP/PSNP packets\n")
{
- isis->debugs &= ~DEBUG_SNP_PACKETS ;
+ isis->debugs &= ~DEBUG_SNP_PACKETS;
print_debug (vty, DEBUG_SNP_PACKETS, 0);
-
+
return CMD_SUCCESS;
}
-
-
DEFUN (debug_isis_upd,
debug_isis_upd_cmd,
"debug isis update-packets",
DEBUG_STR
"IS-IS information\n"
- "IS-IS Update related packets\n"
- )
+ "IS-IS Update related packets\n")
{
isis->debugs |= DEBUG_UPDATE_PACKETS;
print_debug (vty, DEBUG_UPDATE_PACKETS, 1);
@@ -738,26 +746,23 @@
"no debug isis update-packets",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS Update related packets\n"
- )
+ "IS-IS Update related packets\n")
{
isis->debugs &= ~DEBUG_UPDATE_PACKETS;
print_debug (vty, DEBUG_UPDATE_PACKETS, 0);
-
+
return CMD_SUCCESS;
}
-
DEFUN (debug_isis_spfevents,
debug_isis_spfevents_cmd,
"debug isis spf-events",
DEBUG_STR
"IS-IS information\n"
- "IS-IS Shortest Path First Events\n"
- )
+ "IS-IS Shortest Path First Events\n")
{
isis->debugs |= DEBUG_SPF_EVENTS;
- print_debug (vty, DEBUG_SPF_EVENTS , 1);
+ print_debug (vty, DEBUG_SPF_EVENTS, 1);
return CMD_SUCCESS;
}
@@ -767,12 +772,11 @@
"no debug isis spf-events",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS Shortest Path First Events\n"
- )
+ "IS-IS Shortest Path First Events\n")
{
isis->debugs &= ~DEBUG_SPF_EVENTS;
- print_debug (vty, DEBUG_SPF_EVENTS , 0);
-
+ print_debug (vty, DEBUG_SPF_EVENTS, 0);
+
return CMD_SUCCESS;
}
@@ -782,8 +786,7 @@
"debug isis spf-statistics ",
DEBUG_STR
"IS-IS information\n"
- "IS-IS SPF Timing and Statistic Data\n"
- )
+ "IS-IS SPF Timing and Statistic Data\n")
{
isis->debugs |= DEBUG_SPF_STATS;
print_debug (vty, DEBUG_SPF_STATS, 1);
@@ -796,12 +799,11 @@
"no debug isis spf-statistics",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS SPF Timing and Statistic Data\n"
- )
+ "IS-IS SPF Timing and Statistic Data\n")
{
isis->debugs &= ~DEBUG_SPF_STATS;
print_debug (vty, DEBUG_SPF_STATS, 0);
-
+
return CMD_SUCCESS;
}
@@ -810,8 +812,7 @@
"debug isis spf-triggers",
DEBUG_STR
"IS-IS information\n"
- "IS-IS SPF triggering events\n"
- )
+ "IS-IS SPF triggering events\n")
{
isis->debugs |= DEBUG_SPF_TRIGGERS;
print_debug (vty, DEBUG_SPF_TRIGGERS, 1);
@@ -824,12 +825,11 @@
"no debug isis spf-triggers",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS SPF triggering events\n"
- )
+ "IS-IS SPF triggering events\n")
{
isis->debugs &= ~DEBUG_SPF_TRIGGERS;
print_debug (vty, DEBUG_SPF_TRIGGERS, 0);
-
+
return CMD_SUCCESS;
}
@@ -838,8 +838,7 @@
"debug isis route-events",
DEBUG_STR
"IS-IS information\n"
- "IS-IS Route related events\n"
- )
+ "IS-IS Route related events\n")
{
isis->debugs |= DEBUG_RTE_EVENTS;
print_debug (vty, DEBUG_RTE_EVENTS, 1);
@@ -852,12 +851,11 @@
"no debug isis route-events",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS Route related events\n"
- )
+ "IS-IS Route related events\n")
{
isis->debugs &= ~DEBUG_RTE_EVENTS;
print_debug (vty, DEBUG_RTE_EVENTS, 0);
-
+
return CMD_SUCCESS;
}
@@ -866,8 +864,7 @@
"debug isis events",
DEBUG_STR
"IS-IS information\n"
- "IS-IS Events\n"
- )
+ "IS-IS Events\n")
{
isis->debugs |= DEBUG_EVENTS;
print_debug (vty, DEBUG_EVENTS, 1);
@@ -880,16 +877,14 @@
"no debug isis events",
UNDEBUG_STR
"IS-IS information\n"
- "IS-IS Events\n"
- )
+ "IS-IS Events\n")
{
isis->debugs &= ~DEBUG_EVENTS;
print_debug (vty, DEBUG_EVENTS, 0);
-
+
return CMD_SUCCESS;
}
-
DEFUN (show_hostname,
show_hostname_cmd,
"show isis hostname",
@@ -898,51 +893,47 @@
"IS-IS Dynamic hostname mapping\n")
{
dynhn_print_all (vty);
-
+
return CMD_SUCCESS;
}
-
DEFUN (show_database,
show_database_cmd,
"show isis database",
- SHOW_STR
- "IS-IS information\n"
- "IS-IS link state database\n")
+ SHOW_STR "IS-IS information\n" "IS-IS link state database\n")
{
struct listnode *node;
struct isis_area *area;
- int level,lsp_count;
+ int level, lsp_count;
if (isis->area_list->count == 0)
return CMD_SUCCESS;
-
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
- vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
- VTY_NEWLINE);
- for (level=0;level<ISIS_LEVELS;level++) {
- if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0) {
- vty_out (vty,"IS-IS Level-%d link-state database:%s", level+1,
- VTY_NEWLINE);
- lsp_count = lsp_print_all (vty, area->lspdb[level],
- ISIS_UI_LEVEL_BRIEF,
- area->dynhostname);
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
+ vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
+ VTY_NEWLINE);
+ for (level = 0; level < ISIS_LEVELS; level++)
+ {
+ if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)
+ {
+ vty_out (vty, "IS-IS Level-%d link-state database:%s",
+ level + 1, VTY_NEWLINE);
- vty_out (vty,"%s %u LSPs%s%s",
- VTY_NEWLINE,
- lsp_count,
- VTY_NEWLINE,
- VTY_NEWLINE);
- }
+ lsp_count = lsp_print_all (vty, area->lspdb[level],
+ ISIS_UI_LEVEL_BRIEF,
+ area->dynhostname);
+
+ vty_out (vty, "%s %u LSPs%s%s",
+ VTY_NEWLINE, lsp_count, VTY_NEWLINE, VTY_NEWLINE);
+ }
+ }
}
- }
return CMD_SUCCESS;
}
-
DEFUN (show_database_detail,
show_database_detail_cmd,
"show isis database detail",
@@ -957,27 +948,27 @@
if (isis->area_list->count == 0)
return CMD_SUCCESS;
- for (node = listhead (isis->area_list); node; nextnode (node)) {
- area = getdata (node);
- vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
- VTY_NEWLINE);
- for (level=0;level<ISIS_LEVELS;level++) {
- if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0) {
- vty_out (vty,"IS-IS Level-%d Link State Database:%s", level+1,
- VTY_NEWLINE);
+ for (node = listhead (isis->area_list); node; nextnode (node))
+ {
+ area = getdata (node);
+ vty_out (vty, "Area %s:%s", area->area_tag ? area->area_tag : "null",
+ VTY_NEWLINE);
+ for (level = 0; level < ISIS_LEVELS; level++)
+ {
+ if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)
+ {
+ vty_out (vty, "IS-IS Level-%d Link State Database:%s",
+ level + 1, VTY_NEWLINE);
- lsp_count = lsp_print_all (vty, area->lspdb[level],
- ISIS_UI_LEVEL_DETAIL,
- area->dynhostname);
+ lsp_count = lsp_print_all (vty, area->lspdb[level],
+ ISIS_UI_LEVEL_DETAIL,
+ area->dynhostname);
- vty_out (vty,"%s %u LSPs%s%s",
- VTY_NEWLINE,
- lsp_count,
- VTY_NEWLINE,
- VTY_NEWLINE);
- }
+ vty_out (vty, "%s %u LSPs%s%s",
+ VTY_NEWLINE, lsp_count, VTY_NEWLINE, VTY_NEWLINE);
+ }
+ }
}
- }
return CMD_SUCCESS;
}
@@ -988,13 +979,11 @@
DEFUN (router_isis,
router_isis_cmd,
"router isis WORD",
- ROUTER_STR
+ ROUTER_STR
"ISO IS-IS\n"
"ISO Routing area tag")
{
-
return isis_area_get (vty, argv[0]);
-
}
/*
@@ -1003,11 +992,7 @@
DEFUN (no_router_isis,
no_router_isis_cmd,
"no router isis WORD",
- "no\n"
- ROUTER_STR
- "ISO IS-IS\n"
- "ISO Routing area tag")
-
+ "no\n" ROUTER_STR "ISO IS-IS\n" "ISO Routing area tag")
{
return isis_area_destroy (vty, argv[0]);
}
@@ -1019,12 +1004,11 @@
net_cmd,
"net WORD",
"A Network Entity Title for this process (OSI only)\n"
- "XX.XXXX. ... .XXX.XX Network entity title (NET)\n" )
+ "XX.XXXX. ... .XXX.XX Network entity title (NET)\n")
{
return area_net_title (vty, argv[0]);
}
-
/*
* 'no net' command
*/
@@ -1033,7 +1017,7 @@
"no net WORD",
NO_STR
"A Network Entity Title for this process (OSI only)\n"
- "XX.XXXX. ... .XXX.XX Network entity title (NET)\n" )
+ "XX.XXXX. ... .XXX.XX Network entity title (NET)\n")
{
return area_clear_net_title (vty, argv[0]);
}
@@ -1042,27 +1026,29 @@
area_passwd_cmd,
"area-password WORD",
"Configure the authentication password for an area\n"
- "Area password\n" )
+ "Area password\n")
{
struct isis_area *area;
int len;
area = vty->index;
- if (!area) {
- vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
len = strlen (argv[0]);
- if (len > 254) {
- vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
- area->area_passwd.len = (u_char)len;
+ if (len > 254)
+ {
+ vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+ area->area_passwd.len = (u_char) len;
area->area_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;
strncpy (area->area_passwd.passwd, argv[0], 255);
-
+
return CMD_SUCCESS;
}
@@ -1073,49 +1059,50 @@
"Configure the authentication password for an area\n")
{
struct isis_area *area;
-
+
area = vty->index;
- if (!area) {
- vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
memset (&area->area_passwd, 0, sizeof (struct isis_passwd));
return CMD_SUCCESS;
}
-
DEFUN (domain_passwd,
domain_passwd_cmd,
"domain-password WORD",
"Set the authentication password for a routing domain\n"
- "Routing domain password\n" )
+ "Routing domain password\n")
{
struct isis_area *area;
int len;
area = vty->index;
- if (!area) {
- vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
len = strlen (argv[0]);
- if (len > 254) {
- vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
- area->domain_passwd.len = (u_char)len;
+ if (len > 254)
+ {
+ vty_out (vty, "Too long area password (>254)%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+ area->domain_passwd.len = (u_char) len;
area->domain_passwd.type = ISIS_PASSWD_TYPE_CLEARTXT;
strncpy (area->domain_passwd.passwd, argv[0], 255);
-
+
return CMD_SUCCESS;
}
-
DEFUN (no_domain_passwd,
no_domain_passwd_cmd,
"no domain-password WORD",
@@ -1123,16 +1110,17 @@
"Set the authentication password for a routing domain\n")
{
struct isis_area *area;
-
+
area = vty->index;
- if (!area) {
- vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ if (!area)
+ {
+ vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
+
memset (&area->domain_passwd, 0, sizeof (struct isis_passwd));
-
+
return CMD_SUCCESS;
}
@@ -1149,19 +1137,21 @@
area = vty->index;
- if (!area) {
- vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
- return CMD_WARNING;
- }
+ if (!area)
+ {
+ vty_out (vty, "Cant find IS-IS instance%s", VTY_NEWLINE);
+ return CMD_WARNING;
+ }
- type = string2circuit_t (argv[0]);
- if (!type) {
- vty_out (vty, "Unknown IS level %s", VTY_NEWLINE);
- return CMD_SUCCESS;
- }
+ type = string2circuit_t (argv[0]);
+ if (!type)
+ {
+ vty_out (vty, "Unknown IS level %s", VTY_NEWLINE);
+ return CMD_SUCCESS;
+ }
isis_event_system_type_change (area, type);
-
+
return CMD_SUCCESS;
}
@@ -1174,18 +1164,17 @@
"Act as both a station router and an area router\n"
"Act as an area router only\n")
{
-
struct isis_area *area;
int type;
area = vty->index;
assert (area);
-
+
/*
* Put the is-type back to default. Which is level-1-2 on first
* circuit for the area level-1 for the rest
*/
- if (getdata (listhead (isis->area_list)) == area )
+ if (getdata (listhead (isis->area_list)) == area)
type = IS_LEVEL_1_AND_2;
else
type = IS_LEVEL_1;
@@ -1206,7 +1195,7 @@
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
area->lsp_gen_interval[0] = interval;
area->lsp_gen_interval[1] = interval;
@@ -1218,14 +1207,13 @@
no_lsp_gen_interval_cmd,
"no lsp-gen-interval",
NO_STR
- "Minimum interval between regenerating same LSP\n"
- )
+ "Minimum interval between regenerating same LSP\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
+
area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;
area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT;
@@ -1237,23 +1225,21 @@
"no lsp-gen-interval <1-120>",
NO_STR
"Minimum interval between regenerating same LSP\n"
- "Minimum interval in seconds\n"
- )
+ "Minimum interval in seconds\n")
DEFUN (lsp_gen_interval_l1,
lsp_gen_interval_l1_cmd,
"lsp-gen-interval level-1 <1-120>",
"Minimum interval between regenerating same LSP\n"
"Set interval for level 1 only\n"
- "Minimum interval in seconds\n"
- )
+ "Minimum interval in seconds\n")
{
struct isis_area *area;
uint16_t interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
area->lsp_gen_interval[0] = interval;
@@ -1265,15 +1251,13 @@
"no lsp-gen-interval level-1",
NO_STR
"Minimum interval between regenerating same LSP\n"
- "Set interval for level 1 only\n"
-
- )
+ "Set interval for level 1 only\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
+
area->lsp_gen_interval[0] = LSP_GEN_INTERVAL_DEFAULT;
return CMD_SUCCESS;
@@ -1285,24 +1269,21 @@
NO_STR
"Minimum interval between regenerating same LSP\n"
"Set interval for level 1 only\n"
- "Minimum interval in seconds\n"
- )
-
+ "Minimum interval in seconds\n")
DEFUN (lsp_gen_interval_l2,
lsp_gen_interval_l2_cmd,
"lsp-gen-interval level-2 <1-120>",
"Minimum interval between regenerating same LSP\n"
"Set interval for level 2 only\n"
- "Minimum interval in seconds\n"
- )
+ "Minimum interval in seconds\n")
{
struct isis_area *area;
int interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
area->lsp_gen_interval[1] = interval;
@@ -1314,15 +1295,14 @@
"no lsp-gen-interval level-2",
NO_STR
"Minimum interval between regenerating same LSP\n"
- "Set interval for level 2 only\n"
- )
+ "Set interval for level 2 only\n")
{
struct isis_area *area;
int interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
area->lsp_gen_interval[1] = LSP_GEN_INTERVAL_DEFAULT;
@@ -1335,9 +1315,7 @@
NO_STR
"Minimum interval between regenerating same LSP\n"
"Set interval for level 2 only\n"
- "Minimum interval in seconds\n"
- )
-
+ "Minimum interval in seconds\n")
DEFUN (metric_style,
metric_style_cmd,
@@ -1350,7 +1328,7 @@
area = vty->index;
assert (area);
- if (!strcmp(argv[0],"wide"))
+ if (!strcmp (argv[0], "wide"))
area->newmetric = 1;
else
area->newmetric = 0;
@@ -1371,7 +1349,7 @@
area = vty->index;
assert (area);
- if (!strcmp(argv[0],"wide"))
+ if (!strcmp (argv[0], "wide"))
area->newmetric = 0;
else
area->newmetric = 1;
@@ -1383,15 +1361,15 @@
dynamic_hostname_cmd,
"hostname dynamic",
"Dynamic hostname for IS-IS\n"
- "Dynamic hostname\n")
+ "Dynamic hostname\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
+
area->dynhostname = 1;
-
+
return CMD_SUCCESS;
}
@@ -1400,15 +1378,15 @@
"no hostname dynamic",
NO_STR
"Dynamic hostname for IS-IS\n"
- "Dynamic hostname\n")
+ "Dynamic hostname\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
+
area->dynhostname = 0;
-
+
return CMD_SUCCESS;
}
@@ -1420,12 +1398,12 @@
{
struct isis_area *area;
u_int16_t interval;
-
+
area = vty->index;
interval = atoi (argv[0]);
area->min_spf_interval[0] = interval;
area->min_spf_interval[1] = interval;
-
+
return CMD_SUCCESS;
}
@@ -1433,16 +1411,15 @@
no_spf_interval_cmd,
"no spf-interval",
NO_STR
- "Minimum interval between SPF calculations\n"
- )
+ "Minimum interval between SPF calculations\n")
{
struct isis_area *area;
-
+
area = vty->index;
area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1451,8 +1428,7 @@
"no spf-interval <1-120>",
NO_STR
"Minimum interval between SPF calculations\n"
- "Minimum interval between consecutive SPFs in seconds\n"
- )
+ "Minimum interval between consecutive SPFs in seconds\n")
DEFUN (spf_interval_l1,
spf_interval_l1_cmd,
@@ -1463,11 +1439,11 @@
{
struct isis_area *area;
u_int16_t interval;
-
+
area = vty->index;
interval = atoi (argv[0]);
area->min_spf_interval[0] = interval;
-
+
return CMD_SUCCESS;
}
@@ -1479,11 +1455,11 @@
"Set interval for level 1 only\n")
{
struct isis_area *area;
-
+
area = vty->index;
area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1504,11 +1480,11 @@
{
struct isis_area *area;
u_int16_t interval;
-
+
area = vty->index;
interval = atoi (argv[0]);
area->min_spf_interval[1] = interval;
-
+
return CMD_SUCCESS;
}
@@ -1520,11 +1496,11 @@
"Set interval for level 2 only\n")
{
struct isis_area *area;
-
+
area = vty->index;
area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
-
+
return CMD_SUCCESS;
}
@@ -1536,7 +1512,6 @@
"Set interval for level 2 only\n"
"Minimum interval between consecutive SPFs in seconds\n")
-
#ifdef TOPOLOGY_GENERATE
DEFUN (topology_generate_grid,
topology_generate_grid_cmd,
@@ -1558,15 +1533,16 @@
area = vty->index;
assert (area);
- if (!spgrid_check_params (vty, argc, argv)) {
- if (area->topology)
- list_delete (area->topology);
- area->topology = list_new();
- memcpy(area->top_params,vty->buf,200);
- gen_spgrid_topology (vty, area->topology);
- remove_topology_lsps (area);
- generate_topology_lsps (area);
- }
+ if (!spgrid_check_params (vty, argc, argv))
+ {
+ if (area->topology)
+ list_delete (area->topology);
+ area->topology = list_new ();
+ memcpy (area->top_params, vty->buf, 200);
+ gen_spgrid_topology (vty, area->topology);
+ remove_topology_lsps (area);
+ generate_topology_lsps (area);
+ }
return CMD_SUCCESS;
}
@@ -1582,14 +1558,18 @@
struct listnode *node;
struct listnode *node2;
struct arc *arc;
- LIST_LOOP (isis->area_list, area, node) {
- if (area->topology) {
- vty_out (vty, "Topology for isis area:%s%s",area->area_tag, VTY_NEWLINE);
- LIST_LOOP (area->topology, arc, node2) {
- vty_out (vty, "a %ld %ld %ld%s",arc->from_node, arc->to_node,
- arc->distance, VTY_NEWLINE);
+ LIST_LOOP (isis->area_list, area, node)
+ {
+ if (area->topology)
+ {
+ vty_out (vty, "Topology for isis area:%s%s", area->area_tag,
+ VTY_NEWLINE);
+ LIST_LOOP (area->topology, arc, node2)
+ {
+ vty_out (vty, "a %ld %ld %ld%s", arc->from_node, arc->to_node,
+ arc->distance, VTY_NEWLINE);
+ }
}
- }
}
return CMD_SUCCESS;
}
@@ -1597,13 +1577,13 @@
/*
* 'topology base-is' command
*/
-DEFUN (topology_baseis ,
+DEFUN (topology_baseis,
topology_baseis_cmd,
"topology base-is WORD",
"Topology for IS-IS\n"
"Topology for IS-IS\n"
"A Network IS Base for this topology"
- "XX.XXXX.XXXX.XX Network entity title (NET)\n" )
+ "XX.XXXX.XXXX.XX Network entity title (NET)\n")
{
struct isis_area *area;
u_char buff[ISIS_SYS_ID_LEN];
@@ -1611,10 +1591,11 @@
area = vty->index;
assert (area);
- if (sysid2buff (buff, argv[0])) {
- sysid2buff (area->topology_baseis, argv[0]);
- }
-
+ if (sysid2buff (buff, argv[0]))
+ {
+ sysid2buff (area->topology_baseis, argv[0]);
+ }
+
return CMD_SUCCESS;
}
@@ -1626,14 +1607,14 @@
"no topology base-is WORD",
NO_STR
"A Network Entity Title for this process (OSI only)"
- "XX.XXXX. ... .XXX.XX Network entity title (NET)\n" )
+ "XX.XXXX. ... .XXX.XX Network entity title (NET)\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
- memcpy(area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS, ISIS_SYS_ID_LEN);
+ memcpy (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS, ISIS_SYS_ID_LEN);
return CMD_SUCCESS;
}
@@ -1643,41 +1624,41 @@
lsp_lifetime_cmd,
"lsp-lifetime <380-65535>",
"Maximum LSP lifetime\n"
- "LSP lifetime in seconds\n"
- )
+ "LSP lifetime in seconds\n")
{
struct isis_area *area;
uint16_t interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
- if (interval < ISIS_MIN_LSP_LIFETIME) {
- vty_out (vty, "LSP lifetime (%us) below %us%s",
- interval,
- ISIS_MIN_LSP_LIFETIME,
- VTY_NEWLINE);
+ if (interval < ISIS_MIN_LSP_LIFETIME)
+ {
+ vty_out (vty, "LSP lifetime (%us) below %us%s",
+ interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);
- return CMD_WARNING;
- }
+ return CMD_WARNING;
+ }
area->max_lsp_lifetime[0] = interval;
area->max_lsp_lifetime[1] = interval;
- area->lsp_refresh[0] = interval-300;
- area->lsp_refresh[1] = interval-300;
+ area->lsp_refresh[0] = interval - 300;
+ area->lsp_refresh[1] = interval - 300;
- if (area->t_lsp_refresh[0]) {
- thread_cancel (area->t_lsp_refresh[0]);
- thread_execute (master, lsp_refresh_l1, area, 0);
- }
+ if (area->t_lsp_refresh[0])
+ {
+ thread_cancel (area->t_lsp_refresh[0]);
+ thread_execute (master, lsp_refresh_l1, area, 0);
+ }
- if (area->t_lsp_refresh[1]) {
- thread_cancel (area->t_lsp_refresh[1]);
- thread_execute (master, lsp_refresh_l2, area, 0);
- }
+ if (area->t_lsp_refresh[1])
+ {
+ thread_cancel (area->t_lsp_refresh[1]);
+ thread_execute (master, lsp_refresh_l2, area, 0);
+ }
return CMD_SUCCESS;
@@ -1687,18 +1668,17 @@
no_lsp_lifetime_cmd,
"no lsp-lifetime",
NO_STR
- "LSP lifetime in seconds\n"
- )
+ "LSP lifetime in seconds\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
- area->max_lsp_lifetime[0] = MAX_AGE; /* 1200s */
- area->max_lsp_lifetime[1] = MAX_AGE; /* 1200s */
- area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900s */
- area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900s */
+
+ area->max_lsp_lifetime[0] = MAX_AGE; /* 1200s */
+ area->max_lsp_lifetime[1] = MAX_AGE; /* 1200s */
+ area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900s */
+ area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900s */
return CMD_SUCCESS;
}
@@ -1708,36 +1688,33 @@
"no lsp-lifetime <380-65535>",
NO_STR
"Maximum LSP lifetime\n"
- "LSP lifetime in seconds\n"
- )
+ "LSP lifetime in seconds\n")
DEFUN (lsp_lifetime_l1,
lsp_lifetime_l1_cmd,
"lsp-lifetime level-1 <380-65535>",
"Maximum LSP lifetime for Level 1 only\n"
- "LSP lifetime for Level 1 only in seconds\n"
- )
+ "LSP lifetime for Level 1 only in seconds\n")
{
struct isis_area *area;
uint16_t interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
- if (interval < ISIS_MIN_LSP_LIFETIME) {
- vty_out (vty, "Level-1 LSP lifetime (%us) below %us%s",
- interval,
- ISIS_MIN_LSP_LIFETIME,
- VTY_NEWLINE);
+ if (interval < ISIS_MIN_LSP_LIFETIME)
+ {
+ vty_out (vty, "Level-1 LSP lifetime (%us) below %us%s",
+ interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);
- return CMD_WARNING;
- }
+ return CMD_WARNING;
+ }
area->max_lsp_lifetime[0] = interval;
- area->lsp_refresh[0] = interval-300;
+ area->lsp_refresh[0] = interval - 300;
return CMD_SUCCESS;
}
@@ -1746,16 +1723,15 @@
no_lsp_lifetime_l1_cmd,
"no lsp-lifetime level-1",
NO_STR
- "LSP lifetime for Level 1 only in seconds\n"
- )
+ "LSP lifetime for Level 1 only in seconds\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
- area->max_lsp_lifetime[0] = MAX_AGE; /* 1200s */
- area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900s */
+
+ area->max_lsp_lifetime[0] = MAX_AGE; /* 1200s */
+ area->lsp_refresh[0] = MAX_LSP_GEN_INTERVAL; /* 900s */
return CMD_SUCCESS;
}
@@ -1765,33 +1741,29 @@
"no lsp-lifetime level-1 <380-65535>",
NO_STR
"Maximum LSP lifetime for Level 1 only\n"
- "LSP lifetime for Level 1 only in seconds\n"
- )
+ "LSP lifetime for Level 1 only in seconds\n")
DEFUN (lsp_lifetime_l2,
lsp_lifetime_l2_cmd,
"lsp-lifetime level-2 <380-65535>",
"Maximum LSP lifetime for Level 2 only\n"
- "LSP lifetime for Level 2 only in seconds\n"
- )
+ "LSP lifetime for Level 2 only in seconds\n")
{
struct isis_area *area;
uint16_t interval;
area = vty->index;
assert (area);
-
+
interval = atoi (argv[0]);
- if (interval < ISIS_MIN_LSP_LIFETIME) {
- vty_out (vty, "Level-2 LSP lifetime (%us) below %us%s",
- interval,
- ISIS_MIN_LSP_LIFETIME,
- VTY_NEWLINE);
+ if (interval < ISIS_MIN_LSP_LIFETIME)
+ {
+ vty_out (vty, "Level-2 LSP lifetime (%us) below %us%s",
+ interval, ISIS_MIN_LSP_LIFETIME, VTY_NEWLINE);
- return CMD_WARNING;
- }
-
+ return CMD_WARNING;
+ }
area->max_lsp_lifetime[1] = interval;
area->lsp_refresh[1] = interval - 300;
@@ -1803,16 +1775,15 @@
no_lsp_lifetime_l2_cmd,
"no lsp-lifetime level-2",
NO_STR
- "LSP lifetime for Level 2 only in seconds\n"
- )
+ "LSP lifetime for Level 2 only in seconds\n")
{
struct isis_area *area;
area = vty->index;
assert (area);
-
- area->max_lsp_lifetime[1] = MAX_AGE; /* 1200s */
- area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900s */
+
+ area->max_lsp_lifetime[1] = MAX_AGE; /* 1200s */
+ area->lsp_refresh[1] = MAX_LSP_GEN_INTERVAL; /* 900s */
return CMD_SUCCESS;
}
@@ -1822,127 +1793,149 @@
"no lsp-lifetime level-2 <380-65535>",
NO_STR
"Maximum LSP lifetime for Level 2 only\n"
- "LSP lifetime for Level 2 only in seconds\n"
- )
-
-
-
+ "LSP lifetime for Level 2 only in seconds\n")
/* IS-IS configuration write function */
int
isis_config_write (struct vty *vty)
{
int write = 0;
-
- if (isis != NULL) {
- struct isis_area *area;
- struct listnode *node;
- struct listnode *node2;
- LIST_LOOP (isis->area_list, area, node) {
- /* ISIS - Area name */
- vty_out (vty, "router isis %s%s",area->area_tag, VTY_NEWLINE);
- write++;
- /* ISIS - Net */
- if (listcount (area->area_addrs) > 0) {
- struct area_addr *area_addr;
- LIST_LOOP (area->area_addrs, area_addr, node2) {
- vty_out (vty, " net %s%s",
- isonet_print (area_addr->area_addr,
- area_addr->addr_len + ISIS_SYS_ID_LEN + 1),
- VTY_NEWLINE);
- write ++;
- }
- }
- /* ISIS - Dynamic hostname - Defaults to true so only display if false*/
- if (!area->dynhostname) {
- vty_out (vty, " no hostname dynamic%s", VTY_NEWLINE);
- write ++;
- }
- /* ISIS - Metric-Style - when true displays wide */
- if (area->newmetric) {
- vty_out (vty, " metric-style wide%s", VTY_NEWLINE);
- write ++;
- }
- /* ISIS - Area is-type (level-1-2 is default) */
- if (area->is_type == IS_LEVEL_1) {
- vty_out (vty, " is-type level-1%s", VTY_NEWLINE);
- write ++;
- } else {if (area->is_type == IS_LEVEL_2) {
- vty_out (vty, " is-type level-2-only%s", VTY_NEWLINE);
- write ++;
- }}
- /* ISIS - Lsp generation interval */
- if (area->lsp_gen_interval[0] == area->lsp_gen_interval[1]) {
- if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT) {
- vty_out (vty, " lsp-gen-interval %d%s", area->lsp_gen_interval[0],
- VTY_NEWLINE);
- write ++;
- }} else {
- if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT) {
- vty_out (vty, " lsp-gen-interval level-1 %d%s",
- area->lsp_gen_interval[0], VTY_NEWLINE);
- write ++;
- }
- if (area->lsp_gen_interval[1] != LSP_GEN_INTERVAL_DEFAULT) {
- vty_out (vty, " lsp-gen-interval level-2 %d%s",
- area->lsp_gen_interval[1], VTY_NEWLINE);
- write ++;
- }
- }
- /* ISIS - LSP lifetime */
- if (area->max_lsp_lifetime[0] == area->max_lsp_lifetime[1]) {
- if (area->max_lsp_lifetime[0] != MAX_AGE) {
- vty_out (vty, " lsp-lifetime %u%s", area->max_lsp_lifetime[0],
- VTY_NEWLINE);
- write ++;
- }} else {
- if (area->max_lsp_lifetime[0] != MAX_AGE) {
- vty_out (vty, " lsp-lifetime level-1 %u%s", area->max_lsp_lifetime[0],
- VTY_NEWLINE);
- write ++;
- }
- if (area->max_lsp_lifetime[1] != MAX_AGE) {
- vty_out (vty, " lsp-lifetime level-2 %u%s", area->max_lsp_lifetime[1],
- VTY_NEWLINE);
- write ++;
- }
- }
- #ifdef TOPOLOGY_GENERATE
- /* seems we save the whole command line here */
- if (area->top_params) {
- vty_out (vty, " %s%s",area->top_params, VTY_NEWLINE);
- write ++;
- }
+ if (isis != NULL)
+ {
+ struct isis_area *area;
+ struct listnode *node;
+ struct listnode *node2;
- if (memcmp(area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS,
- ISIS_SYS_ID_LEN)) {
- vty_out (vty, " topology base_is %s%s",
- sysid_print (area->topology_baseis), VTY_NEWLINE);
- write ++;
- }
+ LIST_LOOP (isis->area_list, area, node)
+ {
+ /* ISIS - Area name */
+ vty_out (vty, "router isis %s%s", area->area_tag, VTY_NEWLINE);
+ write++;
+ /* ISIS - Net */
+ if (listcount (area->area_addrs) > 0)
+ {
+ struct area_addr *area_addr;
+ LIST_LOOP (area->area_addrs, area_addr, node2)
+ {
+ vty_out (vty, " net %s%s",
+ isonet_print (area_addr->area_addr,
+ area_addr->addr_len + ISIS_SYS_ID_LEN +
+ 1), VTY_NEWLINE);
+ write++;
+ }
+ }
+ /* ISIS - Dynamic hostname - Defaults to true so only display if false */
+ if (!area->dynhostname)
+ {
+ vty_out (vty, " no hostname dynamic%s", VTY_NEWLINE);
+ write++;
+ }
+ /* ISIS - Metric-Style - when true displays wide */
+ if (area->newmetric)
+ {
+ vty_out (vty, " metric-style wide%s", VTY_NEWLINE);
+ write++;
+ }
+ /* ISIS - Area is-type (level-1-2 is default) */
+ if (area->is_type == IS_LEVEL_1)
+ {
+ vty_out (vty, " is-type level-1%s", VTY_NEWLINE);
+ write++;
+ }
+ else
+ {
+ if (area->is_type == IS_LEVEL_2)
+ {
+ vty_out (vty, " is-type level-2-only%s", VTY_NEWLINE);
+ write++;
+ }
+ }
+ /* ISIS - Lsp generation interval */
+ if (area->lsp_gen_interval[0] == area->lsp_gen_interval[1])
+ {
+ if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT)
+ {
+ vty_out (vty, " lsp-gen-interval %d%s",
+ area->lsp_gen_interval[0], VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ if (area->lsp_gen_interval[0] != LSP_GEN_INTERVAL_DEFAULT)
+ {
+ vty_out (vty, " lsp-gen-interval level-1 %d%s",
+ area->lsp_gen_interval[0], VTY_NEWLINE);
+ write++;
+ }
+ if (area->lsp_gen_interval[1] != LSP_GEN_INTERVAL_DEFAULT)
+ {
+ vty_out (vty, " lsp-gen-interval level-2 %d%s",
+ area->lsp_gen_interval[1], VTY_NEWLINE);
+ write++;
+ }
+ }
+ /* ISIS - LSP lifetime */
+ if (area->max_lsp_lifetime[0] == area->max_lsp_lifetime[1])
+ {
+ if (area->max_lsp_lifetime[0] != MAX_AGE)
+ {
+ vty_out (vty, " lsp-lifetime %u%s", area->max_lsp_lifetime[0],
+ VTY_NEWLINE);
+ write++;
+ }
+ }
+ else
+ {
+ if (area->max_lsp_lifetime[0] != MAX_AGE)
+ {
+ vty_out (vty, " lsp-lifetime level-1 %u%s",
+ area->max_lsp_lifetime[0], VTY_NEWLINE);
+ write++;
+ }
+ if (area->max_lsp_lifetime[1] != MAX_AGE)
+ {
+ vty_out (vty, " lsp-lifetime level-2 %u%s",
+ area->max_lsp_lifetime[1], VTY_NEWLINE);
+ write++;
+ }
+ }
+#ifdef TOPOLOGY_GENERATE
+ /* seems we save the whole command line here */
+ if (area->top_params)
+ {
+ vty_out (vty, " %s%s", area->top_params, VTY_NEWLINE);
+ write++;
+ }
- #endif /* TOPOLOGY_GENERATE */
+ if (memcmp (area->topology_baseis, DEFAULT_TOPOLOGY_BASEIS,
+ ISIS_SYS_ID_LEN))
+ {
+ vty_out (vty, " topology base_is %s%s",
+ sysid_print (area->topology_baseis), VTY_NEWLINE);
+ write++;
+ }
+
+#endif /* TOPOLOGY_GENERATE */
+ }
}
- }
-
+
return write;
}
-struct cmd_node isis_node =
-{
+struct cmd_node isis_node = {
ISIS_NODE,
"%s(config-router)# ",
1
};
-void
+void
isis_init ()
{
-
/* Install IS-IS top node */
install_node (&isis_node, isis_config_write);
-
+
install_element (VIEW_NODE, &show_clns_neighbors_cmd);
install_element (VIEW_NODE, &show_isis_neighbors_cmd);
install_element (VIEW_NODE, &show_clns_neighbors_detail_cmd);
@@ -1962,7 +1955,7 @@
install_element (ENABLE_NODE, &show_database_detail_cmd);
install_element (ENABLE_NODE, &show_debugging_cmd);
- install_node(&debug_node, config_write_debug);
+ install_node (&debug_node, config_write_debug);
install_element (ENABLE_NODE, &debug_isis_adj_cmd);
install_element (ENABLE_NODE, &no_debug_isis_adj_cmd);
@@ -2046,7 +2039,7 @@
install_element (ISIS_NODE, &spf_interval_l2_cmd);
install_element (ISIS_NODE, &no_spf_interval_l2_cmd);
install_element (ISIS_NODE, &no_spf_interval_l2_arg_cmd);
-
+
install_element (ISIS_NODE, &lsp_lifetime_cmd);
install_element (ISIS_NODE, &no_lsp_lifetime_cmd);
install_element (ISIS_NODE, &no_lsp_lifetime_arg_cmd);
@@ -2070,14 +2063,8 @@
install_element (ENABLE_NODE, &show_isis_topology_cmd);
#endif /* TOPOLOGY_GENERATE */
- isis_new(0);
+ isis_new (0);
isis_circuit_init ();
isis_zebra_init ();
isis_spf_cmds_init ();
}
-
-
-
-
-
-
diff --git a/isisd/isisd.h b/isisd/isisd.h
index 3ca421a..f1093cc 100644
--- a/isisd/isisd.h
+++ b/isisd/isisd.h
@@ -32,7 +32,8 @@
/* If you want topology stuff compiled in */
/* #define TOPOLOGY_GENERATE */
-struct rmap{
+struct rmap
+{
char *name;
struct route_map *map;
};
@@ -41,58 +42,62 @@
{
u_long process_id;
int sysid_set;
- u_char sysid[ISIS_SYS_ID_LEN]; /* SystemID for this IS */
- struct list *area_list; /* list of IS-IS areas */
+ u_char sysid[ISIS_SYS_ID_LEN]; /* SystemID for this IS */
+ struct list *area_list; /* list of IS-IS areas */
struct list *init_circ_list;
- struct list *nexthops; /* IPv4 next hops from this IS */
+ struct list *nexthops; /* IPv4 next hops from this IS */
#ifdef HAVE_IPV6
- struct list *nexthops6; /* IPv6 next hops from this IS */
-#endif /* HAVE_IPV6 */
- u_char max_area_addrs; /* maximumAreaAdresses */
- struct area_addr *man_area_addrs; /* manualAreaAddresses */
- u_int32_t debugs; /* bitmap for debug */
- time_t uptime; /* when did we start */
-
+ struct list *nexthops6; /* IPv6 next hops from this IS */
+#endif /* HAVE_IPV6 */
+ u_char max_area_addrs; /* maximumAreaAdresses */
+ struct area_addr *man_area_addrs; /* manualAreaAddresses */
+ u_int32_t debugs; /* bitmap for debug */
+ time_t uptime; /* when did we start */
+
/* Redistributed external information. */
struct route_table *external_info[ZEBRA_ROUTE_MAX + 1];
/* Redistribute metric info. */
- struct {
- int type; /* Internal or External */
- int value; /* metric value */
- } dmetric [ZEBRA_ROUTE_MAX + 1];
+ struct
+ {
+ int type; /* Internal or External */
+ int value; /* metric value */
+ } dmetric[ZEBRA_ROUTE_MAX + 1];
- struct {
+ struct
+ {
char *name;
struct route_map *map;
- } rmap [ZEBRA_ROUTE_MAX + 1];
+ } rmap[ZEBRA_ROUTE_MAX + 1];
#ifdef HAVE_IPV6
- struct {
- struct {
+ struct
+ {
+ struct
+ {
char *name;
struct route_map *map;
- } rmap [ZEBRA_ROUTE_MAX + 1];
+ } rmap[ZEBRA_ROUTE_MAX + 1];
} inet6_afmode;
#endif
};
-struct isis_area
+struct isis_area
{
- struct isis *isis; /* back pointer */
- dict_t *lspdb[ISIS_LEVELS]; /* link-state dbs */
- struct isis_spftree *spftree[ISIS_LEVELS]; /* The v4 SPTs */
- struct route_table *route_table; /* IPv4 routes */
+ struct isis *isis; /* back pointer */
+ dict_t *lspdb[ISIS_LEVELS]; /* link-state dbs */
+ struct isis_spftree *spftree[ISIS_LEVELS]; /* The v4 SPTs */
+ struct route_table *route_table; /* IPv4 routes */
#ifdef HAVE_IPV6
- struct isis_spftree *spftree6[ISIS_LEVELS]; /* The v4 SPTs */
- struct route_table *route_table6; /* IPv6 routes */
+ struct isis_spftree *spftree6[ISIS_LEVELS]; /* The v4 SPTs */
+ struct route_table *route_table6; /* IPv6 routes */
#endif
int min_bcast_mtu;
- struct list *circuit_list; /* IS-IS circuits */
- struct flags flags;
- struct thread *t_tick; /* LSP walker */
- struct thread *t_remove_aged;
+ struct list *circuit_list; /* IS-IS circuits */
+ struct flags flags;
+ struct thread *t_tick; /* LSP walker */
+ struct thread *t_remove_aged;
int lsp_regenerate_pending[ISIS_LEVELS];
struct thread *t_lsp_refresh[ISIS_LEVELS];
-
+
/*
* Configurables
*/
@@ -101,34 +106,34 @@
/* do we support dynamic hostnames? */
char dynhostname;
/* do we support new style metrics? */
- char newmetric;
+ char newmetric;
/* identifies the routing instance */
- char *area_tag;
+ char *area_tag;
/* area addresses for this area */
- struct list *area_addrs;
- u_int16_t max_lsp_lifetime[ISIS_LEVELS];
- char is_type; /* level-1 level-1-2 or level-2-only */
+ struct list *area_addrs;
+ u_int16_t max_lsp_lifetime[ISIS_LEVELS];
+ char is_type; /* level-1 level-1-2 or level-2-only */
u_int16_t lsp_refresh[ISIS_LEVELS];
/* minimum time allowed before lsp retransmission */
u_int16_t lsp_gen_interval[ISIS_LEVELS];
/* min interval between between consequtive SPFs */
- u_int16_t min_spf_interval[ISIS_LEVELS];
+ u_int16_t min_spf_interval[ISIS_LEVELS];
/* the percentage of LSP mtu size used, before generating a new frag */
- int lsp_frag_threshold;
+ int lsp_frag_threshold;
int ip_circuits;
#ifdef HAVE_IPV6
int ipv6_circuits;
-#endif /* HAVE_IPV6 */
+#endif /* HAVE_IPV6 */
/* Counters */
u_int32_t circuit_state_changes;
#ifdef TOPOLOGY_GENERATE
- struct list *topology;
- char topology_baseis[ISIS_SYS_ID_LEN]; /* is for the first is emulated */
- char top_params[200]; /* FIXME: what is reasonable? */
-#endif /* TOPOLOGY_GENERATE */
+ struct list *topology;
+ char topology_baseis[ISIS_SYS_ID_LEN]; /* is for the first is emulated */
+ char top_params[200]; /* FIXME: what is reasonable? */
+#endif /* TOPOLOGY_GENERATE */
};
-void isis_init(void);
+void isis_init (void);
struct isis_area *isis_area_lookup (char *);
#define DEBUG_ADJ_PACKETS (1<<0)
diff --git a/isisd/iso_checksum.c b/isisd/iso_checksum.c
index d0bb8a7..e65f6ef 100644
--- a/isisd/iso_checksum.c
+++ b/isisd/iso_checksum.c
@@ -46,8 +46,8 @@
*/
int
-iso_csum_verify (u_char *buffer, int len, uint16_t *csum)
-{
+iso_csum_verify (u_char * buffer, int len, uint16_t * csum)
+{
u_int8_t *p;
u_int32_t c0;
u_int32_t c1;
@@ -70,28 +70,28 @@
*/
if (c0 == 0 || c1 == 0)
return 1;
-
+
/*
* Otherwise initialize to zero and calculate...
*/
c0 = 0;
c1 = 0;
- for (i = 0; i < len; i++) {
- c0 = c0 + *(p++);
- c1 += c0;
- }
+ for (i = 0; i < len; i++)
+ {
+ c0 = c0 + *(p++);
+ c1 += c0;
+ }
c0 = c0 % 255;
c1 = c1 % 255;
-
- if ( c0 == 0 && c1 == 0)
+
+ if (c0 == 0 && c1 == 0)
return 0;
return 1;
}
-
/*
* Creates the checksum. *csum points to the position of the checksum in the
* PDU.
@@ -102,7 +102,7 @@
*/
#define FIXED_CODE
u_int16_t
-iso_csum_create (u_char *buffer, int len, u_int16_t n)
+iso_csum_create (u_char * buffer, int len, u_int16_t n)
{
u_int8_t *p;
@@ -112,7 +112,7 @@
u_int32_t c0;
u_int32_t c1;
u_int16_t checksum;
- u_int16_t *csum;
+ u_int16_t *csum;
int i;
checksum = 0;
@@ -120,40 +120,46 @@
/*
* Zero the csum in the packet.
*/
- csum = (u_int16_t*)(buffer + n);
+ csum = (u_int16_t *) (buffer + n);
*(csum) = checksum;
/* for the limitation of our implementation */
- if (len > 5000) {
- return 0;
- }
+ if (len > 5000)
+ {
+ return 0;
+ }
p = buffer;
c0 = 0;
c1 = 0;
- for (i = 0; i < len; i++) {
- c0 = c0 + *(p++);
- c1 += c0;
- }
+ for (i = 0; i < len; i++)
+ {
+ c0 = c0 + *(p++);
+ c1 += c0;
+ }
c0 = c0 % 255;
c1 = c1 % 255;
- mul = (len - n)*(c0);
-
+ mul = (len - n) * (c0);
+
#ifdef FIXED_CODE
x = mul - c0 - c1;
y = c1 - mul - 1;
- if ( y >= 0 ) y++;
- if ( x < 0 ) x--;
+ if (y >= 0)
+ y++;
+ if (x < 0)
+ x--;
x %= 255;
y %= 255;
- if (x == 0) x = 255;
- if (y == 0) y = 255;
+ if (x == 0)
+ x = 255;
+ if (y == 0)
+ y = 255;
x &= 0x00FF;
@@ -166,12 +172,14 @@
y = c1 - mul - 1;
y %= 255;
- if (x == 0) x = 255;
- if (y == 0) y = 255;
+ if (x == 0)
+ x = 255;
+ if (y == 0)
+ y = 255;
checksum = ((y << 8) | x);
#endif
-
+
/*
* Now we write this to the packet
*/
@@ -181,12 +189,8 @@
return checksum;
}
-
int
-iso_csum_modify (u_char *buffer, int len, uint16_t *csum)
+iso_csum_modify (u_char * buffer, int len, uint16_t * csum)
{
-
return 0;
}
-
-
diff --git a/isisd/iso_checksum.h b/isisd/iso_checksum.h
index cf600a8..ba0d198 100644
--- a/isisd/iso_checksum.h
+++ b/isisd/iso_checksum.h
@@ -23,7 +23,7 @@
#ifndef _ZEBRA_ISO_CSUM_H
#define _ZEBRA_ISO_CSUM_H
-int iso_csum_verify (u_char *buffer, int len, uint16_t *csum);
-u_int16_t iso_csum_create (u_char *buffer, int len, u_int16_t n);
+int iso_csum_verify (u_char * buffer, int len, uint16_t * csum);
+u_int16_t iso_csum_create (u_char * buffer, int len, u_int16_t n);
#endif /* _ZEBRA_ISO_CSUM_H */