]> git.meshlink.io Git - meshlink/commitdiff
Switch to K&R style indentation.
authorGuus Sliepen <guus@tinc-vpn.org>
Mon, 9 Sep 2002 21:49:16 +0000 (21:49 +0000)
committerGuus Sliepen <guus@tinc-vpn.org>
Mon, 9 Sep 2002 21:49:16 +0000 (21:49 +0000)
lib/avl_tree.c
lib/avl_tree.h
lib/dropin.c
lib/dropin.h
lib/list.c
lib/list.h
lib/utils.c
lib/utils.h

index 8ec680bed6599445bf021d270bc4d11118807949..009c680b29f27ad16e922999410c40cc7a81647b 100644 (file)
@@ -29,7 +29,7 @@
     library for inclusion into tinc (http://tinc.nl.linux.org/) by
     Guus Sliepen <guus@sliepen.eu.org>.
 
-    $Id: avl_tree.c,v 1.1.2.9 2002/06/21 10:11:11 guus Exp $
+    $Id: avl_tree.c,v 1.1.2.10 2002/09/09 21:49:16 guus Exp $
 */
 
 #include <stdio.h>
 #ifndef AVL_DEPTH
 int lg(unsigned int u)
 {
-  int r = 1;
-  if (!u)
-    return 0;
-  if (u & 0xffff0000)
-  {
-    u >>= 16;
-    r += 16;
-  }
-  if (u & 0x0000ff00)
-  {
-    u >>= 8;
-    r += 8;
-  }
-  if (u & 0x000000f0)
-  {
-    u >>= 4;
-    r += 4;
-  }
-  if (u & 0x0000000c)
-  {
-    u >>= 2;
-    r += 2;
-  }
-  if (u & 0x00000002)
-    r++;
-  return r;
+       int r = 1;
+
+       if(!u)
+               return 0;
+
+       if(u & 0xffff0000) {
+               u >>= 16;
+               r += 16;
+       }
+
+       if(u & 0x0000ff00) {
+               u >>= 8;
+               r += 8;
+       }
+
+       if(u & 0x000000f0) {
+               u >>= 4;
+               r += 4;
+       }
+
+       if(u & 0x0000000c) {
+               u >>= 2;
+               r += 2;
+       }
+
+       if(u & 0x00000002)
+               r++;
+
+       return r;
 }
 #endif
 
 /* Internal helper functions */
 
-int avl_check_balance(avl_node_t *node)
+int avl_check_balance(avl_node_t * node)
 {
 #ifdef AVL_DEPTH
-  int d;
-  d = R_AVL_DEPTH(node) - L_AVL_DEPTH(node);
-  return d < -1 ? -1 : d > 1 ? 1 : 0;
+       int d;
+
+       d = R_AVL_DEPTH(node) - L_AVL_DEPTH(node);
+
+       return d < -1 ? -1 : d > 1 ? 1 : 0;
 #else
 /*      int d;
  *      d = lg(AVL_R_COUNT(node)) - lg(AVL_L_COUNT(node));
  *      d = d<-1?-1:d>1?1:0;
  */
-  int pl, r;
+       int pl, r;
+
+       pl = lg(AVL_L_COUNT(node));
+       r = AVL_R_COUNT(node);
+
+       if(r >> pl + 1)
+               return 1;
 
-  pl = lg(AVL_L_COUNT(node));
-  r = AVL_R_COUNT(node);
+       if(pl < 2 || r >> pl - 2)
+               return 0;
 
-  if (r >> pl + 1)
-    return 1;
-  if (pl < 2 || r >> pl - 2)
-    return 0;
-  return -1;
+       return -1;
 #endif
 }
 
-void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
+void avl_rebalance(avl_tree_t * tree, avl_node_t * node)
 {
-  avl_node_t *child;
-  avl_node_t *gchild;
-  avl_node_t *parent;
-  avl_node_t **superparent;
+       avl_node_t *child;
+       avl_node_t *gchild;
+       avl_node_t *parent;
+       avl_node_t **superparent;
 
-  parent = node;
+       parent = node;
 
-  while (node)
-  {
-    parent = node->parent;
+       while(node) {
+               parent = node->parent;
 
-    superparent = parent ? node == parent->left ? &parent->left : &parent->right : &tree->root;
+               superparent =
+                       parent ? node ==
+                       parent->left ? &parent->left : &parent->right : &tree->root;
 
-    switch (avl_check_balance(node))
-    {
-    case -1:
-      child = node->left;
+               switch (avl_check_balance(node)) {
+                       case -1:
+                               child = node->left;
 #ifdef AVL_DEPTH
-      if(L_AVL_DEPTH(child) >= R_AVL_DEPTH(child)) {
+                               if(L_AVL_DEPTH(child) >= R_AVL_DEPTH(child)) {
 #else
-      if (AVL_L_COUNT(child) >= AVL_R_COUNT(child))
-      {
+                               if(AVL_L_COUNT(child) >= AVL_R_COUNT(child)) {
 #endif
-        node->left = child->right;
-        if (node->left)
-          node->left->parent = node;
-        child->right = node;
-        node->parent = child;
-        *superparent = child;
-        child->parent = parent;
+                                       node->left = child->right;
+                                       if(node->left)
+                                               node->left->parent = node;
+
+                                       child->right = node;
+                                       node->parent = child;
+                                       *superparent = child;
+                                       child->parent = parent;
 #ifdef AVL_COUNT
-        node->count = AVL_CALC_COUNT(node);
-        child->count = AVL_CALC_COUNT(child);
+                                       node->count = AVL_CALC_COUNT(node);
+                                       child->count = AVL_CALC_COUNT(child);
 #endif
 #ifdef AVL_DEPTH
-        node->depth = AVL_CALC_DEPTH(node);
-        child->depth = AVL_CALC_DEPTH(child);
+                                       node->depth = AVL_CALC_DEPTH(node);
+                                       child->depth = AVL_CALC_DEPTH(child);
 #endif
-      } else
-      {
-        gchild = child->right;
-        node->left = gchild->right;
-        if (node->left)
-          node->left->parent = node;
-        child->right = gchild->left;
-        if (child->right)
-          child->right->parent = child;
-        gchild->right = node;
-        if (gchild->right)
-          gchild->right->parent = gchild;
-        gchild->left = child;
-        if (gchild->left)
-          gchild->left->parent = gchild;
-        *superparent = gchild;
-        gchild->parent = parent;
+                               } else {
+                                       gchild = child->right;
+                                       node->left = gchild->right;
+
+                                       if(node->left)
+                                               node->left->parent = node;
+                                       child->right = gchild->left;
+
+                                       if(child->right)
+                                               child->right->parent = child;
+                                       gchild->right = node;
+
+                                       if(gchild->right)
+                                               gchild->right->parent = gchild;
+                                       gchild->left = child;
+
+                                       if(gchild->left)
+                                               gchild->left->parent = gchild;
+                                       *superparent = gchild;
+
+                                       gchild->parent = parent;
 #ifdef AVL_COUNT
-        node->count = AVL_CALC_COUNT(node);
-        child->count = AVL_CALC_COUNT(child);
-        gchild->count = AVL_CALC_COUNT(gchild);
+                                       node->count = AVL_CALC_COUNT(node);
+                                       child->count = AVL_CALC_COUNT(child);
+                                       gchild->count = AVL_CALC_COUNT(gchild);
 #endif
 #ifdef AVL_DEPTH
-        node->depth = AVL_CALC_DEPTH(node);
-        child->depth = AVL_CALC_DEPTH(child);
-        gchild->depth = AVL_CALC_DEPTH(gchild);
+                                       node->depth = AVL_CALC_DEPTH(node);
+                                       child->depth = AVL_CALC_DEPTH(child);
+                                       gchild->depth = AVL_CALC_DEPTH(gchild);
 #endif
-      }
-      break;
-    case 1:
-      child = node->right;
+                               }
+                               break;
+
+                       case 1:
+                               child = node->right;
 #ifdef AVL_DEPTH
-      if(R_AVL_DEPTH(child) >= L_AVL_DEPTH(child)) {
+                               if(R_AVL_DEPTH(child) >= L_AVL_DEPTH(child)) {
 #else
-      if (AVL_R_COUNT(child) >= AVL_L_COUNT(child))
-      {
+                               if(AVL_R_COUNT(child) >= AVL_L_COUNT(child)) {
 #endif
-        node->right = child->left;
-        if (node->right)
-          node->right->parent = node;
-        child->left = node;
-        node->parent = child;
-        *superparent = child;
-        child->parent = parent;
+                                       node->right = child->left;
+                                       if(node->right)
+                                               node->right->parent = node;
+                                       child->left = node;
+                                       node->parent = child;
+                                       *superparent = child;
+                                       child->parent = parent;
 #ifdef AVL_COUNT
-        node->count = AVL_CALC_COUNT(node);
-        child->count = AVL_CALC_COUNT(child);
+                                       node->count = AVL_CALC_COUNT(node);
+                                       child->count = AVL_CALC_COUNT(child);
 #endif
 #ifdef AVL_DEPTH
-        node->depth = AVL_CALC_DEPTH(node);
-        child->depth = AVL_CALC_DEPTH(child);
+                                       node->depth = AVL_CALC_DEPTH(node);
+                                       child->depth = AVL_CALC_DEPTH(child);
 #endif
-      } else
-      {
-        gchild = child->left;
-        node->right = gchild->left;
-        if (node->right)
-          node->right->parent = node;
-        child->left = gchild->right;
-        if (child->left)
-          child->left->parent = child;
-        gchild->left = node;
-        if (gchild->left)
-          gchild->left->parent = gchild;
-        gchild->right = child;
-        if (gchild->right)
-          gchild->right->parent = gchild;
-        *superparent = gchild;
-        gchild->parent = parent;
+                               } else {
+                                       gchild = child->left;
+                                       node->right = gchild->left;
+
+                                       if(node->right)
+                                               node->right->parent = node;
+                                       child->left = gchild->right;
+
+                                       if(child->left)
+                                               child->left->parent = child;
+                                       gchild->left = node;
+
+                                       if(gchild->left)
+                                               gchild->left->parent = gchild;
+                                       gchild->right = child;
+
+                                       if(gchild->right)
+                                               gchild->right->parent = gchild;
+
+                                       *superparent = gchild;
+                                       gchild->parent = parent;
 #ifdef AVL_COUNT
-        node->count = AVL_CALC_COUNT(node);
-        child->count = AVL_CALC_COUNT(child);
-        gchild->count = AVL_CALC_COUNT(gchild);
+                                       node->count = AVL_CALC_COUNT(node);
+                                       child->count = AVL_CALC_COUNT(child);
+                                       gchild->count = AVL_CALC_COUNT(gchild);
 #endif
 #ifdef AVL_DEPTH
-        node->depth = AVL_CALC_DEPTH(node);
-        child->depth = AVL_CALC_DEPTH(child);
-        gchild->depth = AVL_CALC_DEPTH(gchild);
+                                       node->depth = AVL_CALC_DEPTH(node);
+                                       child->depth = AVL_CALC_DEPTH(child);
+                                       gchild->depth = AVL_CALC_DEPTH(gchild);
 #endif
-      }
-      break;
-    default:
+                               }
+                               break;
+
+                       default:
 #ifdef AVL_COUNT
-      node->count = AVL_CALC_COUNT(node);
+                               node->count = AVL_CALC_COUNT(node);
 #endif
 #ifdef AVL_DEPTH
-      node->depth = AVL_CALC_DEPTH(node);
+                               node->depth = AVL_CALC_DEPTH(node);
 #endif
-    }
-    node = parent;
-  }
+               }
+               node = parent;
+       }
 }
 
 /* (De)constructors */
 
 avl_tree_t *avl_alloc_tree(avl_compare_t compare, avl_action_t delete)
 {
-  avl_tree_t *tree;
-  
-  tree = xmalloc_and_zero(sizeof(avl_tree_t));
-  tree->compare = compare;
-  tree->delete = delete;
+       avl_tree_t *tree;
+
+       tree = xmalloc_and_zero(sizeof(avl_tree_t));
+       tree->compare = compare;
+       tree->delete = delete;
 
-  return tree;
+       return tree;
 }
 
-void avl_free_tree(avl_tree_t *tree)
+void avl_free_tree(avl_tree_t * tree)
 {
-  free(tree);
+       free(tree);
 }
 
 avl_node_t *avl_alloc_node(void)
 {
-  avl_node_t *node;
-  
-  node = xmalloc_and_zero(sizeof(avl_node_t));
-  
-  return node;
+       return (avl_node_t *)xmalloc_and_zero(sizeof(avl_node_t));
 }
 
-void avl_free_node(avl_tree_t *tree, avl_node_t *node)
+void avl_free_node(avl_tree_t * tree, avl_node_t * node)
 {
-  if(node->data && tree->delete)
-    tree->delete(node->data);
-  free(node);    
+       if(node->data && tree->delete)
+               tree->delete(node->data);
+
+       free(node);
 }
 
 /* Searching */
 
-void *avl_search(const avl_tree_t *tree, const void *data)
+void *avl_search(const avl_tree_t * tree, const void *data)
 {
-  avl_node_t *node;
-  
-  node = avl_search_node(tree, data);
+       avl_node_t *node;
+
+       node = avl_search_node(tree, data);
 
-  return node?node->data:NULL;
+       return node ? node->data : NULL;
 }
 
-void *avl_search_closest(const avl_tree_t *tree, const void *data, int *result)
+void *avl_search_closest(const avl_tree_t * tree, const void *data, int *result)
 {
-  avl_node_t *node;
-  
-  node = avl_search_closest_node(tree, data, result);
+       avl_node_t *node;
+
+       node = avl_search_closest_node(tree, data, result);
 
-  return node?node->data:NULL;
+       return node ? node->data : NULL;
 }
 
-void *avl_search_closest_smaller(const avl_tree_t *tree, const void *data)
+void *avl_search_closest_smaller(const avl_tree_t * tree, const void *data)
 {
-  avl_node_t *node;
-  
-  node = avl_search_closest_smaller_node(tree, data);
+       avl_node_t *node;
 
-  return node?node->data:NULL;
+       node = avl_search_closest_smaller_node(tree, data);
+
+       return node ? node->data : NULL;
 }
 
-void *avl_search_closest_greater(const avl_tree_t *tree, const void *data)
+void *avl_search_closest_greater(const avl_tree_t * tree, const void *data)
 {
-  avl_node_t *node;
-  
-  node = avl_search_closest_greater_node(tree, data);
+       avl_node_t *node;
+
+       node = avl_search_closest_greater_node(tree, data);
 
-  return node?node->data:NULL;
+       return node ? node->data : NULL;
 }
 
-avl_node_t *avl_search_node(const avl_tree_t *tree, const void *data)
+avl_node_t *avl_search_node(const avl_tree_t * tree, const void *data)
 {
-  avl_node_t *node;
-  int result;
-  node = avl_search_closest_node(tree, data, &result);
-  
-  return result?NULL:node;
+       avl_node_t *node;
+       int result;
+
+       node = avl_search_closest_node(tree, data, &result);
+
+       return result ? NULL : node;
 }
 
-avl_node_t *avl_search_closest_node(const avl_tree_t *tree, const void *data, int *result)
+avl_node_t *avl_search_closest_node(const avl_tree_t * tree, const void *data,
+                                                                       int *result)
 {
-  avl_node_t *node;
-  int c;
-
-  node = tree->root;
-
-  if (!node)
-  {
-    if(result)
-      *result = 0;
-    return NULL;
-  }
-
-  for (;;)
-  {
-    c = tree->compare(data, node->data);
-
-    if (c < 0)
-    {
-      if (node->left)
-        node = node->left;
-      else
-      {
-        if(result)
-          *result = -1;
-        break;
-      }
-    }
-    else if (c > 0)
-    {
-      if (node->right)
-        node = node->right;
-      else
-      {
-        if(result)
-          *result = 1;
-        break;
-      }
-    }
-    else
-    {
-      if(result)
-        *result = 0;
-      break;
-    }
-  }
-
-  return node;
+       avl_node_t *node;
+       int c;
+
+       node = tree->root;
+
+       if(!node) {
+               if(result)
+                       *result = 0;
+               return NULL;
+       }
+
+       for(;;) {
+               c = tree->compare(data, node->data);
+
+               if(c < 0) {
+                       if(node->left)
+                               node = node->left;
+                       else {
+                               if(result)
+                                       *result = -1;
+                               break;
+                       }
+               } else if(c > 0) {
+                       if(node->right)
+                               node = node->right;
+                       else {
+                               if(result)
+                                       *result = 1;
+                               break;
+                       }
+               } else {
+                       if(result)
+                               *result = 0;
+                       break;
+               }
+       }
+
+       return node;
 }
 
-avl_node_t *avl_search_closest_smaller_node(const avl_tree_t *tree, const void *data)
+avl_node_t *avl_search_closest_smaller_node(const avl_tree_t * tree,
+                                                                                       const void *data)
 {
-  avl_node_t *node;
-  int result;
-  
-  node = avl_search_closest_node(tree, data, &result);
-  
-  if(result < 0)
-    node = node->prev;
-  
-  return node;
+       avl_node_t *node;
+       int result;
+
+       node = avl_search_closest_node(tree, data, &result);
+
+       if(result < 0)
+               node = node->prev;
+
+       return node;
 }
 
-avl_node_t *avl_search_closest_greater_node(const avl_tree_t *tree, const void *data)
+avl_node_t *avl_search_closest_greater_node(const avl_tree_t * tree,
+                                                                                       const void *data)
 {
-  avl_node_t *node;
-  int result;
-  
-  node = avl_search_closest_node(tree, data, &result);
-  
-  if(result > 0)
-    node = node->next;
-  
-  return node;
+       avl_node_t *node;
+       int result;
+
+       node = avl_search_closest_node(tree, data, &result);
+
+       if(result > 0)
+               node = node->next;
+
+       return node;
 }
 
 /* Insertion and deletion */
 
-avl_node_t *avl_insert(avl_tree_t *tree, void *data)
+avl_node_t *avl_insert(avl_tree_t * tree, void *data)
 {
-  avl_node_t *closest, *new;
-  int result;
-
-  if (!tree->root)
-  {
-    new = avl_alloc_node();
-    new->data = data;
-    avl_insert_top(tree, new);
-  }
-  else
-  {
-    closest = avl_search_closest_node(tree, data, &result);
-    switch(result)
-    {
-      case -1:
-        new = avl_alloc_node();
-        new->data = data;
-        avl_insert_before(tree, closest, new);
-        break;
-      case 1:
-        new = avl_alloc_node();
-        new->data = data;
-        avl_insert_after(tree, closest, new);
-        break;
-      default:
-        return NULL;
-    }
-  }
-  
+       avl_node_t *closest, *new;
+       int result;
+
+       if(!tree->root) {
+               new = avl_alloc_node();
+               new->data = data;
+               avl_insert_top(tree, new);
+       } else {
+               closest = avl_search_closest_node(tree, data, &result);
+
+               switch (result) {
+                       case -1:
+                               new = avl_alloc_node();
+                               new->data = data;
+                               avl_insert_before(tree, closest, new);
+                               break;
+
+                       case 1:
+                               new = avl_alloc_node();
+                               new->data = data;
+                               avl_insert_after(tree, closest, new);
+                               break;
+
+                       default:
+                               return NULL;
+               }
+       }
+
 #ifdef AVL_COUNT
-  new->count = 1;
+       new->count = 1;
 #endif
 #ifdef AVL_DEPTH
-  new->depth = 1;
+       new->depth = 1;
 #endif
 
-  return new;
+       return new;
 }
 
-avl_node_t *avl_insert_node(avl_tree_t *tree, avl_node_t *node)
+avl_node_t *avl_insert_node(avl_tree_t * tree, avl_node_t * node)
 {
-  avl_node_t *closest;
-  int result;
-
-  if (!tree->root)
-    avl_insert_top(tree, node);
-  else
-  {
-    closest = avl_search_closest_node(tree, node->data, &result);
-    switch(result)
-    {
-      case -1:
-        avl_insert_before(tree, closest, node);
-        break;
-      case 1:
-        avl_insert_after(tree, closest, node);
-        break;
-      case 0:
-        return NULL;
-    }
-  }
-  
+       avl_node_t *closest;
+       int result;
+
+       if(!tree->root)
+               avl_insert_top(tree, node);
+       else {
+               closest = avl_search_closest_node(tree, node->data, &result);
+
+               switch (result) {
+                       case -1:
+                               avl_insert_before(tree, closest, node);
+                               break;
+
+                       case 1:
+                               avl_insert_after(tree, closest, node);
+                               break;
+
+                       case 0:
+                               return NULL;
+               }
+       }
+
 #ifdef AVL_COUNT
-  node->count = 1;
+       node->count = 1;
 #endif
 #ifdef AVL_DEPTH
-  node->depth = 1;
+       node->depth = 1;
 #endif
 
-  return node;
+       return node;
 }
 
-void avl_insert_top(avl_tree_t *tree, avl_node_t *node)
+void avl_insert_top(avl_tree_t * tree, avl_node_t * node)
 {
-  node->prev = node->next = node->parent = NULL;
-  tree->head = tree->tail = tree->root = node;
+       node->prev = node->next = node->parent = NULL;
+       tree->head = tree->tail = tree->root = node;
 }
 
-void avl_insert_before(avl_tree_t *tree, avl_node_t *before, avl_node_t *node)
+void avl_insert_before(avl_tree_t * tree, avl_node_t * before,
+                                          avl_node_t * node)
 {
-  if (!before)
-    return tree->tail ? avl_insert_after(tree, tree->tail, node) : avl_insert_top(tree, node);
+       if(!before)
+               return tree->tail ? avl_insert_after(tree, tree->tail, node) : avl_insert_top(tree, node);
 
-  node->next = before;
-  node->parent = before;
-  node->prev = before->prev;
+       node->next = before;
+       node->parent = before;
+       node->prev = before->prev;
 
-  if(before->left)
-    return avl_insert_after(tree, before->prev, node);
+       if(before->left)
+               return avl_insert_after(tree, before->prev, node);
 
-  if (before->prev)
-    before->prev->next = node;
-  else
-    tree->head = node;
+       if(before->prev)
+               before->prev->next = node;
+       else
+               tree->head = node;
 
-  before->prev = node;
-  before->left = node;
+       before->prev = node;
+       before->left = node;
 
-  avl_rebalance(tree, before->parent);
+       avl_rebalance(tree, before->parent);
 }
 
-void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
+void avl_insert_after(avl_tree_t * tree, avl_node_t * after, avl_node_t * node)
 {
-  if (!after)
-    return tree->head ? avl_insert_before(tree, tree->head, node) : avl_insert_top(tree, node);
+       if(!after)
+               return tree->head ? avl_insert_before(tree, tree->head,
+                                                                                         node) : avl_insert_top(tree,
+                                                                                                                                        node);
+
+       if(after->right)
+               return avl_insert_before(tree, after->next, node);
 
-  if(after->right)
-    return avl_insert_before(tree, after->next, node);
+       node->prev = after;
+       node->parent = after;
+       node->next = after->next;
 
-  node->prev = after;
-  node->parent = after;
-  node->next = after->next;
+       if(after->next)
+               after->next->prev = node;
+       else
+               tree->tail = node;
 
-  if (after->next)
-    after->next->prev = node;
-  else
-    tree->tail = node;
-    
-  after->next = node;
-  after->right = node;
+       after->next = node;
+       after->right = node;
 
-  avl_rebalance(tree, after->parent);
+       avl_rebalance(tree, after->parent);
 }
 
-avl_node_t *avl_unlink(avl_tree_t *tree, void *data)
+avl_node_t *avl_unlink(avl_tree_t * tree, void *data)
 {
-  avl_node_t *node;
-  
-  node = avl_search_node(tree, data);
+       avl_node_t *node;
 
-  if(node)
-    avl_unlink_node(tree, node);
+       node = avl_search_node(tree, data);
 
-  return node;
+       if(node)
+               avl_unlink_node(tree, node);
+
+       return node;
 }
 
-void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
+void avl_unlink_node(avl_tree_t * tree, avl_node_t * node)
 {
-  avl_node_t *parent;
-  avl_node_t **superparent;
-  avl_node_t *subst, *left, *right;
-  avl_node_t *balnode;
-
-  if (node->prev)
-    node->prev->next = node->next;
-  else
-    tree->head = node->next;
-  if (node->next)
-    node->next->prev = node->prev;
-  else
-    tree->tail = node->prev;
-
-  parent = node->parent;
-
-  superparent = parent ? node == parent->left ? &parent->left : &parent->right : &tree->root;
-
-  left = node->left;
-  right = node->right;
-  if (!left)
-  {
-    *superparent = right;
-    if (right)
-      right->parent = parent;
-    balnode = parent;
-  } else if (!right)
-  {
-    *superparent = left;
-    left->parent = parent;
-    balnode = parent;
-  } else
-  {
-    subst = node->prev;
-    if (subst == left)
-    {
-      balnode = subst;
-    } else
-    {
-      balnode = subst->parent;
-      balnode->right = subst->left;
-      if (balnode->right)
-        balnode->right->parent = balnode;
-      subst->left = left;
-      left->parent = subst;
-    }
-    subst->right = right;
-    subst->parent = parent;
-    right->parent = subst;
-    *superparent = subst;
-  }
-
-  avl_rebalance(tree, balnode);
-  
-  node->next = node->prev = node->parent = node->left = node->right = NULL;
+       avl_node_t *parent;
+       avl_node_t **superparent;
+       avl_node_t *subst, *left, *right;
+       avl_node_t *balnode;
+
+       if(node->prev)
+               node->prev->next = node->next;
+       else
+               tree->head = node->next;
+       if(node->next)
+               node->next->prev = node->prev;
+       else
+               tree->tail = node->prev;
+
+       parent = node->parent;
+
+       superparent =
+               parent ? node ==
+               parent->left ? &parent->left : &parent->right : &tree->root;
+
+       left = node->left;
+       right = node->right;
+       if(!left) {
+               *superparent = right;
+
+               if(right)
+                       right->parent = parent;
+
+               balnode = parent;
+       } else if(!right) {
+               *superparent = left;
+               left->parent = parent;
+               balnode = parent;
+       } else {
+               subst = node->prev;
+
+               if(subst == left) {
+                       balnode = subst;
+               } else {
+                       balnode = subst->parent;
+                       balnode->right = subst->left;
+
+                       if(balnode->right)
+                               balnode->right->parent = balnode;
+
+                       subst->left = left;
+                       left->parent = subst;
+               }
+
+               subst->right = right;
+               subst->parent = parent;
+               right->parent = subst;
+               *superparent = subst;
+       }
+
+       avl_rebalance(tree, balnode);
+
+       node->next = node->prev = node->parent = node->left = node->right = NULL;
 
 #ifdef AVL_COUNT
-  node->count = 0;
+       node->count = 0;
 #endif
 #ifdef AVL_DEPTH
-  node->depth = 0;
+       node->depth = 0;
 #endif
 }
 
-void avl_delete_node(avl_tree_t *tree, avl_node_t *node)
+void avl_delete_node(avl_tree_t * tree, avl_node_t * node)
 {
-  avl_unlink_node(tree, node);
-  avl_free_node(tree, node);
+       avl_unlink_node(tree, node);
+       avl_free_node(tree, node);
 }
 
-void avl_delete(avl_tree_t *tree, void *data)
+void avl_delete(avl_tree_t * tree, void *data)
 {
-  avl_node_t *node;
+       avl_node_t *node;
 
-  node = avl_search_node(tree, data);
+       node = avl_search_node(tree, data);
 
-  if (node)
-    avl_delete_node(tree, node);
+       if(node)
+               avl_delete_node(tree, node);
 }
 
 /* Fast tree cleanup */
 
-void avl_delete_tree(avl_tree_t *tree)
+void avl_delete_tree(avl_tree_t * tree)
 {
-  avl_node_t *node, *next;
-  
-  for(node = tree->root; node; node = next)
-  {
-    next = node->next;
-    avl_free_node(tree, node);
-  }
-  
-  avl_free_tree(tree);
+       avl_node_t *node, *next;
+
+       for(node = tree->root; node; node = next) {
+               next = node->next;
+               avl_free_node(tree, node);
+       }
+
+       avl_free_tree(tree);
 }
 
 /* Tree walking */
 
-void avl_foreach(avl_tree_t *tree, avl_action_t action)
+void avl_foreach(avl_tree_t * tree, avl_action_t action)
 {
-  avl_node_t *node, *next;
-  
-  for(node = tree->head; node; node = next)
-    {
-      next = node->next;
-      action(node->data);
-    }
+       avl_node_t *node, *next;
+
+       for(node = tree->head; node; node = next) {
+               next = node->next;
+               action(node->data);
+       }
 }
 
-void avl_foreach_node(avl_tree_t *tree, avl_action_t action)
+void avl_foreach_node(avl_tree_t * tree, avl_action_t action)
 {
-  avl_node_t *node, *next;
-  
-  for(node = tree->head; node; node = next)
-    {
-      next = node->next;
-      action(node);
-    }
+       avl_node_t *node, *next;
+
+       for(node = tree->head; node; node = next) {
+               next = node->next;
+               action(node);
+       }
 }
 
 /* Indexing */
 
 #ifdef AVL_COUNT
-unsigned int avl_count(avl_tree_t *tree)
+unsigned int avl_count(avl_tree_t * tree)
 {
-  return AVL_NODE_COUNT(tree->root);
+       return AVL_NODE_COUNT(tree->root);
 }
 
-avl_node_t *avl_get_node(const avl_tree_t *tree, unsigned int index)
+avl_node_t *avl_get_node(const avl_tree_t * tree, unsigned int index)
 {
-  avl_node_t *node;
-  unsigned int c;
-
-  node = tree->root;
-
-  while (node)
-  {
-    c = AVL_L_COUNT(node);
-
-    if (index < c)
-    {
-      node = node->left;
-    } else if (index > c)
-    {
-      node = node->right;
-      index -= c + 1;
-    } else
-    {
-      return node;
-    }
-  }
-  
-  return NULL;
+       avl_node_t *node;
+       unsigned int c;
+
+       node = tree->root;
+
+       while(node) {
+               c = AVL_L_COUNT(node);
+
+               if(index < c) {
+                       node = node->left;
+               } else if(index > c) {
+                       node = node->right;
+                       index -= c + 1;
+               } else {
+                       return node;
+               }
+       }
+
+       return NULL;
 }
 
-unsigned int avl_index(const avl_node_t *node)
+unsigned int avl_index(const avl_node_t * node)
 {
-  avl_node_t *next;
-  unsigned int index;
+       avl_node_t *next;
+       unsigned int index;
 
-  index = AVL_L_COUNT(node);
+       index = AVL_L_COUNT(node);
 
-  while ((next = node->parent))
-  {
-    if (node == next->right)
-      index += AVL_L_COUNT(next) + 1;
-    node = next;
-  }
+       while((next = node->parent)) {
+               if(node == next->right)
+                       index += AVL_L_COUNT(next) + 1;
+               node = next;
+       }
 
-  return index;
+       return index;
 }
 #endif
 #ifdef AVL_DEPTH
-unsigned int avl_depth(avl_tree_t *tree)
+unsigned int avl_depth(avl_tree_t * tree)
 {
-  return AVL_NODE_DEPTH(tree->root);
+       return AVL_NODE_DEPTH(tree->root);
 }
 #endif
index 35c13a32b04a9e5b0aaf2acd6273174e80e331f0..08bed6b9c057e430133e7ef6b43dcf2878022753 100644 (file)
@@ -29,7 +29,7 @@
     library for inclusion into tinc (http://tinc.nl.linux.org/) by
     Guus Sliepen <guus@sliepen.eu.org>.
 
-    $Id: avl_tree.h,v 1.1.2.5 2002/06/21 10:11:11 guus Exp $
+    $Id: avl_tree.h,v 1.1.2.6 2002/09/09 21:49:16 guus Exp $
 */
 
 
 #define __AVL_TREE_H__
 
 #ifndef AVL_DEPTH
- #ifndef AVL_COUNT
-  #define AVL_DEPTH
- #endif
+#ifndef AVL_COUNT
+#define AVL_DEPTH
+#endif
 #endif
 
 typedef struct avl_node_t {
 
-  /* Linked list part */
+       /* Linked list part */
 
-  struct avl_node_t *next;
-  struct avl_node_t *prev;
+       struct avl_node_t *next;
+       struct avl_node_t *prev;
 
-  /* Tree part */
+       /* Tree part */
 
-  struct avl_node_t *parent;
-  struct avl_node_t *left;
-  struct avl_node_t *right;
+       struct avl_node_t *parent;
+       struct avl_node_t *left;
+       struct avl_node_t *right;
 
 #ifdef AVL_COUNT
-  unsigned int count;
+       unsigned int count;
 #endif
 #ifdef AVL_DEPTH
-  unsigned char depth;
+       unsigned char depth;
 #endif
 
-  /* Payload */
+       /* Payload */
 
-  void *data;
+       void *data;
 
 } avl_node_t;
 
@@ -74,17 +74,17 @@ typedef void (*avl_action_node_t) (const avl_node_t *);
 
 typedef struct avl_tree_t {
 
-  /* Linked list part */
+       /* Linked list part */
 
-  avl_node_t *head;
-  avl_node_t *tail;
+       avl_node_t *head;
+       avl_node_t *tail;
 
-  /* Tree part */
+       /* Tree part */
 
-  avl_node_t *root;
+       avl_node_t *root;
 
-  avl_compare_t compare;
-  avl_action_t delete;
+       avl_compare_t compare;
+       avl_action_t delete;
 
 } avl_tree_t;
 
@@ -94,7 +94,7 @@ extern avl_tree_t *avl_alloc_tree(avl_compare_t, avl_action_t);
 extern void avl_free_tree(avl_tree_t *);
 
 extern avl_node_t *avl_alloc_node(void);
-extern void avl_free_node(avl_tree_t *tree, avl_node_t *);
+extern void avl_free_node(avl_tree_t * tree, avl_node_t *);
 
 /* Insertion and deletion */
 
@@ -106,7 +106,7 @@ extern void avl_insert_before(avl_tree_t *, avl_node_t *, avl_node_t *);
 extern void avl_insert_after(avl_tree_t *, avl_node_t *, avl_node_t *);
 
 extern avl_node_t *avl_unlink(avl_tree_t *, void *);
-extern void avl_unlink_node(avl_tree_t *tree, avl_node_t *);
+extern void avl_unlink_node(avl_tree_t * tree, avl_node_t *);
 extern void avl_delete(avl_tree_t *, void *);
 extern void avl_delete_node(avl_tree_t *, avl_node_t *);
 
@@ -142,4 +142,4 @@ extern unsigned int avl_index(const avl_node_t *);
 extern unsigned int avl_depth(avl_tree_t *);
 #endif
 
-#endif /* __AVL_TREE_H__ */
+#endif                                                 /* __AVL_TREE_H__ */
index 661c4551027d89282ef3af370040189a7acba884..22bc812fd718b5ded4a4b6691f35bee6c42b24e2 100644 (file)
@@ -17,7 +17,7 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: dropin.c,v 1.1.2.11 2002/07/12 11:45:21 guus Exp $
+    $Id: dropin.c,v 1.1.2.12 2002/09/09 21:49:16 guus Exp $
 */
 
 #include "config.h"
 */
 int daemon(int nochdir, int noclose)
 {
-  pid_t pid;
-  int fd;
-  
-  pid = fork();
-  
-  /* Check if forking failed */
-  if(pid < 0)
-    {
-      perror("fork");
-      exit(-1);
-    }
-
-  /* If we are the parent, terminate */
-  if(pid)
-    exit(0);
-
-  /* Detach by becoming the new process group leader */
-  if(setsid() < 0)
-    {
-      perror("setsid");
-      return -1;
-    }
-  
-  /* Change working directory to the root (to avoid keeping mount
-     points busy) */
-  if(!nochdir)
-    {
-      chdir("/");
-    }
-    
-  /* Redirect stdin/out/err to /dev/null */
-  if(!noclose)
-    {
-      fd = open("/dev/null", O_RDWR);
-
-      if(fd < 0)
-        {
-          perror("opening /dev/null");
-          return -1;
-        }
-      else
-        {
-          dup2(fd, 0);
-          dup2(fd, 1);
-          dup2(fd, 2);
-        }
-    }
-
-  return 0;
+       pid_t pid;
+       int fd;
+
+       pid = fork();
+
+       /* Check if forking failed */
+       if(pid < 0) {
+               perror("fork");
+               exit(-1);
+       }
+
+       /* If we are the parent, terminate */
+       if(pid)
+               exit(0);
+
+       /* Detach by becoming the new process group leader */
+       if(setsid() < 0) {
+               perror("setsid");
+               return -1;
+       }
+
+       /* Change working directory to the root (to avoid keeping mount
+          points busy) */
+       if(!nochdir) {
+               chdir("/");
+       }
+
+       /* Redirect stdin/out/err to /dev/null */
+       if(!noclose) {
+               fd = open("/dev/null", O_RDWR);
+
+               if(fd < 0) {
+                       perror("opening /dev/null");
+                       return -1;
+               } else {
+                       dup2(fd, 0);
+                       dup2(fd, 1);
+                       dup2(fd, 2);
+               }
+       }
+
+       return 0;
 }
 #endif
 
-
-
-
 #ifndef HAVE_GET_CURRENT_DIR_NAME
 /*
   Replacement for the GNU get_current_dir_name function:
@@ -116,56 +106,55 @@ int daemon(int nochdir, int noclose)
 */
 char *get_current_dir_name(void)
 {
-  size_t size;
-  char *buf;
-  char *r;
-
-  /* Start with 100 bytes.  If this turns out to be insufficient to
-     contain the working directory, double the size.  */
-  size = 100;
-  buf = xmalloc(size);
-
-  errno = 0; /* Success */
-  r = getcwd(buf, size);
-  /* getcwd returns NULL and sets errno to ERANGE if the bufferspace
-     is insufficient to contain the entire working directory.  */
-  while(r == NULL && errno == ERANGE)
-    {
-      free(buf);
-      size <<= 1; /* double the size */
-      buf = xmalloc(size);
-      r = getcwd(buf, size);
-    }
-
-  return buf;
+       size_t size;
+       char *buf;
+       char *r;
+
+       /* Start with 100 bytes.  If this turns out to be insufficient to
+          contain the working directory, double the size.  */
+       size = 100;
+       buf = xmalloc(size);
+
+       errno = 0;                                      /* Success */
+       r = getcwd(buf, size);
+
+       /* getcwd returns NULL and sets errno to ERANGE if the bufferspace
+          is insufficient to contain the entire working directory.  */
+       while(r == NULL && errno == ERANGE) {
+               free(buf);
+               size <<= 1;                             /* double the size */
+               buf = xmalloc(size);
+               r = getcwd(buf, size);
+       }
+
+       return buf;
 }
 #endif
 
 #ifndef HAVE_ASPRINTF
 int asprintf(char **buf, const char *fmt, ...)
 {
-  int status;
-  va_list ap;
-  int len;
-  
-  len = 4096;
-  *buf = xmalloc(len);
+       int status;
+       va_list ap;
+       int len;
+
+       len = 4096;
+       *buf = xmalloc(len);
 
-  va_start(ap, fmt);
-  status = vsnprintf (*buf, len, fmt, ap);
-  va_end (ap);
+       va_start(ap, fmt);
+       status = vsnprintf(*buf, len, fmt, ap);
+       va_end(ap);
 
-  if(status >= 0)
-    *buf = xrealloc(*buf, status);
+       if(status >= 0)
+               *buf = xrealloc(*buf, status);
 
-  if(status > len-1)
-    {
-      len = status;
-      va_start(ap, fmt);
-      status = vsnprintf (*buf, len, fmt, ap);
-      va_end (ap);
-    }
+       if(status > len - 1) {
+               len = status;
+               va_start(ap, fmt);
+               status = vsnprintf(*buf, len, fmt, ap);
+               va_end(ap);
+       }
 
-  return status;
+       return status;
 }
 #endif
index ecf14403a9451f0e7e98655c9c109a76e0996143..0d10c367ef8d01988830166ddd32b79dc8446e20 100644 (file)
@@ -17,7 +17,7 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: dropin.h,v 1.1.2.8 2002/06/21 10:11:11 guus Exp $
+    $Id: dropin.h,v 1.1.2.9 2002/09/09 21:49:16 guus Exp $
 */
 
 #ifndef __DROPIN_H__
@@ -28,7 +28,7 @@ extern int daemon(int, int);
 #endif
 
 #ifndef HAVE_GET_CURRENT_DIR_NAME
-extern charget_current_dir_name(void);
+extern char *get_current_dir_name(void);
 #endif
 
 #ifndef HAVE_ASPRINTF
@@ -39,7 +39,7 @@ extern int asprintf(char **, const char *, ...);
 #include <sys/types.h>
 #include <sys/socket.h>
 extern int getnameinfo(const struct sockaddr *sa, size_t salen, char *host,
-                size_t hostlen, char *serv, size_t servlen, int flags);
+                                          size_t hostlen, char *serv, size_t servlen, int flags);
 #endif
 
-#endif /* __DROPIN_H__ */
+#endif                                                 /* __DROPIN_H__ */
index b4c5871c19f41281c407cacce6540a4dff0199d5..d47ce0ebb8bc36ffd15b8e982da0ccf560feb006 100644 (file)
@@ -17,7 +17,7 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: list.c,v 1.1.2.11 2002/06/21 10:11:11 guus Exp $
+    $Id: list.c,v 1.1.2.12 2002/09/09 21:49:16 guus Exp $
 */
 
 #include "config.h"
 
 list_t *list_alloc(list_action_t delete)
 {
-  list_t *list;
+       list_t *list;
 
-  list = xmalloc_and_zero(sizeof(list_t));
-  list->delete = delete;
+       list = xmalloc_and_zero(sizeof(list_t));
+       list->delete = delete;
 
-  return list;
+       return list;
 }
 
-void list_free(list_t *list)
+void list_free(list_t * list)
 {
-  free(list);
+       free(list);
 }
 
 list_node_t *list_alloc_node(void)
 {
-  list_node_t *node;
-  
-  node = xmalloc_and_zero(sizeof(list_node_t));
-  
-  return node;
+       return (list_node_t *)xmalloc_and_zero(sizeof(list_node_t));
 }
 
-void list_free_node(list_t *list, list_node_t *node)
+void list_free_node(list_t * list, list_node_t * node)
 {
-  if(node->data && list->delete)
-    list->delete(node->data);
-  
-  free(node);
+       if(node->data && list->delete)
+               list->delete(node->data);
+
+       free(node);
 }
 
 /* Insertion and deletion */
 
-list_node_t *list_insert_head(list_t *list, void *data)
+list_node_t *list_insert_head(list_t * list, void *data)
 {
-  list_node_t *node;
-  
-  node = list_alloc_node();
-  
-  node->data = data;
-  node->prev = NULL;
-  node->next = list->head;
-  list->head = node;
-  
-  if(node->next)
-    node->next->prev = node;
-  else
-    list->tail = node;
-
-  list->count++;
-
-  return node;
+       list_node_t *node;
+
+       node = list_alloc_node();
+
+       node->data = data;
+       node->prev = NULL;
+       node->next = list->head;
+       list->head = node;
+
+       if(node->next)
+               node->next->prev = node;
+       else
+               list->tail = node;
+
+       list->count++;
+
+       return node;
 }
 
-list_node_t *list_insert_tail(list_t *list, void *data)
+list_node_t *list_insert_tail(list_t * list, void *data)
 {
-  list_node_t *node;
-  
-  node = list_alloc_node();
-  
-  node->data = data;
-  node->next = NULL;
-  node->prev = list->tail;
-  list->tail = node;
-  
-  if(node->prev)
-    node->prev->next = node;
-  else
-    list->head = node;
-
-  list->count++;
-  
-  return node;
+       list_node_t *node;
+
+       node = list_alloc_node();
+
+       node->data = data;
+       node->next = NULL;
+       node->prev = list->tail;
+       list->tail = node;
+
+       if(node->prev)
+               node->prev->next = node;
+       else
+               list->head = node;
+
+       list->count++;
+
+       return node;
 }
 
-void list_unlink_node(list_t *list, list_node_t *node)
+void list_unlink_node(list_t * list, list_node_t * node)
 {
-  if(node->prev)
-    node->prev->next = node->next;
-  else
-    list->head = node->next;
-    
-  if(node->next)
-    node->next->prev = node->prev;
-  else
-    list->tail = node->prev;
-
-  list->count--;
+       if(node->prev)
+               node->prev->next = node->next;
+       else
+               list->head = node->next;
+
+       if(node->next)
+               node->next->prev = node->prev;
+       else
+               list->tail = node->prev;
+
+       list->count--;
 }
 
-void list_delete_node(list_t *list, list_node_t *node)
+void list_delete_node(list_t * list, list_node_t * node)
 {
-  list_unlink_node(list, node);
-  list_free_node(list, node);
+       list_unlink_node(list, node);
+       list_free_node(list, node);
 }
 
-void list_delete_head(list_t *list)
+void list_delete_head(list_t * list)
 {
-  list_delete_node(list, list->head);
+       list_delete_node(list, list->head);
 }
 
-void list_delete_tail(list_t *list)
+void list_delete_tail(list_t * list)
 {
-  list_delete_node(list, list->tail);
+       list_delete_node(list, list->tail);
 }
 
 /* Head/tail lookup */
 
-void *list_get_head(list_t *list)
+void *list_get_head(list_t * list)
 {
-  if(list->head)
-    return list->head->data;
-  else
-    return NULL;
+       if(list->head)
+               return list->head->data;
+       else
+               return NULL;
 }
 
-void *list_get_tail(list_t *list)
+void *list_get_tail(list_t * list)
 {
-  if(list->tail)
-    return list->tail->data;
-  else
-    return NULL;
+       if(list->tail)
+               return list->tail->data;
+       else
+               return NULL;
 }
 
 /* Fast list deletion */
 
-void list_delete_list(list_t *list)
+void list_delete_list(list_t * list)
 {
-  list_node_t *node, *next;
-  
-  for(node = list->head; node; node = next)
-    {
-      next = node->next;
-      list_free_node(list, node);
-    }
-
-  list_free(list);
+       list_node_t *node, *next;
+
+       for(node = list->head; node; node = next) {
+               next = node->next;
+               list_free_node(list, node);
+       }
+
+       list_free(list);
 }
 
 /* Traversing */
 
-void list_foreach_node(list_t *list, list_action_node_t action)
+void list_foreach_node(list_t * list, list_action_node_t action)
 {
-  list_node_t *node, *next;
+       list_node_t *node, *next;
 
-  for(node = list->head; node; node = next)
-    {
-      next = node->next;
-      action(node);
-    }
+       for(node = list->head; node; node = next) {
+               next = node->next;
+               action(node);
+       }
 }
 
-void list_foreach(list_t *list, list_action_t action)
+void list_foreach(list_t * list, list_action_t action)
 {
-  list_node_t *node, *next;
-
-  for(node = list->head; node; node = next)
-    {
-      next = node->next;
-      if(node->data)
-        action(node->data);
-    }
+       list_node_t *node, *next;
+
+       for(node = list->head; node; node = next) {
+               next = node->next;
+               if(node->data)
+                       action(node->data);
+       }
 }
index 4c9885d44becd300eed0c45d19ddd09e8257ac04..326a92968e6ca01812aac4c296cba30ade1d05cf 100644 (file)
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id: list.h,v 1.1.2.6 2002/06/21 10:11:11 guus Exp $
+    $Id: list.h,v 1.1.2.7 2002/09/09 21:49:16 guus Exp $
 */
 
 #ifndef __TINC_LIST_H__
 #define __TINC_LIST_H__
 
-typedef struct list_node_t
-{
-  struct list_node_t *prev;
-  struct list_node_t *next;
+typedef struct list_node_t {
+       struct list_node_t *prev;
+       struct list_node_t *next;
 
-  /* Payload */
+       /* Payload */
 
-  void *data;
+       void *data;
 } list_node_t;
 
 typedef void (*list_action_t) (const void *);
 typedef void (*list_action_node_t) (const list_node_t *);
 
-typedef struct list_t
-{
-  list_node_t *head;
-  list_node_t *tail;
-  int count;
+typedef struct list_t {
+       list_node_t *head;
+       list_node_t *tail;
+       int count;
 
-  /* Callbacks */
+       /* Callbacks */
 
-  list_action_t delete;
+       list_action_t delete;
 } list_t;
 
 /* (De)constructors */
@@ -79,4 +77,4 @@ extern void list_delete_list(list_t *);
 extern void list_foreach(list_t *, list_action_t);
 extern void list_foreach_node(list_t *, list_action_node_t);
 
-#endif /* __TINC_LIST_H__ */
+#endif                                                 /* __TINC_LIST_H__ */
index ce78dd2e799c5ddc5470525e769488b6580c9fbc..3b1abc374bb8ef7bb4fe9ed8fc75019e99dd7037 100644 (file)
@@ -38,50 +38,49 @@ char *hexadecimals = "0123456789ABCDEF";
 
 int charhex2bin(char c)
 {
-  if(isdigit(c))
-    return c - '0';
-  else
-    return toupper(c) - 'A' + 10;
+       if(isdigit(c))
+               return c - '0';
+       else
+               return toupper(c) - 'A' + 10;
 }
 
 
 void hex2bin(char *src, char *dst, int length)
 {
-  int i;
-  for(i=0; i<length; i++)
-    dst[i] = charhex2bin(src[i*2])*16 + charhex2bin(src[i*2+1]);
+       int i;
+       for(i = 0; i < length; i++)
+               dst[i] = charhex2bin(src[i * 2]) * 16 + charhex2bin(src[i * 2 + 1]);
 }
 
 void bin2hex(char *src, char *dst, int length)
 {
-  int i;
-  for(i=length-1; i>=0; i--)
-    {
-      dst[i*2+1] = hexadecimals[(unsigned char)src[i] & 15];
-      dst[i*2] = hexadecimals[(unsigned char)src[i]>>4];
-    }
+       int i;
+       for(i = length - 1; i >= 0; i--) {
+               dst[i * 2 + 1] = hexadecimals[(unsigned char) src[i] & 15];
+               dst[i * 2] = hexadecimals[(unsigned char) src[i] >> 4];
+       }
 }
 
 #ifdef ENABLE_TRACING
 void cp_trace()
 {
-  syslog(LOG_DEBUG, "Checkpoint trace: %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d...",
-           cp_file[(cp_index+15)%16], cp_line[(cp_index+15)%16],
-           cp_file[(cp_index+14)%16], cp_line[(cp_index+14)%16],
-           cp_file[(cp_index+13)%16], cp_line[(cp_index+13)%16],
-           cp_file[(cp_index+12)%16], cp_line[(cp_index+12)%16],
-           cp_file[(cp_index+11)%16], cp_line[(cp_index+11)%16],
-           cp_file[(cp_index+10)%16], cp_line[(cp_index+10)%16],
-           cp_file[(cp_index+9)%16], cp_line[(cp_index+9)%16],
-           cp_file[(cp_index+8)%16], cp_line[(cp_index+8)%16],
-           cp_file[(cp_index+7)%16], cp_line[(cp_index+7)%16],
-           cp_file[(cp_index+6)%16], cp_line[(cp_index+6)%16],
-           cp_file[(cp_index+5)%16], cp_line[(cp_index+5)%16],
-           cp_file[(cp_index+4)%16], cp_line[(cp_index+4)%16],
-           cp_file[(cp_index+3)%16], cp_line[(cp_index+3)%16],
-           cp_file[(cp_index+2)%16], cp_line[(cp_index+2)%16],
-           cp_file[(cp_index+1)%16], cp_line[(cp_index+1)%16],
-           cp_file[cp_index], cp_line[cp_index]
-        );
+       syslog(LOG_DEBUG, "Checkpoint trace: %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d...",
+                  cp_file[(cp_index + 15) % 16], cp_line[(cp_index + 15) % 16],
+                  cp_file[(cp_index + 14) % 16], cp_line[(cp_index + 14) % 16],
+                  cp_file[(cp_index + 13) % 16], cp_line[(cp_index + 13) % 16],
+                  cp_file[(cp_index + 12) % 16], cp_line[(cp_index + 12) % 16],
+                  cp_file[(cp_index + 11) % 16], cp_line[(cp_index + 11) % 16],
+                  cp_file[(cp_index + 10) % 16], cp_line[(cp_index + 10) % 16],
+                  cp_file[(cp_index + 9) % 16], cp_line[(cp_index + 9) % 16],
+                  cp_file[(cp_index + 8) % 16], cp_line[(cp_index + 8) % 16],
+                  cp_file[(cp_index + 7) % 16], cp_line[(cp_index + 7) % 16],
+                  cp_file[(cp_index + 6) % 16], cp_line[(cp_index + 6) % 16],
+                  cp_file[(cp_index + 5) % 16], cp_line[(cp_index + 5) % 16],
+                  cp_file[(cp_index + 4) % 16], cp_line[(cp_index + 4) % 16],
+                  cp_file[(cp_index + 3) % 16], cp_line[(cp_index + 3) % 16],
+                  cp_file[(cp_index + 2) % 16], cp_line[(cp_index + 2) % 16],
+                  cp_file[(cp_index + 1) % 16], cp_line[(cp_index + 1) % 16],
+                  cp_file[cp_index], cp_line[cp_index]
+               );
 }
 #endif
index a1a666bd3f48527dd4b633adf261ea7ff5aceac7..7a953a3e34c8c076137d45a0e57e6fb983ea80dc 100644 (file)
 #include "fake-getnameinfo.h"
 
 enum {
-  DEBUG_NOTHING = 0,           /* Quiet mode, only show starting/stopping of the daemon */
-  DEBUG_CONNECTIONS = 1,       /* Show (dis)connects of other tinc daemons via TCP */
-  DEBUG_ERROR = 2,             /* Show error messages received from other hosts */
-  DEBUG_STATUS = 2,            /* Show status messages received from other hosts */
-  DEBUG_PROTOCOL = 3,          /* Show the requests that are sent/received */
-  DEBUG_META = 4,              /* Show contents of every request that is sent/received */
-  DEBUG_TRAFFIC = 5,           /* Show network traffic information */
-  DEBUG_PACKET = 6,            /* Show contents of each packet that is being sent/received */
-  DEBUG_SCARY_THINGS = 10      /* You have been warned */
+       DEBUG_NOTHING = 0,                      /* Quiet mode, only show starting/stopping of the daemon */
+       DEBUG_CONNECTIONS = 1,          /* Show (dis)connects of other tinc daemons via TCP */
+       DEBUG_ERROR = 2,                        /* Show error messages received from other hosts */
+       DEBUG_STATUS = 2,                       /* Show status messages received from other hosts */
+       DEBUG_PROTOCOL = 3,                     /* Show the requests that are sent/received */
+       DEBUG_META = 4,                         /* Show contents of every request that is sent/received */
+       DEBUG_TRAFFIC = 5,                      /* Show network traffic information */
+       DEBUG_PACKET = 6,                       /* Show contents of each packet that is being sent/received */
+       DEBUG_SCARY_THINGS = 10         /* You have been warned */
 };
 
 #define min(a,b) (((a)<(b))?(a):(b))
@@ -46,15 +46,15 @@ extern volatile char *cp_file[];
 extern volatile int cp_index;
 extern void cp_trace(void);
 
-  #define cp() { cp_line[cp_index] = __LINE__; cp_file[cp_index] = __FILE__; cp_index++; cp_index %= 16; }
-  #define ecp() { fprintf(stderr, "Explicit checkpoint in %s line %d\n", __FILE__, __LINE__); }
+#define cp() { cp_line[cp_index] = __LINE__; cp_file[cp_index] = __FILE__; cp_index++; cp_index %= 16; }
+#define ecp() { fprintf(stderr, "Explicit checkpoint in %s line %d\n", __FILE__, __LINE__); }
 #else
-  #define cp()
-  #define ecp()
-  #define cp_trace()
+#define cp()
+#define ecp()
+#define cp_trace()
 #endif
 
 extern void hex2bin(char *src, char *dst, int length);
 extern void bin2hex(char *src, char *dst, int length);
 
-#endif /* __TINC_UTILS_H__ */
+#endif                                                 /* __TINC_UTILS_H__ */