diff options
Diffstat (limited to 'isisd')
40 files changed, 10011 insertions, 9024 deletions
diff --git a/isisd/dict.c b/isisd/dict.c index 4c787ac5..86206a3b 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 @@ static const char rcsid[] = "$Id: dict.c,v 1.1 2003/12/23 08:09:47 jardin Exp $" #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 @@ static void dnode_free(dnode_t *node, void *context); * 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 @@ static void rotate_left(dnode_t *upper) * 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 @@ static void rotate_right(dnode_t *upper) * 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 @@ static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil) * 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; + 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; + } + else + { + while (first && (next = dict_next (dict, first))) + { + if (dict->compare (first->key, next->key) >= 0) + return 0; + first = next; } } - return 1; + return 1; } @@ -181,29 +197,32 @@ static int verify_bintree(dict_t *dict) * 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 @@ static unsigned int verify_redblack(dnode_t *nil, dnode_t *root) * 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 @@ static dictcount_t verify_node_count(dnode_t *nil, dnode_t *root) * 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); - - 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; + 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; } - 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 @@ void dict_set_allocator(dict_t *dict, dnode_alloc_t al, * 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 @@ void dict_destroy(dict_t *dict) * 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; - - assert (dict_similar(dict, 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; + + 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 @@ int dict_verify(dict_t *dict) * 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 @@ int dict_similar(const dict_t *left, const dict_t *right) * 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; - - /* 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; + 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 */ + + 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 @@ dnode_t *dict_lookup(dict_t *dict, const void *key) * 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; - - 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; + 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); + + 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 @@ dnode_t *dict_lower_bound(dict_t *dict, const void *key) * 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; - - 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; + 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); + + 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 @@ dnode_t *dict_upper_bound(dict_t *dict, const void *key) * 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; - - node->key = key; - - assert (!dict_isfull(dict)); - assert (!dict_contains(dict, node)); - assert (!dnode_is_in_a_dict(node)); - - /* 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; + dnode_t *where = dict_root (dict), *nil = dict_nil (dict); + dnode_t *parent = nil, *uncle, *grandpa; + int result = -1; + + node->key = key; + + assert (!dict_isfull (dict)); + assert (!dict_contains (dict, node)); + assert (!dnode_is_in_a_dict (node)); + + /* 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; } - assert (where == nil); - - if (result < 0) - parent->left = node; - else - parent->right = node; - - node->parent = parent; - node->left = nil; - node->right = nil; - - dict->nodecount++; - - /* red black adjustments */ - - 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 */ + assert (where == nil); + + if (result < 0) + parent->left = node; + else + parent->right = node; + + node->parent = parent; + node->left = nil; + node->right = nil; + + dict->nodecount++; + + /* red black adjustments */ + + 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; + 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 { /* 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 + { + 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; + 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 @@ void dict_insert(dict_t *dict, dnode_t *node, const void *key) * 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; - - /* basic deletion */ - - 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 (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); - - /* - * First, splice out the successor from the tree completely, by - * moving up its right child into its place. - */ - - child = next->right; - child->parent = nextparent; - - if (nextparent->left == next) { - nextparent->left = child; - } else { - assert (nextparent->right == next); - nextparent->right = child; + dnode_t *nil = dict_nil (dict), *child, *delparent = delete->parent; + + /* basic deletion */ + + 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 (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); + + /* + * First, splice out the successor from the tree completely, by + * moving up its right child into its place. + */ + + child = next->right; + child->parent = nextparent; + + 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; - - if (delparent->left == delete) { - delparent->left = next; - } else { - assert (delparent->right == delete); - delparent->right = next; + 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; } - } 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; } - 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); + 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; } - 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); + 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 @@ dnode_t *dict_delete(dict_t *dict, dnode_t *delete) * 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 @@ void dict_delete_free(dict_t *dict, dnode_t *node) * (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 @@ dnode_t *dict_first(dict_t *dict) * (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 @@ dnode_t *dict_last(dict_t *dict) * 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; - - if (curr->right != nil) { - curr = curr->right; - while ((left = curr->left) != nil) - curr = left; - return curr; + dnode_t *nil = dict_nil (dict), *parent, *left; + + 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 @@ dnode_t *dict_next(dict_t *dict, dnode_t *curr) * 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; - - if (curr->left != nil) { - curr = curr->left; - while ((right = curr->right) != nil) - curr = right; - return curr; + dnode_t *nil = dict_nil (dict), *parent, *right; + + 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 @@ void dict_allow_dupes(dict_t *dict) #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; - - 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; + 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; } } -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); - - #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); + dict_t *dict = load->dictptr; + dnode_t *nil = &load->nilnode; + + 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; - - assert (dnode_red == 0 && dnode_black == 1); - - while (fullcount >= nodecount && fullcount) - fullcount >>= 1; - - botrowcount = nodecount - fullcount; - - 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 != 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; + 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); + + while (fullcount >= nodecount && fullcount) + fullcount >>= 1; + + botrowcount = nodecount - fullcount; + + 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 != 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; - - assert (level == baselevel); - 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; + + 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; } - - copyleft: + else if (leftnode != NULL) { - 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; + goto copyleft; } - - copyright: + else if (rightnode != NULL) + { + goto copyright; + } + else { - dnode_t *next = dict_next(source, rightnode); - #ifndef NDEBUG - rightnode->left = NULL; - #endif - dict_load_next(&load, rightnode, rightnode->key); - rightnode = next; - continue; + 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; + } + + copyright: + { + 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 @@ void dict_merge(dict_t *dest, dict_t *source) typedef char input_t[256]; -static int tokenize(char *string, ...) +static int +tokenize (char *string, ...) { - 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; + 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_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"; - - if (!dict_isempty(d)) - puts("warning: dictionary not empty!"); - - dict_load_begin(&dl, d); - - while (!done) { - if (prompt) - putchar('>'); - fflush(stdout); - - 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); - - if (!key || !val || !dn) { - puts("out of memory"); - free((void *) key); - free(val); - if (dn) - dnode_destroy(dn); - } + 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!"); + + dict_load_begin (&dl, d); + + while (!done) + { + if (prompt) + putchar ('>'); + fflush (stdout); + + 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); + + 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; - - 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 (;;) { - if (prompt) - putchar('>'); - fflush(stdout); - - 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); - - if (!key || !val) { - puts("out of memory"); - free((void *) key); - free(val); - } + 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"; + + for (i = 0; i < sizeof darray / sizeof *darray; i++) + dict_init (&darray[i], DICTCOUNT_T_MAX, comparef); + + for (;;) + { + if (prompt) + putchar ('>'); + fflush (stdout); + + 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); + + 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); - - free(val); - free((void *) key); - break; - case 'f': - dict_free(d); - break; + 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; + 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 = 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; - } - 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]; + 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; } - 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]); + 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; } - 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 2977a90f..1a5e9d7c 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 @@ typedef struct dict_t { 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; - -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 *); +#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 *); #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 86fed1d9..3770ebde 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 */ - adj = adj_alloc (id); /* P2P kludge */ - - if (adj == NULL){ - zlog_err ("Out of memory!"); - return NULL; - } + 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++; - - /* 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); - } + 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]--; + } + + 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 @@ isis_adj_print (struct isis_adjacency *adj) 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)); + 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); + +#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 @@ isis_adj_expire (struct thread *thread) 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 @@ isis_adj_print_vty2 (struct isis_adjacency *adj, struct vty *vty, char detail) #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 @@ isis_adj_print_vty2 (struct isis_adjacency *adj, struct vty *vty, char detail) 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_p2p_print_vty (struct isis_adjacency *adj, struct vty *vty) 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 @@ isis_adj_build_up_list (struct list *adjdb, struct list *list) 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 5c0772cc..a9b1913e 100644 --- a/isisd/isis_adjacency.h +++ b/isisd/isis_adjacency.h @@ -33,7 +33,7 @@ enum isis_adj_usage ISIS_ADJ_LEVEL1AND2 }; -enum isis_system_type +enum isis_system_type { ISIS_SYSTYPE_UNKNOWN, ISIS_SYSTYPE_ES, @@ -42,7 +42,7 @@ enum isis_system_type ISIS_SYSTYPE_L2_IS }; -enum isis_adj_state +enum isis_adj_state { ISIS_ADJ_INITIALIZING, ISIS_ADJ_UP, @@ -62,65 +62,66 @@ enum isis_adj_updown_reason 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 192b107f..671ebbff 100644 --- a/isisd/isis_circuit.c +++ b/isisd/isis_circuit.c @@ -67,24 +67,27 @@ isis_circuit_new () 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; - } - } else { - zlog_err ("Can't malloc isis circuit"); - return NULL; - } - + 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; + } + return circuit; } - void isis_circuit_configure (struct isis_circuit *circuit, struct isis_area *area) { @@ -98,18 +101,20 @@ isis_circuit_configure (struct isis_circuit *circuit, struct isis_area *area) /* * 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 @@ isis_circuit_configure (struct isis_circuit *circuit, struct isis_area *area) 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 @@ circuit_lookup_by_ifp (struct interface *ifp, struct list *list) { 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 @@ circuit_scan_by_ifp (struct interface *ifp) 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 @@ isis_circuit_del (struct isis_circuit *circuit) 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 @@ isis_circuit_del (struct isis_circuit *circuit) 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 @@ isis_circuit_del (struct isis_circuit *circuit) } 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 */ - } + 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); - } - prefix2str (conn->address, buf, BUFSIZ); + 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 @@ isis_circuit_if_add (struct isis_circuit *circuit, struct interface *ifp) 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 @@ isis_circuit_update_params (struct isis_circuit *circuit, 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 - */ - - /* 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->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 + */ + + /* 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); + + } /* 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 @@ isis_circuit_up (struct isis_circuit *circuit) 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 @@ void 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 @@ isis_interface_config_write (struct vty *vty) 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 - 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 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 - 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 - 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 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 @@ DEFUN (ip_router_isis, "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 */ - } - + } + /* 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 @@ DEFUN (ip_router_isis, circuit_update_nlpids (c); vty->node = INTERFACE_NODE; - + return CMD_SUCCESS; } @@ -725,36 +824,37 @@ DEFUN (no_ip_router_isis, "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 @@ DEFUN (isis_circuit_type, "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 @@ DEFUN (no_isis_circuit_type, "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; + + ifp = vty->index; circuit = ifp->info; - if (circuit == NULL) { - return CMD_WARNING; - } + if (circuit == NULL) + { + return CMD_WARNING; + } + + assert (circuit); - 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 @@ DEFUN (isis_passwd, 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 @@ DEFUN (no_isis_passwd, { 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 @@ DEFUN (isis_priority, "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 @@ DEFUN (no_isis_priority, "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 @@ ALIAS (no_isis_priority, 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 @@ DEFUN (no_isis_priority_l1, 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 @@ ALIAS (no_isis_priority_l1, "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 @@ DEFUN (no_isis_priority_l2, 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 @@ ALIAS (no_isis_priority_l2, "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 @@ DEFUN (no_isis_metric, "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 @@ ALIAS (no_isis_metric, NO_STR "IS-IS commands\n" "Set default metric for circuit\n" - "Default metric value\n" - ) -/* end of metrics */ + "Default metric value\n") - -DEFUN (isis_hello_interval, +/* end of metrics */ + 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 */ - - circuit->hello_interval[0] = (u_int16_t)interval; - circuit->hello_interval[1] = (u_int16_t)interval; - + 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; + return CMD_SUCCESS; } @@ -1164,23 +1265,23 @@ DEFUN (no_isis_hello_interval, "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 @@ ALIAS (no_isis_hello_interval, "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 @@ DEFUN (isis_hello_interval_l1, "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 @@ DEFUN (no_isis_hello_interval_l1, 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 @@ ALIAS (no_isis_hello_interval_l1, "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 @@ DEFUN (isis_hello_interval_l2, "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 @@ DEFUN (no_isis_hello_interval_l2, 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 @@ ALIAS (no_isis_hello_interval_l2, "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 @@ DEFUN (no_isis_hello_multiplier, "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 @@ ALIAS (no_isis_hello_multiplier, 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 @@ DEFUN (isis_hello_multiplier_l1, "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 @@ DEFUN (no_isis_hello_multiplier_l1, 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 @@ ALIAS (no_isis_hello_multiplier_l1, "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 @@ DEFUN (isis_hello_multiplier_l2, "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 @@ DEFUN (no_isis_hello_multiplier_l2, 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 @@ ALIAS (no_isis_hello_multiplier_l2, "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 @@ DEFUN (isis_hello, { 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 @@ DEFUN (ip_address, 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 @@ DEFUN (ip_address, 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 @@ DEFUN (ip_address, #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 (ret <= 0) + { + zlog_warn ("ip_address_cmd(): malformed address"); + vty_out (vty, "%% Malformed address %s", VTY_NEWLINE); + return CMD_WARNING; } - if (found) { - prefix_ipv4_free (ipv4); - return CMD_SUCCESS; + + 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 @@ DEFUN (no_ip_address, 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 @@ DEFUN (no_isis_hello, 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 @@ DEFUN (csnp_interval, 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 @@ DEFUN (no_csnp_interval, "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 @@ ALIAS (no_csnp_interval, "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 @@ DEFUN (csnp_interval_l1, 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 @@ DEFUN (no_csnp_interval_l1, 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 @@ ALIAS (no_csnp_interval_l1, "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 @@ DEFUN (csnp_interval_l2, 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 @@ DEFUN (no_csnp_interval_l2, 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 @@ ALIAS (no_csnp_interval_l2, "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 @@ DEFUN (ipv6_router_isis, 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 @@ DEFUN (no_ipv6_router_isis, 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 @@ DEFUN (no_ipv6_router_isis, 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 @@ DEFUN (ipv6_address, 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; - } - - + + 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 (ret <= 0) + { + vty_out (vty, "%% Malformed address %s", VTY_NEWLINE); + return CMD_WARNING; } - if (found) { - prefix_ipv6_free (ipv6); - return CMD_SUCCESS; + + 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 (ipv6_address, 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 @@ DEFUN (no_ipv6_address, 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 @@ isis_if_delete_hook (struct interface *ifp) 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 @@ isis_circuit_init () install_element (INTERFACE_NODE, &no_ipv6_address_cmd); #endif #endif - } diff --git a/isisd/isis_circuit.h b/isisd/isis_circuit.h index 7163c5b9..484c0575 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 951e6371..7a0768a8 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 @@ struct isis_passwd { * 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 @@ struct hostname { /* * 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 c732bfc4..1b75ba6b 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 b2057903..8f44db15 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 @@ static char *csm_statestr[] = #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 @@ static char *csm_eventstr[] = #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; - 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 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"); + + 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: - zlog_warn ("circuit already connected"); + 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: - 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); + 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 IF_DOWN_FROM_Z: - isis_circuit_if_del (circuit); - circuit->state = C_STATE_CONF; - isis_event_circuit_state_change (circuit, 0); + 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; - - 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 23cc2150..d6b13ac6 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 a2fddcce..b44d2123 100644 --- a/isisd/isis_dr.c +++ b/isisd/isis_dr.c @@ -51,37 +51,37 @@ extern struct isis *isis; 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 @@ int 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 @@ isis_check_dr_change (struct isis_adjacency *adj, int level) { 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 @@ isis_dr_elect (struct isis_circuit *circuit, int level) 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); - - if (adj->prio[level-1] > biggest_prio) { - biggest_prio = adj->prio[level-1]; - adj_dr = adj; - } else if (adj->prio[level-1] == biggest_prio) { + 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 (cmp_res == 0) + zlog_warn + ("isis_dr_elect(): multiple adjacencies with same SNPA"); + } + else + { + adj_dr = adj; + } + } + } + + if (!adj_dr) + { /* - * Comparison of MACs breaks a tie + * Could not find the DR - means we are alone and thus the DR */ - if (adj_dr) { - cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN); - if (cmp_res < 0) { - adj_dr = adj; + if (!circuit->u.bc.is_dr[level - 1]) + { + list_delete (list); + list = NULL; + return isis_dr_commence (circuit, level); } - 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); + 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 - */ - list_delete (list); - return isis_dr_commence (circuit, level); + 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 { + 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); + /* 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 - */ + /* 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); - } + for (node = listhead (list); node; nextnode (node)) + { + adj = getdata (node); + isis_check_dr_change (adj, level); + } - /* - * We are not DR - if we were -> resign - */ + /* + * 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); + 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); - - 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)); - } - + 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); + + 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); + 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); + + 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)); + } - 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); - - 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); + 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)); } - 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 73d9cd38..b0386d4d 100644 --- a/isisd/isis_dr.h +++ b/isisd/isis_dr.h @@ -31,7 +31,8 @@ int isis_dr_resign (struct isis_circuit *circuit, int level); 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 @@ enum isis_dis_state { }; #endif /* _ZEBRA_ISIS_DR_H */ - diff --git a/isisd/isis_dynhn.c b/isisd/isis_dynhn.c index 6b1d27b9..41c36371 100644 --- a/isisd/isis_dynhn.c +++ b/isisd/isis_dynhn.c @@ -50,48 +50,52 @@ void 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 @@ isis_dynhn_insert (u_char *id, struct hostname *hostname, int level) * 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 2a7f3ec9..37a7b03c 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 @@ struct isis_dynhn { }; 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 be136e26..a99869b9 100644 --- a/isisd/isis_events.c +++ b/isisd/isis_events.c @@ -64,19 +64,19 @@ extern struct isis *isis; 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 @@ isis_event_circuit_state_change (struct isis_circuit *circuit, int up) 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 @@ isis_event_system_type_change (struct isis_area *area, int newtype) return; } - - -void +void isis_event_area_addr_change (struct isis_area *area) { @@ -146,40 +148,49 @@ circuit_commence_level (struct isis_circuit *circuit, int level) { 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 (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 (); + 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[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 (); + 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 @@ void 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 @@ isis_event_circuit_type_change (struct isis_circuit *circuit, int newtype) * * ***********************************************************************/ -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 @@ int 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 75dd92e8..a6ec2e8c 100644 --- a/isisd/isis_events.h +++ b/isisd/isis_events.h @@ -31,14 +31,15 @@ void isis_event_area_addr_change (struct isis_area *area); /* * 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 @@ int isis_event_dis_status_change (struct thread *thread); #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 716bee05..0ef048e2 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 66b94848..f2421f2f 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 @@ int flags_any_set (u_int32_t *flags); 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 a29ba803..214b438c 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 @@ lsp_clear_data (struct isis_lsp *lsp) { 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 @@ lsp_destroy (struct isis_lsp *lsp) { 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 @@ lsp_db_destroy (dict_t *lspdb) * 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); - } - lsp_destroy (lsp); - dnode_destroy (node); - } + 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); + } } /* * 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)); - } - return LSP_EQUAL; - } + (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; + } - 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; - } - 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 (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; + } + 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 @@ lsp_seqnum_update (struct isis_lsp *lsp0) { 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 @@ isis_lsp_authinfo_check (struct stream *stream, struct isis_area *area, 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 @@ lsp_update_data (struct isis_lsp *lsp, struct stream *stream, 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 @@ lsp_update_data (struct isis_lsp *lsp, struct stream *stream, #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); - - 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)); - } + 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)); + } } 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 @@ lsp_new (u_char *lsp_id, u_int16_t rem_lifetime, u_int32_t seq_num, /* #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 @@ lsp_insert (struct isis_lsp *lsp, dict_t *lspdb) /* * 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 @@ lsp_build_list (u_char *start_id, u_char *stop_id, * 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 @@ void 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 @@ lspid_print (u_char *lsp_id, u_char *trg, char dynhost, char frag) 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); - } + 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 (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)); + 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) { - - char *pos = lsp_bits_string; +/* Convert the lsp attribute bits to attribute string */ +char * +lsp_bits2string (u_char * lsp_bits) +{ + 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 @@ lsp_print_detail (dnode_t *node, struct vty *vty, char dynhost) 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.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.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 @@ lsp_print_detail (dnode_t *node, struct vty *vty, char dynhost) 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 @@ lsp_print_detail (dnode_t *node, struct vty *vty, char dynhost) * 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++; - } - } 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++; + "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++; + } } - } return lsp_count; } @@ -1009,31 +1025,30 @@ lsp_print_all (struct vty *vty, dict_t *lspdb, char detail, char dynhost) * 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 @@ lsp_build_nonpseudo (struct isis_lsp *lsp, struct isis_area *area) 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 @@ lsp_build_nonpseudo (struct isis_lsp *lsp, struct isis_area *area) 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))); - } - tlv_build_func (*to, lsp->pdu); - } - lsp->lsp_header->pdu_len = htons (stream_get_putp (lsp->pdu)); + 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))); + } + 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 @@ lsp_build_nonpseudo (struct isis_lsp *lsp, struct isis_area *area) /* * 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"); + + 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 */ + 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); + } - 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 @@ build_lsp_data (struct isis_lsp *lsp, struct isis_area *area) 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 @@ build_lsp_data (struct isis_lsp *lsp, struct isis_area *area) * 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 @@ lsp_generate_non_pseudo (struct isis_area *area, int level) { 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 @@ lsp_generate_non_pseudo (struct isis_area *area, int level) { 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 @@ lsp_non_pseudo_regenerate (struct isis_area *area, int level) 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 @@ lsp_non_pseudo_regenerate (struct isis_area *area, int level) 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 @@ lsp_refresh_l1 (struct thread *thread) 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 @@ lsp_refresh_l2 (struct thread *thread) 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 @@ lsp_l2_regenerate (struct thread *thread) 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 @@ lsp_regenerate_schedule (struct isis_area *area) * 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 @@ lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit, 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 @@ lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit, /* * 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 @@ lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit, 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 @@ lsp_pseudo_regenerate (struct isis_circuit *circuit, int level) 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 @@ lsp_l1_refresh_pseudo (struct thread *thread) 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 @@ lsp_l1_pseudo_generate (struct isis_circuit *circuit) 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 @@ lsp_l2_refresh_pseudo (struct thread *thread) 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)); - - return lsp_regenerate_schedule (circuit->area); -} + 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 @@ lsp_tick (struct thread *thread) 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) { - - 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; - } - - /* - * 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); + 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)); + + 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); + } } - } 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 @@ lsp_purge_dr (u_char *id, struct isis_circuit *circuit, int level) * -> 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 @@ lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr, 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 @@ lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr, /* * 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 @@ lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr, 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 @@ generate_topology_lsps (struct isis_area *area) 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); + + 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]); - 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)); - - ISIS_FLAGS_SET_ALL(lsp->SRMflags); - lsp_insert (lsp,area->lspdb[0]); - - } + } } void @@ -2330,20 +2428,22 @@ remove_topology_lsps (struct isis_area *area) 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 @@ build_topology_lsp_data (struct isis_lsp *lsp, struct isis_area *area, 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 */ } - } - /* 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)); + /* 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); + /* 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 71a75089..c6eb7c27 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 isis_lsp 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_regenerate_schedule (struct isis_area *area); 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 @@ void lsp_purge_non_exist (struct isis_link_state_hdr *lsp_hdr, 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 a2a7e51a..d9bdd476 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 @@ struct zebra_privs_t isisd_privs = }; /* 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 @@ int _argc; char **_argv; char **_envp; - /* Help information display. */ static void usage (int status) @@ -116,7 +112,7 @@ usage (int status) 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 @@ terminate (int i) * Signal handlers */ -void +void sighup (void) { zlog_info ("SIGHUP received"); @@ -168,7 +164,7 @@ sigint (void) { zlog_info ("SIGINT received"); terminate (0); - + return; } @@ -187,29 +183,29 @@ sigusr1 (void) } struct quagga_signal_t isisd_signals[] = -{ - { - .signal = SIGHUP, - .handler = &sighup, - }, +{ + { + .signal = SIGHUP, + .handler = &sighup, + }, { - .signal = SIGUSR1, - .handler = &sigusr1, - }, + .signal = SIGUSR1, + .handler = &sigusr1, + }, { - .signal = SIGINT, - .handler = &sigint, - }, + .signal = SIGINT, + .handler = &sigint, + }, { - .signal = SIGTERM, - .handler = &sigterm, - }, + .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 @@ main (int argc, char **argv, char **envp) 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 @@ main (int argc, char **argv, char **envp) 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); + 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); 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 '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 @@ main (int argc, char **argv, char **envp) 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 @@ main (int argc, char **argv, char **envp) /* 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 @@ main (int argc, char **argv, char **envp) /* Not reached. */ exit (0); } - - - - - - - - - - diff --git a/isisd/isis_misc.c b/isisd/isis_misc.c index 709dbe4f..7fe5286f 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 @@ char * isonet_print (u_char *from, int len) { * 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 @@ dotformat2buff (u_char *buff, u_char *dotted) 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 @@ sysid2buff (u_char *buff, u_char *dotted) */ 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 @@ string2circuit_t (u_char *str) 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 "??"; - } - - return NULL; /* not reached */ + 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 */ } 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 "??"; - } - - return NULL; /* not reached */ + 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 */ } /* * 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 @@ snpa_print (u_char *from) } 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 @@ rawlspid_print (u_char *from) } 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 @@ time2string (u_int32_t time) { * 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 @@ isis_jitter (unsigned long timer, unsigned long jitter) * 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 @@ isis_jitter (unsigned long timer, unsigned long jitter) } 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 @@ newprefix2inaddr (u_char *prefix_start, u_char prefix_masklen) * 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 ca0c0ae3..75c8d8b4 100644 --- a/isisd/isis_misc.h +++ b/isisd/isis_misc.h @@ -28,7 +28,8 @@ int dotformat2buff (u_char *, u_char *); 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 @@ int sysid2buff (u_char *, u_char *); */ 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 @@ char nlpidstring[30]; #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 4f9af61e..080863bd 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 @@ extern struct zebra_privs_t isisd_privs; */ #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 @@ u_char *readbuff = NULL; * 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 @@ isis_multicast_join (int fd, int registerto, int if_num) { 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); - - } else { - mreq.mr_type = PACKET_MR_ALLMULTI; - } + 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; + } #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); + } + else + { + retval = + isis_multicast_join (circuit->fd, 0, 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); - } return retval; } @@ -201,101 +211,110 @@ open_bpf_dev (struct isis_circuit *circuit) 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 @@ isis_sock_init (struct isis_circuit *circuit) { 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 @@ isis_sock_init (struct isis_circuit *circuit) 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 @@ isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char *ssnpa) memset (&s_addr, 0, sizeof (struct sockaddr_ll)); - 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; - } + 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; + } /* * 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 @@ isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char *ssnpa) /* 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); - - 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->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; + } circuit->rcv_stream->putp = bytesread; circuit->rcv_stream->endp = bytesread; @@ -437,32 +459,31 @@ isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char *ssnpa) /* 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 @@ isis_send_pdu_bcast (struct isis_circuit *circuit, int level) 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 @@ isis_send_pdu_p2p (struct isis_circuit *circuit, int level) /* 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 @@ isis_send_pdu_bcast (struct isis_circuit *circuit, int level) /* * 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 @@ isis_send_pdu_bcast (struct isis_circuit *circuit, int level) /* * 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 7633f9e0..e1e10dfd 100644 --- a/isisd/isis_network.h +++ b/isisd/isis_network.h @@ -29,8 +29,8 @@ extern u_char ALL_L2_ISYSTEMS[]; 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 f93025db..cae34610 100644 --- a/isisd/isis_pdu.c +++ b/isisd/isis_pdu.c @@ -58,15 +58,14 @@ extern struct thread_master *master; 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 @@ static u_char maskbit[] = /* * 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,34 +103,37 @@ area_match (struct list *left, struct list *right) * 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 @@ -138,20 +142,23 @@ ip_same_subnet (struct prefix_ipv4 *ip1, struct in_addr *ip2) * 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 @@ ip_match (struct list *left, struct list *right) 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); - } + 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 (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); - } + 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 (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 @@ process_p2p_hello (struct isis_circuit *circuit) 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 @@ process_p2p_hello (struct isis_circuit *circuit) /* * 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 @@ process_p2p_hello (struct isis_circuit *circuit) 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); - - if (retval > ISIS_WARNING) { - free_tlvs (&tlvs); - return retval; - }; + ntohs (hdr->pdu_len) - ISIS_P2PHELLO_HDRLEN + - ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs); + + 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"); - - } 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; - } + 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; + } + } } - } /* 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 @@ process_p2p_hello (struct isis_circuit *circuit) 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 @@ process_p2p_hello (struct isis_circuit *circuit) 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 @@ process_lan_hello (int level, struct isis_circuit *circuit, u_char *ssnpa) 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 ((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 (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 (!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; } - 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 @@ process_lan_hello (int level, struct isis_circuit *circuit, u_char *ssnpa) 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 @@ process_lan_hello (int level, struct isis_circuit *circuit, u_char *ssnpa) 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); - - if (retval > ISIS_WARNING) { - zlog_warn ("parse_tlvs() failed"); - goto out; - } + STREAM_PNT (circuit->rcv_stream), + hdr.pdu_len - ISIS_LANHELLO_HDRLEN - + ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs); - 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 (retval > ISIS_WARNING) + { + zlog_warn ("parse_tlvs() failed"); + 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); - } - 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); + 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; - } #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_lan_hello (int level, struct isis_circuit *circuit, u_char *ssnpa) * 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 @@ process_lsp (int level, struct isis_circuit *circuit, u_char *ssnpa) 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); - - 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); - } + 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); + } 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)); - - return ISIS_WARNING; - } + 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; + } /* 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); - - return ISIS_WARNING; - } + 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; + } /* 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)); - - return ISIS_WARNING; - } + 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; + } /* 7.3.15.1 a) 4 - need to make sure IDLength matches */ @@ -903,221 +1009,254 @@ process_lsp (int level, struct isis_circuit *circuit, u_char *ssnpa) /* 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 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.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.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; - } - /* 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)); - + 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)); + } } - } 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) { + 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) + { #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); - - /* 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); + } + /* + * 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) */ + } + /* 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 @@ process_lsp (int level, struct isis_circuit *circuit, u_char *ssnpa) */ 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 @@ process_snp (int snp_type, int level, struct isis_circuit *circuit, 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); + 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; - } + 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]) { + if (!accept_level (level, circuit->circuit_is_type)) + { - 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 type %s does not match level %d", circuit->area->area_tag, - level, + level, typechar, - snpa_print(ssnpa), - circuit->interface->name); + 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 @@ process_snp (int snp_type, int level, struct isis_circuit *circuit, /* 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 (!adj) - return ISIS_OK; /* Silently discard */ - } else { - if (!circuit->u.p2p.neighbor) - return ISIS_OK; /* Silently discard */ - } + 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 */ + } + 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 @@ process_snp (int snp_type, int level, struct isis_circuit *circuit, 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]); - - /* 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; - } - } + 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; + } + } + } + } + /* 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 @@ process_is_hello (struct isis_circuit *circuit) 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; - - 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; + if (!adj) + { + /* 8.2.2 */ + 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 */ - } + 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 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 @@ isis_receive (struct thread *thread) 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 @@ isis_receive (struct thread *thread) /* * 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 @@ isis_receive (struct thread *thread) int isis_receive (struct thread *thread) { - struct isis_circuit *circuit; u_char ssnpa[ETH_ALEN]; int retval; @@ -1629,10 +1815,10 @@ isis_receive (struct thread *thread) 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 @@ isis_receive (struct thread *thread) /* * 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 @@ fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type) 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 @@ fill_fixed_hdr_andstream (struct isis_fixed_hdr *hdr, u_char pdu_type, return; } - int send_hello (struct isis_circuit *circuit, int level) { @@ -1728,55 +1913,65 @@ send_hello (struct isis_circuit *circuit, int level) 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.pdu_len = 0; /* Update the PDU Length later */ - len_pointer = stream_get_putp (circuit->snd_stream) + 3 + ISIS_SYS_ID_LEN; + 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; /* 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); - } - stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN); - } + 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); + } + stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN); + } /* * Then the variable length part @@ -1793,19 +1988,20 @@ send_hello (struct isis_circuit *circuit, int level) 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 @@ send_hello (struct isis_circuit *circuit, int level) 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 @@ send_hello (struct isis_circuit *circuit, int level) 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 @@ send_hello (struct isis_circuit *circuit, int level) 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 @@ send_lan_l1_hello (struct thread *thread) 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 @@ send_lan_l2_hello (struct thread *thread) 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 @@ send_p2p_hello (struct thread *thread) 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 @@ build_csnp (int level, u_char *start, u_char *stop, struct list *lsps, 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 @@ build_csnp (int level, u_char *start, u_char *stop, struct list *lsps, 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 @@ send_csnp (struct isis_circuit *circuit, int level) 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->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); - - 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 (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); + + 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)); + } + } - list_delete (list); + list_delete (list); - if (retval == ISIS_OK) - retval = circuit->tx (circuit, level); - } + if (retval == ISIS_OK) + retval = circuit->tx (circuit, level); + } return retval; } @@ -2036,12 +2241,13 @@ send_l1_csnp (struct thread *thread) 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 @@ send_l2_csnp (struct thread *thread) 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 @@ build_psnp (int level, struct isis_circuit *circuit, struct list *lsps) 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 @@ build_psnp (int level, struct isis_circuit *circuit, struct list *lsps) 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 (!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 (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); + 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 @@ send_psnp (int level, struct isis_circuit *circuit) 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 (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)); - - 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 (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 (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); + + 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_l1_psnp (struct thread *thread) 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 @@ send_l1_psnp (struct thread *thread) int send_l2_psnp (struct thread *thread) { - struct isis_circuit *circuit; int retval = ISIS_OK; @@ -2224,26 +2439,24 @@ send_l2_psnp (struct thread *thread) 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 @@ send_lsp (struct thread *thread) circuit = THREAD_ARG (thread); assert (circuit); - 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); + if (circuit->state == C_STATE_UP) + { + node = listhead (circuit->lsp_queue); + assert (node); - 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 (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); - if (flags_any_set (lsp->SRMflags) == 0) { /* - * 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 + { + /* 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 { - 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); - } #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 @@ ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit, 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 @@ ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit, * 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; + } + else + { + isis_delete_adj (adj, circuit->adjdb); + zlog_warn ("areaMismatch"); + return ISIS_WARNING; } - goto mismatch; - } 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 99403680..29c76211 100644 --- a/isisd/isis_pdu.h +++ b/isisd/isis_pdu.h @@ -54,7 +54,7 @@ struct esis_fixed_hdr 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 esis_fixed_hdr * +-------+-------+-------+-------+-------+-------+-------+-------+ */ -struct isis_fixed_hdr +struct isis_fixed_hdr { u_char idrp; u_char length; @@ -117,14 +117,15 @@ struct isis_fixed_hdr * | 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 @@ struct isis_lan_hello_hdr { * | 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 @@ struct isis_p2p_hello_hdr { * | 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 @@ struct isis_link_state_hdr { * + 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 @@ struct isis_complete_seqnum_hdr { * + 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 @@ int isis_receive (struct thread *thread); /* * 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 b889d3b8..90808681 100644 --- a/isisd/isis_route.c +++ b/isisd/isis_route.c @@ -55,27 +55,28 @@ extern struct thread_master *master; 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 @@ isis_nexthop_create (struct in_addr *ip, unsigned int ifindex) 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 @@ void 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 @@ void 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 @@ isis_nexthop6_new (struct in6_addr *ip6, unsigned int ifindex) 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 @@ void 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 @@ void 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 @@ adjinfo2nexthop (struct list *nexthops, struct isis_adjacency *adj) 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 @@ adjinfo2nexthop6 (struct list *nexthops6, struct isis_adjacency *adj) 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; - } - - 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; + + 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; + } } - } #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; - } - - 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; + 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; + } } - } #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 @@ isis_nexthops6_merge (struct list *new, struct list *old) 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 { + 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 rejected: %s", area->area_tag, buff); + 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 @@ isis_route_delete (struct prefix *prefix, struct route_table *table) 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 (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 (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); + } isis_route_info_delete (rinfo); rode->info = NULL; - + return; } @@ -581,27 +613,29 @@ isis_route_validate (struct thread *thread) 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 7137948e..59b6c226 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 9a8df610..56e44b88 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 1e414c6c..bd79659c 100644 --- a/isisd/isis_spf.c +++ b/isisd/isis_spf.c @@ -60,73 +60,81 @@ int isis_run_spf_l2 (struct thread *thread); /* 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) - 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) + { + 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 @@ remove_excess_adjs (struct list *adjs) 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 @@ isis_spftree_new () 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 @@ isis_spftree_del (struct isis_spftree *spftree) 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 @@ isis_vertex_new (void *id, enum vertextype vtype) 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 @@ isis_vertex_new (void *id, enum vertextype vtype) */ 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 @@ isis_spf_add_self (struct isis_spftree *spftree, struct isis_area *area, 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 @@ isis_spf_add_self (struct isis_spftree *spftree, struct isis_area *area, #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; + + 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; } - /* e) do nothing */ - return vertex; - } - add2tent: +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 @@ process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id, 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 @@ process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id, * 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 @@ isis_spf_process_lsp (struct isis_spftree *spftree, struct isis_lsp *lsp, #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; - } - - 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); - } +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); + } + } #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 @@ isis_spf_preload_tent (struct isis_spftree *spftree, #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; + + 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; + 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); - } - } + /* + * 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); - } - } + 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); + 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 @@ isis_spf_preload_tent (struct isis_spftree *spftree, */ 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 @@ isis_run_spf (struct isis_area *area, int level, int family) 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_run_spf (struct isis_area *area, int level, int family) 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); + 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)); + } } - } 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 @@ isis_run_spf_l1 (struct thread *thread) 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; + } + + if (isis->debugs & DEBUG_SPF_EVENTS) + { + zlog_info ("ISIS-Spf (%s) L1 SPF needed, periodic SPF", area->area_tag); } - return ISIS_WARNING; - } - 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 @@ isis_run_spf_l2 (struct thread *thread) 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; + } + + if (isis->debugs & DEBUG_SPF_EVENTS) + { + zlog_info ("ISIS-Spf (%s) L2 SPF needed, periodic SPF", area->area_tag); } - return ISIS_WARNING; - } - - 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 @@ isis_run_spf_l2 (struct thread *thread) return retval; } -int +int isis_spf_schedule (struct isis_area *area, int level) { int retval = ISIS_OK; @@ -1029,43 +1117,45 @@ isis_spf_schedule (struct isis_area *area, int level) 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); - - spftree->pending = 1; - return retval; - } + 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; + } /* FIXME: This stuff is just mess. All spf thread add/cancel logic should be reviewed. */ - 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); - - spftree->pending = 1; - } else { - spftree->pending = 0; - retval = isis_run_spf (area, level, AF_INET); - } + 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); + + 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 @@ isis_spf_schedule6 (struct isis_area *area, int level) 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); - - spftree->pending = 1; - return retval; - } + 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; + } - 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); - } + 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); + } return retval; } @@ -1121,43 +1213,47 @@ isis_print_paths (struct vty *vty, struct list *paths) 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 @@ DEFUN (show_isis_topology, 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); - - 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); - } + 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); + } #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 @@ DEFUN (show_isis_topology_l1, { 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); - - 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); - } + 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); + } #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 @@ DEFUN (show_isis_topology_l2, { 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); - - 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); - } + 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); + } #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 59e4b6b5..432f846e 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 @@ struct isis_vertex { 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 */ - struct list *Adj_N; /* {Adj(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 */ + 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 @@ void isis_spf_cmds_init (void); 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 d7bbb914..a35b6878 100644 --- a/isisd/isis_tlv.c +++ b/isisd/isis_tlv.c @@ -48,58 +48,71 @@ extern struct isis *isis; 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 @@ free_tlvs (struct tlvs *tlvs) * 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; - - case IS_NEIGHBOURS: - *found |= TLVFLAG_IS_NEIGHS; + 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; #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; - - case TE_IS_NEIGHBOURS: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * | Neighbour ID | 7 - * +---------------------------------------------------------------+ - * | TE Metric | 3 - * +---------------------------------------------------------------+ - * | SubTLVs Length | 1 - * +---------------------------------------------------------------+ - * : : - */ - *found |= TLVFLAG_TE_IS_NEIGHS; + 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; #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 (!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 | - * +---------------------------------------------------------------+ - * : : - */ + 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; + + 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; - - 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: + *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 ("TLV padding %d", length); + zlog_info ("ISIS-TLV (%s): LAN Neigbours length %d", + areatag, length); #endif /* EXTREME_TLV_DEBUG */ - pnt += length; - break; - - case LSP_ENTRIES: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * | Remaining Lifetime | 2 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * | LSP ID | id+2 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * | LSP Sequence Number | 4 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * | Checksum | 2 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - */ + 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: #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; - - case CHECKSUM: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * | 16 bit fletcher CHECKSUM | - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * : : - */ - *found |= TLVFLAG_CHECKSUM; + pnt += length; + break; + + 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; - - case PROTOCOLS_SUPPORTED: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * | NLPID | - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * : : - */ - *found |= TLVFLAG_NLPID; + *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 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; - - case IPV4_ADDR: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * + IP version 4 address + 4 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * : : - */ - *found |= TLVFLAG_IPV4_ADDR; + if (*expected & TLVFLAG_CHECKSUM) + { + tlvs->checksum = (struct checksum *) pnt; + } + pnt += length; + break; + + 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; - - case AUTH_INFO: - *found |= TLVFLAG_AUTH_INFO; + if (*expected & TLVFLAG_NLPID) + { + tlvs->nlpids = (struct nlpids *) (pnt - 1); + } + pnt += length; + break; + + 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; - - case DYNAMIC_HOSTNAME: - *found |= TLVFLAG_DYN_HOSTNAME; + 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; #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; - - case TE_ROUTER_ID: - /* +---------------------------------------------------------------+ - * + Router ID + 4 - * +---------------------------------------------------------------+ - */ - *found |= TLVFLAG_TE_ROUTER_ID; + 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; #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; - - 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; + 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; #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; - - 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; + 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; #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; - - case TE_IPV4_REACHABILITY: - /* +-------+-------+-------+-------+-------+-------+-------+-------+ - * | TE Metric | 4 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * | U/D | sTLV? | Prefix Mask Len | 1 - * +-------+-------+-------+-------+-------+-------+-------+-------+ - * | Prefix | 0-4 - * +---------------------------------------------------------------+ - * | sub tlvs | - * +---------------------------------------------------------------+ - * : : - */ - *found |= TLVFLAG_TE_IPV4_REACHABILITY; + 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; #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; - - 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; + 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; #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 @@ parse_tlvs (char *areatag, u_char *stream, int size, u_int32_t *expected, 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; - } - - 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); - - retval = ISIS_WARNING; - pnt += length; - break; + 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; + + default: + zlog_warn ("ISIS-TLV (%s): unsupported TLV type %d, length %d", + areatag, type, length); + + 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 @@ add_tlv (u_char tag, u_char len, u_char *value, struct stream *stream) 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 @@ tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream) 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 @@ int 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 @@ tlv_add_ip_addrs (struct list *ip_addrs, struct stream *stream) 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 @@ tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream) 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 @@ tlv_add_ipv6_reachs (struct list *ipv6_reachs, struct stream *stream) 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 @@ int 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 @@ tlv_add_padding (struct stream *stream) 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 e030385e..e4fd9e07 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 @@ struct ipv6_reachability { /* * 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 @@ struct tlvs { #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 136d2b52..ad5a0507 100644 --- a/isisd/isis_zebra.c +++ b/isisd/isis_zebra.c @@ -44,20 +44,20 @@ struct zclient *zclient = NULL; 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 @@ isis_zebra_if_del (int command, struct zclient *zclient, zebra_size_t length) 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 @@ zebra_interface_if_set_value (struct stream *s, struct interface *ifp) } 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 @@ isis_zebra_route_add_ipv4 (struct prefix *prefix, 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 (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); + 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); - - 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); - } - } + + 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); + 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)); - } + 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 @@ isis_zebra_route_add_ipv6 (struct prefix *prefix, 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 @@ isis_zebra_route_add_ipv6 (struct prefix *prefix, #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 @@ isis_zebra_route_del_ipv6 (struct prefix *prefix, 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 @@ isis_zebra_route_del_ipv6 (struct prefix *prefix, 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); - } - + + 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); + 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 @@ isis_zebra_route_update (struct prefix *prefix, 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 @@ isis_zebra_read_ipv4 (int command, struct zclient *zclient, 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 @@ isis_distribute_list_update (int routetype) } 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 @@ isis_zebra_init () 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 fabf7200..0dce7995 100644 --- a/isisd/isis_zebra.h +++ b/isisd/isis_zebra.h @@ -26,8 +26,8 @@ extern struct zclient *zclient; 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 8d0b3a21..3c499dc3 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 @@ isis_new (unsigned long process_id) /* * 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 @@ isis_area_create () */ 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 @@ isis_area_create () #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 @@ isis_area_lookup (char *area_tag) { 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; + } + + 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); } - 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 @@ area_net_title (struct vty *vty , char *net_title) 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 @@ area_net_title (struct vty *vty , char *net_title) 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 @@ int 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 @@ show_clns_neigh (struct vty *vty, char detail) 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); - - 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); - } + 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); + + 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 @@ DEFUN (show_clns_neighbors, "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 @@ DEFUN (show_clns_neighbors_detail, "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 @@ ALIAS (show_clns_neighbors_detail, "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 @@ DEFUN (show_debugging, 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 @@ config_write_debug (struct vty *vty) 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 @@ DEFUN (debug_isis_adj, "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 @@ DEFUN (no_debug_isis_adj, "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 @@ DEFUN (no_debug_isis_csum, "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 @@ DEFUN (debug_isis_lupd, "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 @@ DEFUN (no_debug_isis_lupd, "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 @@ DEFUN (no_debug_isis_err, "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 @@ DEFUN (debug_isis_snp, "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 @@ DEFUN (no_debug_isis_snp, "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 @@ DEFUN (no_debug_isis_upd, "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 @@ DEFUN (no_debug_isis_spfevents, "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 @@ DEFUN (debug_isis_spfstats, "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 @@ DEFUN (no_debug_isis_spfstats, "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 @@ DEFUN (debug_isis_spftrigg, "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 @@ DEFUN (no_debug_isis_spftrigg, "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 @@ DEFUN (debug_isis_rtevents, "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 @@ DEFUN (no_debug_isis_rtevents, "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 @@ DEFUN (debug_isis_events, "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 @@ DEFUN (no_debug_isis_events, "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 @@ DEFUN (show_hostname, "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); - - vty_out (vty,"%s %u LSPs%s%s", - VTY_NEWLINE, - lsp_count, - VTY_NEWLINE, - 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_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 @@ DEFUN (show_database_detail, 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_DETAIL, - area->dynhostname); - - vty_out (vty,"%s %u LSPs%s%s", - VTY_NEWLINE, - lsp_count, - VTY_NEWLINE, - 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); + + vty_out (vty, "%s %u LSPs%s%s", + VTY_NEWLINE, lsp_count, VTY_NEWLINE, VTY_NEWLINE); + } + } } - } return CMD_SUCCESS; } @@ -988,13 +979,11 @@ DEFUN (show_database_detail, 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 (router_isis, 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 @@ DEFUN (net, 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 @@ DEFUN (no_net, "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 @@ DEFUN (area_passwd, 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 @@ DEFUN (no_area_passwd, "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 @@ DEFUN (no_domain_passwd, "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 @@ DEFUN (is_type, 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 @@ DEFUN (no_is_type, "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 @@ DEFUN (lsp_gen_interval, 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 @@ DEFUN (no_lsp_gen_interval, 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 @@ ALIAS (no_lsp_gen_interval, "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 @@ DEFUN (no_lsp_gen_interval_l1, "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 @@ ALIAS (no_lsp_gen_interval_l1, 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 @@ DEFUN (no_lsp_gen_interval_l2, "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 @@ ALIAS (no_lsp_gen_interval_l2, 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 @@ DEFUN (metric_style, 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 @@ DEFUN (no_metric_style, 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 @@ DEFUN (dynamic_hostname, 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 @@ DEFUN (no_dynamic_hostname, "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 @@ DEFUN (spf_interval, { 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 @@ DEFUN (no_spf_interval, 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 @@ ALIAS (no_spf_interval, "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 @@ DEFUN (spf_interval_l1, { 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 @@ DEFUN (no_spf_interval_l1, "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 @@ DEFUN (spf_interval_l2, { 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 @@ DEFUN (no_spf_interval_l2, "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 @@ ALIAS (no_spf_interval, "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 @@ DEFUN (topology_generate_grid, 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 @@ DEFUN (show_isis_topology, 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 @@ DEFUN (show_isis_topology, /* * '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 @@ DEFUN (topology_baseis , 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 @@ DEFUN (no_topology_baseis, "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 @@ DEFUN (lsp_lifetime, 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 @@ DEFUN (no_lsp_lifetime, 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 @@ ALIAS (no_lsp_lifetime, "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 @@ DEFUN (no_lsp_lifetime_l1, 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 @@ ALIAS (no_lsp_lifetime_l1, "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); + interval = atoi (argv[0]); - return CMD_WARNING; - } + 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; + } area->max_lsp_lifetime[1] = interval; area->lsp_refresh[1] = interval - 300; @@ -1803,16 +1775,15 @@ DEFUN (no_lsp_lifetime_l2, 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 @@ ALIAS (no_lsp_lifetime_l2, "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 (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 ++; - } + 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 (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 */ +#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 @@ isis_init () 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 @@ isis_init () 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 @@ isis_init () 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 3ca421ad..f1093cc2 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 @@ struct isis { 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 @@ struct isis_area /* 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 d0bb8a75..e65f6ef6 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 @@ iso_csum_verify (u_char *buffer, int len, uint16_t *csum) */ 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 @@ iso_csum_verify (u_char *buffer, int len, uint16_t *csum) */ #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 @@ iso_csum_create (u_char *buffer, int len, u_int16_t n) 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 @@ iso_csum_create (u_char *buffer, int len, u_int16_t n) /* * 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 @@ iso_csum_create (u_char *buffer, int len, u_int16_t n) 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 @@ iso_csum_create (u_char *buffer, int len, u_int16_t n) 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 cf600a86..ba0d1983 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 */ |