Reformat all code using astyle.
authorGuus Sliepen <guus@tinc-vpn.org>
Sat, 7 Oct 2017 15:49:45 +0000 (17:49 +0200)
committerGuus Sliepen <guus@tinc-vpn.org>
Sat, 7 Oct 2017 15:49:45 +0000 (17:49 +0200)
65 files changed:
src/avl_tree.c
src/bsd/device.c
src/bsd/tunemu.c
src/bsd/tunemu.h
src/conf.c
src/conf.h
src/connection.c
src/connection.h
src/cygwin/device.c
src/dropin.c
src/edge.c
src/edge.h
src/ethernet.h
src/event.c
src/event.h
src/fake-getaddrinfo.c
src/fake-getaddrinfo.h
src/fake-getnameinfo.c
src/fake-getnameinfo.h
src/getopt.c
src/getopt.h
src/getopt1.c
src/graph.c
src/ipv4.h
src/ipv6.h
src/linux/device.c
src/list.c
src/list.h
src/logger.c
src/logger.h
src/meta.c
src/mingw/common.h
src/mingw/device.c
src/multicast_device.c
src/net.c
src/net.h
src/net_packet.c
src/net_setup.c
src/net_socket.c
src/netutl.c
src/node.c
src/node.h
src/pidfile.c
src/pidfile.h
src/process.c
src/protocol.c
src/protocol.h
src/protocol_auth.c
src/protocol_edge.c
src/protocol_key.c
src/protocol_misc.c
src/protocol_subnet.c
src/proxy.c
src/raw_socket_device.c
src/route.c
src/route.h
src/solaris/device.c
src/subnet.c
src/subnet.h
src/tincd.c
src/uml_device.c
src/utils.c
src/utils.h
src/vde_device.c
src/xalloc.h

index 0d122bf..96d3d43 100644 (file)
 #endif
 
 #ifndef AVL_DEPTH
-static int lg(unsigned int u) __attribute__ ((__const__));
+static int lg(unsigned int u) __attribute__((__const__));
 
-static int lg(unsigned int u)
-{
+static int lg(unsigned int u) {
        int r = 1;
 
-       if(!u)
+       if(!u) {
                return 0;
+       }
 
        if(u & 0xffff0000) {
                u >>= 16;
@@ -79,8 +79,9 @@ static int lg(unsigned int u)
                r += 2;
        }
 
-       if(u & 0x00000002)
+       if(u & 0x00000002) {
                r++;
+       }
 
        return r;
 }
@@ -88,8 +89,7 @@ static int lg(unsigned int u)
 
 /* Internal helper functions */
 
-static int avl_check_balance(const avl_node_t *node)
-{
+static int avl_check_balance(const avl_node_t *node) {
 #ifdef AVL_DEPTH
        int d;
 
@@ -97,27 +97,28 @@ static int avl_check_balance(const avl_node_t *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 d;
       *      d = lg(AVL_R_COUNT(node)) - lg(AVL_L_COUNT(node));
       *      d = d<-1?-1:d>1?1:0;
       */
        int pl, r;
 
        pl = lg(AVL_L_COUNT(node));
        r = AVL_R_COUNT(node);
 
-       if(r >> pl + 1)
+       if(r >> pl + 1) {
                return 1;
+       }
 
-       if(pl < 2 || r >> pl - 2)
+       if(pl < 2 || r >> pl - 2) {
                return 0;
+       }
 
        return -1;
 #endif
 }
 
-static void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
-{
+static void avl_rebalance(avl_tree_t *tree, avl_node_t *node) {
        avl_node_t *child;
        avl_node_t *gchild;
        avl_node_t *parent;
@@ -127,135 +128,154 @@ static void avl_rebalance(avl_tree_t *tree, avl_node_t *node)
                parent = node->parent;
 
                superparent =
-                       parent ? node ==
-                       parent->left ? &parent->left : &parent->right : &tree->root;
+                       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;
+                       } else {
+                               gchild = child->right;
+                               node->left = gchild->right;
 
-                                       if(node->left)
-                                               node->left->parent = node;
-                                       child->right = gchild->left;
+                               if(node->left) {
+                                       node->left->parent = node;
+                               }
+
+                               child->right = gchild->left;
+
+                               if(child->right) {
+                                       child->right->parent = child;
+                               }
 
-                                       if(child->right)
-                                               child->right->parent = child;
-                                       gchild->right = node;
+                               gchild->right = node;
 
-                                       gchild->right->parent = gchild;
-                                       gchild->left = child;
+                               gchild->right->parent = gchild;
+                               gchild->left = child;
 
-                                       gchild->left->parent = gchild;
+                               gchild->left->parent = gchild;
 
-                                       *superparent = gchild;
-                                       gchild->parent = parent;
+                               *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;
+                       }
+
+                       break;
 
-                       case 1:
-                               child = node->right;
+               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;
+                       } else {
+                               gchild = child->left;
+                               node->right = gchild->left;
+
+                               if(node->right) {
+                                       node->right->parent = node;
+                               }
 
-                                       if(node->right)
-                                               node->right->parent = node;
-                                       child->left = gchild->right;
+                               child->left = gchild->right;
+
+                               if(child->left) {
+                                       child->left->parent = child;
+                               }
 
-                                       if(child->left)
-                                               child->left->parent = child;
-                                       gchild->left = node;
+                               gchild->left = node;
 
-                                       gchild->left->parent = gchild;
-                                       gchild->right = child;
+                               gchild->left->parent = gchild;
+                               gchild->right = child;
 
-                                       gchild->right->parent = gchild;
+                               gchild->right->parent = gchild;
 
-                                       *superparent = gchild;
-                                       gchild->parent = parent;
+                               *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;
        }
 }
 
 /* (De)constructors */
 
-avl_tree_t *avl_alloc_tree(avl_compare_t compare, avl_action_t delete)
-{
+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));
@@ -265,28 +285,25 @@ avl_tree_t *avl_alloc_tree(avl_compare_t compare, avl_action_t delete)
        return tree;
 }
 
-void avl_free_tree(avl_tree_t *tree)
-{
+void avl_free_tree(avl_tree_t *tree) {
        free(tree);
 }
 
-avl_node_t *avl_alloc_node(void)
-{
+avl_node_t *avl_alloc_node(void) {
        return xmalloc_and_zero(sizeof(avl_node_t));
 }
 
-void avl_free_node(avl_tree_t *tree, avl_node_t *node)
-{
-       if(node->data && tree->delete)
+void avl_free_node(avl_tree_t *tree, avl_node_t *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);
@@ -294,8 +311,7 @@ void *avl_search(const avl_tree_t *tree, const void *data)
        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);
@@ -303,8 +319,7 @@ void *avl_search_closest(const avl_tree_t *tree, const void *data, int *result)
        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);
@@ -312,8 +327,7 @@ void *avl_search_closest_smaller(const avl_tree_t *tree, const void *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);
@@ -321,8 +335,7 @@ void *avl_search_closest_greater(const avl_tree_t *tree, const void *data)
        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;
 
@@ -332,16 +345,17 @@ avl_node_t *avl_search_node(const avl_tree_t *tree, const void *data)
 }
 
 avl_node_t *avl_search_closest_node(const avl_tree_t *tree, const void *data,
-                                                                       int *result)
-{
+                                    int *result) {
        avl_node_t *node;
        int c;
 
        node = tree->root;
 
        if(!node) {
-               if(result)
+               if(result) {
                        *result = 0;
+               }
+
                return NULL;
        }
 
@@ -349,24 +363,30 @@ avl_node_t *avl_search_closest_node(const avl_tree_t *tree, const void *data,
                c = tree->compare(data, node->data);
 
                if(c < 0) {
-                       if(node->left)
+                       if(node->left) {
                                node = node->left;
-                       else {
-                               if(result)
+                       else {
+                               if(result) {
                                        *result = -1;
+                               }
+
                                break;
                        }
                } else if(c > 0) {
-                       if(node->right)
+                       if(node->right) {
                                node = node->right;
-                       else {
-                               if(result)
+                       else {
+                               if(result) {
                                        *result = 1;
+                               }
+
                                break;
                        }
                } else {
-                       if(result)
+                       if(result) {
                                *result = 0;
+                       }
+
                        break;
                }
        }
@@ -375,37 +395,36 @@ avl_node_t *avl_search_closest_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)
-{
+                const void *data) {
        avl_node_t *node;
        int result;
 
        node = avl_search_closest_node(tree, data, &result);
 
-       if(result < 0)
+       if(result < 0) {
                node = node->prev;
+       }
 
        return node;
 }
 
 avl_node_t *avl_search_closest_greater_node(const avl_tree_t *tree,
-                                                                                       const void *data)
-{
+                const void *data) {
        avl_node_t *node;
        int result;
 
        node = avl_search_closest_node(tree, data, &result);
 
-       if(result > 0)
+       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;
 
@@ -416,21 +435,21 @@ avl_node_t *avl_insert(avl_tree_t *tree, void *data)
        } 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;
+               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;
+               case 1:
+                       new = avl_alloc_node();
+                       new->data = data;
+                       avl_insert_after(tree, closest, new);
+                       break;
 
-                       default:
-                               return NULL;
+               default:
+                       return NULL;
                }
        }
 
@@ -444,27 +463,26 @@ avl_node_t *avl_insert(avl_tree_t *tree, void *data)
        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)
+       if(!tree->root) {
                avl_insert_top(tree, node);
-       else {
+       else {
                closest = avl_search_closest_node(tree, node->data, &result);
 
-               switch (result) {
-                       case -1:
-                               avl_insert_before(tree, closest, node);
-                               break;
+               switch(result) {
+               case -1:
+                       avl_insert_before(tree, closest, node);
+                       break;
 
-                       case 1:
-                               avl_insert_after(tree, closest, node);
-                               break;
+               case 1:
+                       avl_insert_after(tree, closest, node);
+                       break;
 
-                       case 0:
-                               return NULL;
+               case 0:
+                       return NULL;
                }
        }
 
@@ -478,20 +496,20 @@ avl_node_t *avl_insert_node(avl_tree_t *tree, avl_node_t *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;
 }
 
 void avl_insert_before(avl_tree_t *tree, avl_node_t *before,
-                                          avl_node_t *node)
-{
+                       avl_node_t *node) {
        if(!before) {
-               if(tree->tail)
+               if(tree->tail) {
                        avl_insert_after(tree, tree->tail, node);
-               else
+               } else {
                        avl_insert_top(tree, node);
+               }
+
                return;
        }
 
@@ -504,10 +522,11 @@ void avl_insert_before(avl_tree_t *tree, avl_node_t *before,
                return;
        }
 
-       if(before->prev)
+       if(before->prev) {
                before->prev->next = node;
-       else
+       } else {
                tree->head = node;
+       }
 
        before->prev = node;
        before->left = node;
@@ -515,13 +534,14 @@ void avl_insert_before(avl_tree_t *tree, avl_node_t *before,
        avl_rebalance(tree, before);
 }
 
-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) {
-               if(tree->head)
+               if(tree->head) {
                        avl_insert_before(tree, tree->head, node);
-               else
+               } else {
                        avl_insert_top(tree, node);
+               }
+
                return;
        }
 
@@ -534,10 +554,11 @@ void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
        node->parent = after;
        node->next = after->next;
 
-       if(after->next)
+       if(after->next) {
                after->next->prev = node;
-       else
+       } else {
                tree->tail = node;
+       }
 
        after->next = node;
        after->right = node;
@@ -545,47 +566,51 @@ void avl_insert_after(avl_tree_t *tree, avl_node_t *after, avl_node_t *node)
        avl_rebalance(tree, after);
 }
 
-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);
 
-       if(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)
+       if(node->prev) {
                node->prev->next = node->next;
-       else
+       } else {
                tree->head = node->next;
-       if(node->next)
+       }
+
+       if(node->next) {
                node->next->prev = node->prev;
-       else
+       } else {
                tree->tail = node->prev;
+       }
 
        parent = node->parent;
 
        superparent =
-               parent ? node ==
-               parent->left ? &parent->left : &parent->right : &tree->root;
+               parent ? node ==
+               parent->left ? &parent->left : &parent->right : &tree->root;
 
        left = node->left;
        right = node->right;
+
        if(!left) {
                *superparent = right;
 
-               if(right)
+               if(right) {
                        right->parent = parent;
+               }
 
                balnode = parent;
        } else if(!right) {
@@ -594,8 +619,10 @@ void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
                balnode = parent;
        } else {
                subst = node->prev;
-               if(!subst) // This only happens if node is not actually in a tree at all.
+
+               if(!subst) { // This only happens if node is not actually in a tree at all.
                        abort();
+               }
 
                if(subst == left) {
                        balnode = subst;
@@ -603,8 +630,9 @@ void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
                        balnode = subst->parent;
                        balnode->right = subst->left;
 
-                       if(balnode->right)
+                       if(balnode->right) {
                                balnode->right->parent = balnode;
+                       }
 
                        subst->left = left;
                        left->parent = subst;
@@ -628,26 +656,24 @@ void avl_unlink_node(avl_tree_t *tree, avl_node_t *node)
 #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);
 }
 
-void avl_delete(avl_tree_t *tree, void *data)
-{
+void avl_delete(avl_tree_t *tree, void *data) {
        avl_node_t *node;
 
        node = avl_search_node(tree, data);
 
-       if(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->head; node; node = next) {
@@ -660,8 +686,7 @@ void avl_delete_tree(avl_tree_t *tree)
 
 /* Tree walking */
 
-void avl_foreach(const avl_tree_t *tree, avl_action_t action)
-{
+void avl_foreach(const avl_tree_t *tree, avl_action_t action) {
        avl_node_t *node, *next;
 
        for(node = tree->head; node; node = next) {
@@ -670,8 +695,7 @@ void avl_foreach(const avl_tree_t *tree, avl_action_t action)
        }
 }
 
-void avl_foreach_node(const avl_tree_t *tree, avl_action_t action)
-{
+void avl_foreach_node(const avl_tree_t *tree, avl_action_t action) {
        avl_node_t *node, *next;
 
        for(node = tree->head; node; node = next) {
@@ -683,13 +707,11 @@ void avl_foreach_node(const avl_tree_t *tree, avl_action_t action)
 /* Indexing */
 
 #ifdef AVL_COUNT
-unsigned int avl_count(const avl_tree_t *tree)
-{
+unsigned int avl_count(const avl_tree_t *tree) {
        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;
 
@@ -711,16 +733,17 @@ avl_node_t *avl_get_node(const avl_tree_t *tree, unsigned int index)
        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;
 
        index = AVL_L_COUNT(node);
 
        while((next = node->parent)) {
-               if(node == next->right)
+               if(node == next->right) {
                        index += AVL_L_COUNT(next) + 1;
+               }
+
                node = next;
        }
 
@@ -728,8 +751,7 @@ unsigned int avl_index(const avl_node_t *node)
 }
 #endif
 #ifdef AVL_DEPTH
-unsigned int avl_depth(const avl_tree_t *tree)
-{
+unsigned int avl_depth(const avl_tree_t *tree) {
        return AVL_NODE_DEPTH(tree->root);
 }
 #endif
index f6614b2..62e7e84 100644 (file)
@@ -69,12 +69,14 @@ static device_type_t device_type = DEVICE_TYPE_TUN;
 #ifdef HAVE_NET_IF_UTUN_H
 static bool setup_utun(void) {
        device_fd = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
+
        if(device_fd == -1) {
                logger(LOG_ERR, "Could not open PF_SYSTEM socket: %s\n", strerror(errno));
                return false;
        }
 
        struct ctl_info info = {};
+
        strlcpy(info.ctl_name, UTUN_CONTROL_NAME, sizeof(info.ctl_name));
 
        if(ioctl(device_fd, CTLIOCGINFO, &info) == -1) {
@@ -84,10 +86,13 @@ static bool setup_utun(void) {
 
        int unit = -1;
        char *p = strstr(device, "utun"), *e = NULL;
+
        if(p) {
                unit = strtol(p + 4, &e, 10);
-               if(!e)
+
+               if(!e) {
                        unit = -1;
+               }
        }
 
        struct sockaddr_ctl sc = {
@@ -105,6 +110,7 @@ static bool setup_utun(void) {
 
        char name[64] = "";
        socklen_t len = sizeof(name);
+
        if(getsockopt(device_fd, SYSPROTO_CONTROL, UTUN_OPT_IFNAME, name, &len)) {
                iface = xstrdup(device);
        } else {
@@ -123,10 +129,11 @@ static bool setup_device(void) {
        // Find out which device file to open
 
        if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
-               if(routing_mode == RMODE_ROUTER)
+               if(routing_mode == RMODE_ROUTER) {
                        device = xstrdup(DEFAULT_TUN_DEVICE);
-               else
+               } else {
                        device = xstrdup(DEFAULT_TAP_DEVICE);
+               }
        }
 
        // Find out if it's supposed to be a tun or a tap device
@@ -135,33 +142,40 @@ static bool setup_device(void) {
 
        if(get_config_string(lookup_config(config_tree, "DeviceType"), &type)) {
                if(!strcasecmp(type, "tun"))
-                       /* use default */;      
+                       /* use default */;
+
 #ifdef ENABLE_TUNEMU
-               else if(!strcasecmp(type, "tunemu"))
+               else if(!strcasecmp(type, "tunemu")) {
                        device_type = DEVICE_TYPE_TUNEMU;
+               }
+
 #endif
 #ifdef HAVE_NET_IF_UTUN_H
-               else if(!strcasecmp(type, "utun"))
+               else if(!strcasecmp(type, "utun")) {
                        device_type = DEVICE_TYPE_UTUN;
+               }
+
 #endif
-               else if(!strcasecmp(type, "tunnohead"))
+               else if(!strcasecmp(type, "tunnohead")) {
                        device_type = DEVICE_TYPE_TUN;
-               else if(!strcasecmp(type, "tunifhead"))
+               } else if(!strcasecmp(type, "tunifhead")) {
                        device_type = DEVICE_TYPE_TUNIFHEAD;
-               else if(!strcasecmp(type, "tap"))
+               } else if(!strcasecmp(type, "tap")) {
                        device_type = DEVICE_TYPE_TAP;
-               else {
+               else {
                        logger(LOG_ERR, "Unknown device type %s!", type);
                        return false;
                }
        } else {
 #ifdef HAVE_NET_IF_UTUN_H
-               if(strncmp(device, "utun", 4) == 0 || strncmp(device, "/dev/utun", 9) == 0)
+
+               if(strncmp(device, "utun", 4) == 0 || strncmp(device, "/dev/utun", 9) == 0) {
                        device_type = DEVICE_TYPE_UTUN;
-               else
+               else
 #endif
-               if(strstr(device, "tap") || routing_mode != RMODE_ROUTER)
-                       device_type = DEVICE_TYPE_TAP;
+                       if(strstr(device, "tap") || routing_mode != RMODE_ROUTER) {
+                               device_type = DEVICE_TYPE_TAP;
+                       }
        }
 
        if(routing_mode == RMODE_SWITCH && device_type != DEVICE_TYPE_TAP) {
@@ -173,18 +187,21 @@ static bool setup_device(void) {
 
        switch(device_type) {
 #ifdef ENABLE_TUNEMU
-               case DEVICE_TYPE_TUNEMU: {
-                       char dynamic_name[256] = "";
-                       device_fd = tunemu_open(dynamic_name);
-               }
-                       break;
+
+       case DEVICE_TYPE_TUNEMU: {
+               char dynamic_name[256] = "";
+               device_fd = tunemu_open(dynamic_name);
+       }
+       break;
 #endif
 #ifdef HAVE_NET_IF_UTUN_H
-               case DEVICE_TYPE_UTUN:
-                       return setup_utun();
+
+       case DEVICE_TYPE_UTUN:
+               return setup_utun();
 #endif
-               default:
-                       device_fd = open(device, O_RDWR | O_NONBLOCK);
+
+       default:
+               device_fd = open(device, O_RDWR | O_NONBLOCK);
        }
 
        if(device_fd < 0) {
@@ -204,32 +221,40 @@ static bool setup_device(void) {
        realname = fdevname(device_fd);
 #elif defined(HAVE_DEVNAME)
        struct stat buf;
-       if(!fstat(device_fd, &buf))
+
+       if(!fstat(device_fd, &buf)) {
                realname = devname(buf.st_rdev, S_IFCHR);
+       }
+
 #endif
 
-       if(!realname)
+       if(!realname) {
                realname = device;
+       }
 
-       if(!get_config_string(lookup_config(config_tree, "Interface"), &iface))
+       if(!get_config_string(lookup_config(config_tree, "Interface"), &iface)) {
                iface = xstrdup(strrchr(realname, '/') ? strrchr(realname, '/') + 1 : realname);
-       else if(strcmp(iface, strrchr(realname, '/') ? strrchr(realname, '/') + 1 : realname))
+       } else if(strcmp(iface, strrchr(realname, '/') ? strrchr(realname, '/') + 1 : realname)) {
                logger(LOG_WARNING, "Warning: Interface does not match Device. $INTERFACE might be set incorrectly.");
+       }
 
        // Configure the device as best as we can
 
        switch(device_type) {
-               default:
-                       device_type = DEVICE_TYPE_TUN;
-               case DEVICE_TYPE_TUN:
+       default:
+               device_type = DEVICE_TYPE_TUN;
+
+       case DEVICE_TYPE_TUN:
 #ifdef TUNSIFHEAD
-               {       
+               {
                        const int zero = 0;
+
                        if(ioctl(device_fd, TUNSIFHEAD, &zero, sizeof(zero)) == -1) {
                                logger(LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
                                return false;
                        }
                }
+
 #endif
 #if defined(TUNSIFMODE) && defined(IFF_BROADCAST) && defined(IFF_MULTICAST)
                {
@@ -238,53 +263,66 @@ static bool setup_device(void) {
                }
 #endif
 
-                       device_info = "Generic BSD tun device";
-                       break;
-               case DEVICE_TYPE_TUNIFHEAD:
+               device_info = "Generic BSD tun device";
+               break;
+
+       case DEVICE_TYPE_TUNIFHEAD:
 #ifdef TUNSIFHEAD
                {
                        const int one = 1;
+
                        if(ioctl(device_fd, TUNSIFHEAD, &one, sizeof(one)) == -1) {
                                logger(LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
                                return false;
                        }
                }
+
 #endif
 #if defined(TUNSIFMODE) && defined(IFF_BROADCAST) && defined(IFF_MULTICAST)
                {
-                               const int mode = IFF_BROADCAST | IFF_MULTICAST;
-                               ioctl(device_fd, TUNSIFMODE, &mode, sizeof(mode));
+                       const int mode = IFF_BROADCAST | IFF_MULTICAST;
+                       ioctl(device_fd, TUNSIFMODE, &mode, sizeof(mode));
                }
 #endif
 
-                       device_info = "Generic BSD tun device";
-                       break;
-               case DEVICE_TYPE_TAP:
-                       if(routing_mode == RMODE_ROUTER)
-                               overwrite_mac = true;
-                       device_info = "Generic BSD tap device";
+               device_info = "Generic BSD tun device";
+               break;
+
+       case DEVICE_TYPE_TAP:
+               if(routing_mode == RMODE_ROUTER) {
+                       overwrite_mac = true;
+               }
+
+               device_info = "Generic BSD tap device";
 #ifdef TAPGIFNAME
-                       {
-                               struct ifreq ifr;
-                               if(ioctl(device_fd, TAPGIFNAME, (void*)&ifr) == 0) {
-                                       if(iface)
-                                               free(iface);
-                                       iface = xstrdup(ifr.ifr_name);
+               {
+                       struct ifreq ifr;
+
+                       if(ioctl(device_fd, TAPGIFNAME, (void *)&ifr) == 0) {
+                               if(iface) {
+                                       free(iface);
                                }
+
+                               iface = xstrdup(ifr.ifr_name);
                        }
-                       
+               }
+
 #endif
-                       break;
+               break;
 #ifdef ENABLE_TUNEMU
-               case DEVICE_TYPE_TUNEMU:
-                       device_info = "BSD tunemu device";
-                       break;
+
+       case DEVICE_TYPE_TUNEMU:
+               device_info = "BSD tunemu device";
+               break;
 #endif
        }
 
 #ifdef SIOCGIFADDR
-       if(overwrite_mac)
+
+       if(overwrite_mac) {
                ioctl(device_fd, SIOCGIFADDR, mymac.x);
+       }
+
 #endif
 
        logger(LOG_INFO, "%s is a %s", device, device_info);
@@ -295,12 +333,14 @@ static bool setup_device(void) {
 static void close_device(void) {
        switch(device_type) {
 #ifdef ENABLE_TUNEMU
-               case DEVICE_TYPE_TUNEMU:
-                       tunemu_close(device_fd);
-                       break;
+
+       case DEVICE_TYPE_TUNEMU:
+               tunemu_close(device_fd);
+               break;
 #endif
-               default:
-                       close(device_fd);
+
+       default:
+               close(device_fd);
        }
 
        free(device);
@@ -311,154 +351,165 @@ static bool read_packet(vpn_packet_t *packet) {
        int lenin;
 
        switch(device_type) {
-               case DEVICE_TYPE_TUN:
+       case DEVICE_TYPE_TUN:
 #ifdef ENABLE_TUNEMU
-               case DEVICE_TYPE_TUNEMU:
-                       if(device_type == DEVICE_TYPE_TUNEMU)
-                               lenin = tunemu_read(device_fd, packet->data + 14, MTU - 14);
-                       else
+       case DEVICE_TYPE_TUNEMU:
+               if(device_type == DEVICE_TYPE_TUNEMU) {
+                       lenin = tunemu_read(device_fd, packet->data + 14, MTU - 14);
+               } else
 #endif
-                               lenin = read(device_fd, packet->data + 14, MTU - 14);
+                       lenin = read(device_fd, packet->data + 14, MTU - 14);
 
-                       if(lenin <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
+               if(lenin <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                              device, strerror(errno));
+                       return false;
+               }
 
-                       switch(packet->data[14] >> 4) {
-                               case 4:
-                                       packet->data[12] = 0x08;
-                                       packet->data[13] = 0x00;
-                                       break;
-                               case 6:
-                                       packet->data[12] = 0x86;
-                                       packet->data[13] = 0xDD;
-                                       break;
-                               default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
-                                                          "Unknown IP version %d while reading packet from %s %s",
-                                                          packet->data[14] >> 4, device_info, device);
-                                       return false;
-                       }
+               switch(packet->data[14] >> 4) {
+               case 4:
+                       packet->data[12] = 0x08;
+                       packet->data[13] = 0x00;
+                       break;
 
-                       memset(packet->data, 0, 12);
-                       packet->len = lenin + 14;
+               case 6:
+                       packet->data[12] = 0x86;
+                       packet->data[13] = 0xDD;
                        break;
 
-               case DEVICE_TYPE_UTUN:
-               case DEVICE_TYPE_TUNIFHEAD: {
-                       if((lenin = read(device_fd, packet->data + 10, MTU - 10)) <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
+               default:
+                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                               "Unknown IP version %d while reading packet from %s %s",
+                                               packet->data[14] >> 4, device_info, device);
+                       return false;
+               }
 
-                       switch(packet->data[14] >> 4) {
-                               case 4:
-                                       packet->data[12] = 0x08;
-                                       packet->data[13] = 0x00;
-                                       break;
-                               case 6:
-                                       packet->data[12] = 0x86;
-                                       packet->data[13] = 0xDD;
-                                       break;
-                               default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
-                                                          "Unknown IP version %d while reading packet from %s %s",
-                                                          packet->data[14] >> 4, device_info, device);
-                                       return false;
-                       }
+               memset(packet->data, 0, 12);
+               packet->len = lenin + 14;
+               break;
 
-                       memset(packet->data, 0, 12);
-                       packet->len = lenin + 10;
-                       break;
+       case DEVICE_TYPE_UTUN:
+       case DEVICE_TYPE_TUNIFHEAD: {
+               if((lenin = read(device_fd, packet->data + 10, MTU - 10)) <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                              device, strerror(errno));
+                       return false;
                }
 
-               case DEVICE_TYPE_TAP:
-                       if((lenin = read(device_fd, packet->data, MTU)) <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
+               switch(packet->data[14] >> 4) {
+               case 4:
+                       packet->data[12] = 0x08;
+                       packet->data[13] = 0x00;
+                       break;
 
-                       packet->len = lenin;
+               case 6:
+                       packet->data[12] = 0x86;
+                       packet->data[13] = 0xDD;
                        break;
 
                default:
+                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                               "Unknown IP version %d while reading packet from %s %s",
+                                               packet->data[14] >> 4, device_info, device);
+                       return false;
+               }
+
+               memset(packet->data, 0, 12);
+               packet->len = lenin + 10;
+               break;
+       }
+
+       case DEVICE_TYPE_TAP:
+               if((lenin = read(device_fd, packet->data, MTU)) <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                              device, strerror(errno));
                        return false;
+               }
+
+               packet->len = lenin;
+               break;
+
+       default:
+               return false;
        }
-               
+
        device_total_in += packet->len;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
        return true;
 }
 
 static bool write_packet(vpn_packet_t *packet) {
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
        switch(device_type) {
-               case DEVICE_TYPE_TUN:
-                       if(write(device_fd, packet->data + 14, packet->len - 14) < 0) {
-                               logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
-                       break;
+       case DEVICE_TYPE_TUN:
+               if(write(device_fd, packet->data + 14, packet->len - 14) < 0) {
+                       logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
+                              device, strerror(errno));
+                       return false;
+               }
 
-               case DEVICE_TYPE_UTUN:
-               case DEVICE_TYPE_TUNIFHEAD: {
-                       int af = (packet->data[12] << 8) + packet->data[13];
-                       uint32_t type;
-
-                       switch (af) {
-                               case 0x0800:
-                                       type = htonl(AF_INET);
-                                       break;
-                               case 0x86DD:
-                                       type = htonl(AF_INET6);
-                                       break;
-                               default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
-                                                          "Unknown address family %x while writing packet to %s %s",
-                                                          af, device_info, device);
-                                       return false;
-                       }
+               break;
 
-                       memcpy(packet->data + 10, &type, sizeof(type));
+       case DEVICE_TYPE_UTUN:
+       case DEVICE_TYPE_TUNIFHEAD: {
+               int af = (packet->data[12] << 8) + packet->data[13];
+               uint32_t type;
 
-                       if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
-                               logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
-                                          strerror(errno));
-                               return false;
-                       }
-                       break;
-               }
-                       
-               case DEVICE_TYPE_TAP:
-                       if(write(device_fd, packet->data, packet->len) < 0) {
-                               logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
+               switch(af) {
+               case 0x0800:
+                       type = htonl(AF_INET);
                        break;
 
-#ifdef ENABLE_TUNEMU
-               case DEVICE_TYPE_TUNEMU:
-                       if(tunemu_write(device_fd, packet->data + 14, packet->len - 14) < 0) {
-                               logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
-                                          device, strerror(errno));
-                               return false;
-                       }
+               case 0x86DD:
+                       type = htonl(AF_INET6);
                        break;
-#endif
 
                default:
+                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                               "Unknown address family %x while writing packet to %s %s",
+                                               af, device_info, device);
+                       return false;
+               }
+
+               memcpy(packet->data + 10, &type, sizeof(type));
+
+               if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
+                       logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
+                              strerror(errno));
+                       return false;
+               }
+
+               break;
+       }
+
+       case DEVICE_TYPE_TAP:
+               if(write(device_fd, packet->data, packet->len) < 0) {
+                       logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
+                              device, strerror(errno));
                        return false;
+               }
+
+               break;
+
+#ifdef ENABLE_TUNEMU
+
+       case DEVICE_TYPE_TUNEMU:
+               if(tunemu_write(device_fd, packet->data + 14, packet->len - 14) < 0) {
+                       logger(LOG_ERR, "Error while writing to %s %s: %s", device_info,
+                              device, strerror(errno));
+                       return false;
+               }
+
+               break;
+#endif
+
+       default:
+               return false;
        }
 
        device_total_out += packet->len;
index f532b04..7ff6f72 100644 (file)
@@ -1,20 +1,20 @@
 /*
  *  tunemu - Tun device emulation for Darwin
  *  Copyright (C) 2009 Friedrich Schöller <friedrich.schoeller@gmail.com>
- *  
+ *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
- *  
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
- *  
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *  
+ *
  */
 
 #include "tunemu.h"
 
 #define PPPPROTO_CTL 1
 
-#define PPP_IP         0x21
-#define PPP_IPV6       0x57
+#define PPP_IP          0x21
+#define PPP_IPV6        0x57
 
 #define SC_LOOP_TRAFFIC 0x00000200
 
-#define PPPIOCNEWUNIT  _IOWR('t', 62, int)
-#define        PPPIOCSFLAGS    _IOW('t', 89, int)
-#define PPPIOCSNPMODE  _IOW('t', 75, struct npioctl)
-#define PPPIOCATTCHAN  _IOW('t', 56, int)
-#define PPPIOCGCHAN            _IOR('t', 55, int)
-#define PPPIOCCONNECT  _IOW('t', 58, int)
-#define        PPPIOCGUNIT             _IOR('t', 86, int)
+#define PPPIOCNEWUNIT   _IOWR('t', 62, int)
+#define PPPIOCSFLAGS    _IOW('t', 89, int)
+#define PPPIOCSNPMODE   _IOW('t', 75, struct npioctl)
+#define PPPIOCATTCHAN   _IOW('t', 56, int)
+#define PPPIOCGCHAN             _IOR('t', 55, int)
+#define PPPIOCCONNECT   _IOW('t', 58, int)
+#define PPPIOCGUNIT             _IOR('t', 86, int)
 
-struct sockaddr_ppp
-{
+struct sockaddr_ppp {
        u_int8_t ppp_len;
        u_int8_t ppp_family;
        u_int16_t ppp_proto;
        u_int32_t ppp_cookie;
 };
 
-enum NPmode
-{
+enum NPmode {
        NPMODE_PASS,
-    NPMODE_DROP,
-    NPMODE_ERROR,
-    NPMODE_QUEUE
+       NPMODE_DROP,
+       NPMODE_ERROR,
+       NPMODE_QUEUE
 };
 
-struct npioctl
-{
+struct npioctl {
        int protocol;
        enum NPmode mode;
 };
@@ -83,58 +80,55 @@ static pcap_t *pcap = NULL;
 static int data_buffer_length = 0;
 static char *data_buffer = NULL;
 
-static void tun_error(char *format, ...)
-{
+static void tun_error(char *format, ...) {
        va_list vl;
        va_start(vl, format);
        vsnprintf(tunemu_error, ERROR_BUFFER_SIZE, format, vl);
        va_end(vl);
 }
 
-static void tun_noerror()
-{
+static void tun_noerror() {
        *tunemu_error = 0;
 }
 
-static void closeall()
-{
-    int fd = getdtablesize();
-       while (fd--)
+static void closeall() {
+       int fd = getdtablesize();
+
+       while(fd--) {
                close(fd);
+       }
 
-    open("/dev/null", O_RDWR, 0);
-    dup(0);
-    dup(0);
+       open("/dev/null", O_RDWR, 0);
+       dup(0);
+       dup(0);
 }
 
-static int ppp_load_kext()
-{
+static int ppp_load_kext() {
        int pid = fork();
-       if (pid < 0)
-       {
+
+       if(pid < 0) {
                tun_error("fork for ppp kext: %s", strerror(errno));
                return -1;
        }
 
-       if (pid == 0)
-       {
+       if(pid == 0) {
                closeall();
                execle("/sbin/kextload", "kextload", PPP_KEXT_PATH, NULL, NULL);
                exit(1);
        }
 
        int status;
-       while (waitpid(pid, &status, 0) < 0)
-       {
-               if (errno == EINTR)
+
+       while(waitpid(pid, &status, 0) < 0) {
+               if(errno == EINTR) {
                        continue;
+               }
 
                tun_error("waitpid for ppp kext: %s", strerror(errno));
                return -1;
        }
 
-       if (WEXITSTATUS(status) != 0)
-       {
+       if(WEXITSTATUS(status) != 0) {
                tun_error("could not load ppp kext \"%s\"", PPP_KEXT_PATH);
                return -1;
        }
@@ -143,74 +137,73 @@ static int ppp_load_kext()
        return 0;
 }
 
-static int ppp_new_instance()
-{
+static int ppp_new_instance() {
        // create ppp socket
-    int ppp_sockfd = socket(PF_PPP, SOCK_RAW, PPPPROTO_CTL);
-    if (ppp_sockfd < 0)
-       {
-               if (ppp_load_kext() < 0)
+       int ppp_sockfd = socket(PF_PPP, SOCK_RAW, PPPPROTO_CTL);
+
+       if(ppp_sockfd < 0) {
+               if(ppp_load_kext() < 0) {
                        return -1;
+               }
 
                ppp_sockfd = socket(PF_PPP, SOCK_RAW, PPPPROTO_CTL);
-               if (ppp_sockfd < 0)
-               {
+
+               if(ppp_sockfd < 0) {
                        tun_error("creating ppp socket: %s", strerror(errno));
                        return -1;
                }
        }
 
        // connect to ppp procotol
-    struct sockaddr_ppp pppaddr;
-    pppaddr.ppp_len = sizeof(struct sockaddr_ppp);
-    pppaddr.ppp_family = AF_PPP;
-    pppaddr.ppp_proto = PPPPROTO_CTL;
-    pppaddr.ppp_cookie = 0;
-    if (connect(ppp_sockfd, (struct sockaddr *)&pppaddr, sizeof(struct sockaddr_ppp)) < 0)
-       {
+       struct sockaddr_ppp pppaddr;
+       pppaddr.ppp_len = sizeof(struct sockaddr_ppp);
+       pppaddr.ppp_family = AF_PPP;
+       pppaddr.ppp_proto = PPPPROTO_CTL;
+       pppaddr.ppp_cookie = 0;
+
+       if(connect(ppp_sockfd, (struct sockaddr *)&pppaddr, sizeof(struct sockaddr_ppp)) < 0) {
                tun_error("connecting ppp socket: %s", strerror(errno));
                close(ppp_sockfd);
                return -1;
-    }
+       }
 
        tun_noerror();
        return ppp_sockfd;
 }
 
-static int ppp_new_unit(int *unit_number)
-{
+static int ppp_new_unit(int *unit_number) {
        int fd = ppp_new_instance();
-       if (fd < 0)
+
+       if(fd < 0) {
                return -1;
+       }
 
        // create ppp unit
-       if (ioctl(fd, PPPIOCNEWUNIT, unit_number) < 0)
-       {
+       if(ioctl(fd, PPPIOCNEWUNIT, unit_number) < 0) {
                tun_error("creating ppp unit: %s", strerror(errno));
                close(fd);
                return -1;
-    }
+       }
 
        tun_noerror();
        return fd;
 }
 
-static int ppp_setup_unit(int unit_fd)
-{
+static int ppp_setup_unit(int unit_fd) {
        // send traffic to program
        int flags = SC_LOOP_TRAFFIC;
-       if (ioctl(unit_fd, PPPIOCSFLAGS, &flags) < 0)
-       {
+
+       if(ioctl(unit_fd, PPPIOCSFLAGS, &flags) < 0) {
                tun_error("setting ppp loopback mode: %s", strerror(errno));
                return -1;
-    }
+       }
 
        // allow packets
        struct npioctl npi;
        npi.protocol = PPP_IP;
        npi.mode = NPMODE_PASS;
-       if (ioctl(unit_fd, PPPIOCSNPMODE, &npi) < 0)
-       {
+
+       if(ioctl(unit_fd, PPPIOCSNPMODE, &npi) < 0) {
                tun_error("starting ppp unit: %s", strerror(errno));
                return -1;
        }
@@ -219,10 +212,8 @@ static int ppp_setup_unit(int unit_fd)
        return 0;
 }
 
-static int open_pcap()
-{
-       if (pcap != NULL)
-       {
+static int open_pcap() {
+       if(pcap != NULL) {
                pcap_use_count++;
                return 0;
        }
@@ -231,8 +222,7 @@ static int open_pcap()
        pcap = pcap_open_live("lo0", BUFSIZ, 0, 1, errbuf);
        pcap_use_count = 1;
 
-       if (pcap == NULL)
-       {
+       if(pcap == NULL) {
                tun_error("opening pcap: %s", errbuf);
                return -1;
        }
@@ -241,59 +231,57 @@ static int open_pcap()
        return 0;
 }
 
-static void close_pcap()
-{
-       if (pcap == NULL)
+static void close_pcap() {
+       if(pcap == NULL) {
                return;
+       }
 
        pcap_use_count--;
-       if (pcap_use_count == 0)
-       {
+
+       if(pcap_use_count == 0) {
                pcap_close(pcap);
                pcap = NULL;
        }
 }
 
-static void allocate_data_buffer(int size)
-{
-       if (data_buffer_length < size)
-       {
+static void allocate_data_buffer(int size) {
+       if(data_buffer_length < size) {
                free(data_buffer);
                data_buffer_length = size;
                data_buffer = malloc(data_buffer_length);
        }
 }
 
-static void make_device_name(tunemu_device device, int unit_number)
-{
+static void make_device_name(tunemu_device device, int unit_number) {
        snprintf(device, sizeof(tunemu_device), "ppp%d", unit_number);
 }
 
-static int check_device_name(tunemu_device device)
-{
-       if (strlen(device) < 4)
+static int check_device_name(tunemu_device device) {
+       if(strlen(device) < 4) {
                return -1;
+       }
 
        int unit_number = atoi(device + 3);
-       if (unit_number < 0 || unit_number > 999)
+
+       if(unit_number < 0 || unit_number > 999) {
                return -1;
+       }
 
        tunemu_device compare;
        make_device_name(compare, unit_number);
 
-       if (strcmp(device, compare) != 0)
+       if(strcmp(device, compare) != 0) {
                return -1;
+       }
 
        return 0;
 }
 
-int tunemu_open(tunemu_device device)
-{
+int tunemu_open(tunemu_device device) {
        int ppp_unit_number = -1;
-       if (device[0] != 0)
-       {
-               if (check_device_name(device) < 0)
-               {
+
+       if(device[0] != 0) {
+               if(check_device_name(device) < 0) {
                        tun_error("invalid device name \"%s\"", device);
                        return -1;
                }
@@ -302,17 +290,17 @@ int tunemu_open(tunemu_device device)
        }
 
        int ppp_unit_fd = ppp_new_unit(&ppp_unit_number);
-       if (ppp_unit_fd < 0)
+
+       if(ppp_unit_fd < 0) {
                return -1;
+       }
 
-       if (ppp_setup_unit(ppp_unit_fd) < 0)
-       {
+       if(ppp_setup_unit(ppp_unit_fd) < 0) {
                close(ppp_unit_fd);
                return -1;
        }
 
-       if (open_pcap() < 0)
-       {
+       if(open_pcap() < 0) {
                close(ppp_unit_fd);
                return -1;
        }
@@ -322,39 +310,40 @@ int tunemu_open(tunemu_device device)
        return ppp_unit_fd;
 }
 
-int tunemu_close(int ppp_sockfd)
-{
+int tunemu_close(int ppp_sockfd) {
        int ret = close(ppp_sockfd);
 
-       if (ret == 0)
+       if(ret == 0) {
                close_pcap();
+       }
 
        return ret;
 }
 
-int tunemu_read(int ppp_sockfd, char *buffer, int length)
-{
+int tunemu_read(int ppp_sockfd, char *buffer, int length) {
        allocate_data_buffer(length + 2);
 
        length = read(ppp_sockfd, data_buffer, length + 2);
-       if (length < 0)
-       {
+
+       if(length < 0) {
                tun_error("reading packet: %s", strerror(errno));
                return length;
        }
+
        tun_noerror();
 
        length -= 2;
-       if (length < 0)
+
+       if(length < 0) {
                return 0;
+       }
 
        memcpy(buffer, data_buffer + 2, length);
 
        return length;
 }
 
-int tunemu_write(int ppp_sockfd, char *buffer, int length)
-{
+int tunemu_write(int ppp_sockfd, char *buffer, int length) {
        allocate_data_buffer(length + 4);
 
        data_buffer[0] = 0x02;
@@ -364,23 +353,25 @@ int tunemu_write(int ppp_sockfd, char *buffer, int length)
 
        memcpy(data_buffer + 4, buffer, length);
 
-       if (pcap == NULL)
-       {
+       if(pcap == NULL) {
                tun_error("pcap not open");
                return -1;
        }
 
        length = pcap_inject(pcap, data_buffer, length + 4);
-       if (length < 0)
-       {
+
+       if(length < 0) {
                tun_error("injecting packet: %s", pcap_geterr(pcap));
                return length;
        }
+
        tun_noerror();
 
        length -= 4;
-       if (length < 0)
+
+       if(length < 0) {
                return 0;
+       }
 
        return length;
 }
index 42b1785..e0452a8 100644 (file)
@@ -1,20 +1,20 @@
 /*
  *  tunemu - Tun device emulation for Darwin
  *  Copyright (C) 2009 Friedrich Schöller <friedrich.schoeller@gmail.com>
- *  
+ *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
- *  
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
- *  
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *  
+ *
  */
 
 #ifndef TUNEMU_H
index 82bc521..3289c58 100644 (file)
@@ -4,7 +4,7 @@
                   1998-2005 Ivo Timmermans
                   2000-2014 Guus Sliepen <guus@tinc-vpn.org>
                   2010-2011 Julien Muchembled <jm@jmuchemb.eu>
-                 2000 Cris van Pelt
+                  2000 Cris van Pelt
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 #include "conf.h"
 #include "list.h"
 #include "logger.h"
-#include "netutl.h"                            /* for str2address */
+#include "netutl.h"                             /* for str2address */
 #include "protocol.h"
-#include "utils.h"                             /* for cp */
+#include "utils.h"                              /* for cp */
 #include "xalloc.h"
 
 avl_tree_t *config_tree;
 
-int pinginterval = 0;                  /* seconds between pings */
-int pingtimeout = 0;                   /* seconds to wait for response */
-char *confbase = NULL;                 /* directory in which all config files are */
-char *netname = NULL;                  /* name of the vpn network */
-list_t *cmdline_conf = NULL;   /* global/host configuration values given at the command line */
+int pinginterval = 0;                   /* seconds between pings */
+int pingtimeout = 0;                    /* seconds to wait for response */
+char *confbase = NULL;                  /* directory in which all config files are */
+char *netname = NULL;                   /* name of the vpn network */
+list_t *cmdline_conf = NULL;    /* global/host configuration values given at the command line */
 
 
 static int config_compare(const config_t *a, const config_t *b) {
@@ -47,27 +47,31 @@ static int config_compare(const config_t *a, const config_t *b) {
 
        result = strcasecmp(a->variable, b->variable);
 
-       if(result)
+       if(result) {
                return result;
+       }
 
        /* give priority to command line options */
        result = !b->file - !a->file;
-       if (result)
+
+       if(result) {
                return result;
+       }
 
        result = a->line - b->line;
 
-       if(result)
+       if(result) {
                return result;
-       else
+       } else {
                return a->file ? strcmp(a->file, b->file) : 0;
+       }
 }
 
-void init_configuration(avl_tree_t ** config_tree) {
+void init_configuration(avl_tree_t **config_tree) {
        *config_tree = avl_alloc_tree((avl_compare_t) config_compare, (avl_action_t) free_config);
 }
 
-void exit_configuration(avl_tree_t ** config_tree) {
+void exit_configuration(avl_tree_t **config_tree) {
        avl_delete_tree(*config_tree);
        *config_tree = NULL;
 }
@@ -77,14 +81,17 @@ config_t *new_config(void) {
 }
 
 void free_config(config_t *cfg) {
-       if(cfg->variable)
+       if(cfg->variable) {
                free(cfg->variable);
+       }
 
-       if(cfg->value)
+       if(cfg->value) {
                free(cfg->value);
+       }
 
-       if(cfg->file)
+       if(cfg->file) {
                free(cfg->file);
+       }
 
        free(cfg);
 }
@@ -102,11 +109,13 @@ config_t *lookup_config(const avl_tree_t *config_tree, char *variable) {
 
        found = avl_search_closest_greater(config_tree, &cfg);
 
-       if(!found)
+       if(!found) {
                return NULL;
+       }
 
-       if(strcasecmp(found->variable, variable))
+       if(strcasecmp(found->variable, variable)) {
                return NULL;
+       }
 
        return found;
 }
@@ -121,8 +130,9 @@ config_t *lookup_config_next(const avl_tree_t *config_tree, const config_t *cfg)
                if(node->next) {
                        found = node->next->data;
 
-                       if(!strcasecmp(found->variable, cfg->variable))
+                       if(!strcasecmp(found->variable, cfg->variable)) {
                                return found;
+                       }
                }
        }
 
@@ -130,8 +140,9 @@ config_t *lookup_config_next(const avl_tree_t *config_tree, const config_t *cfg)
 }
 
 bool get_config_bool(const config_t *cfg, bool *result) {
-       if(!cfg)
+       if(!cfg) {
                return false;
+       }
 
        if(!strcasecmp(cfg->value, "yes")) {
                *result = true;
@@ -142,27 +153,30 @@ bool get_config_bool(const config_t *cfg, bool *result) {
        }
 
        logger(LOG_ERR, "\"yes\" or \"no\" expected for configuration variable %s in %s line %d",
-                  cfg->variable, cfg->file, cfg->line);
+              cfg->variable, cfg->file, cfg->line);
 
        return false;
 }
 
 bool get_config_int(const config_t *cfg, int *result) {
-       if(!cfg)
+       if(!cfg) {
                return false;
+       }
 
-       if(sscanf(cfg->value, "%d", result) == 1)
+       if(sscanf(cfg->value, "%d", result) == 1) {
                return true;
+       }
 
        logger(LOG_ERR, "Integer expected for configuration variable %s in %s line %d",
-                  cfg->variable, cfg->file, cfg->line);
+              cfg->variable, cfg->file, cfg->line);
 
        return false;
 }
 
 bool get_config_string(const config_t *cfg, char **result) {
-       if(!cfg)
+       if(!cfg) {
                return false;
+       }
 
        *result = xstrdup(cfg->value);
 
@@ -172,8 +186,9 @@ bool get_config_string(const config_t *cfg, char **result) {
 bool get_config_address(const config_t *cfg, struct addrinfo **result) {
        struct addrinfo *ai;
 
-       if(!cfg)
+       if(!cfg) {
                return false;
+       }
 
        ai = str2addrinfo(cfg->value, NULL, 0);
 
@@ -183,31 +198,32 @@ bool get_config_address(const config_t *cfg, struct addrinfo **result) {
        }
 
        logger(LOG_ERR, "Hostname or IP address expected for configuration variable %s in %s line %d",
-                  cfg->variable, cfg->file, cfg->line);
+              cfg->variable, cfg->file, cfg->line);
 
        return false;
 }
 
-bool get_config_subnet(const config_t *cfg, subnet_t ** result) {
+bool get_config_subnet(const config_t *cfg, subnet_t **result) {
        subnet_t subnet = {NULL};
 
-       if(!cfg)
+       if(!cfg) {
                return false;
+       }
 
        if(!str2net(&subnet, cfg->value)) {
                logger(LOG_ERR, "Subnet expected for configuration variable %s in %s line %d",
-                          cfg->variable, cfg->file, cfg->line);
+                      cfg->variable, cfg->file, cfg->line);
                return false;
        }
 
        /* Teach newbies what subnets are... */
 
        if(((subnet.type == SUBNET_IPV4)
-               && !maskcheck(&subnet.net.ipv4.address, subnet.net.ipv4.prefixlength, sizeof(ipv4_t)))
-               || ((subnet.type == SUBNET_IPV6)
-               && !maskcheck(&subnet.net.ipv6.address, subnet.net.ipv6.prefixlength, sizeof(ipv6_t)))) {
+                       && !maskcheck(&subnet.net.ipv4.address, subnet.net.ipv4.prefixlength, sizeof(ipv4_t)))
+                       || ((subnet.type == SUBNET_IPV6)
+                           && !maskcheck(&subnet.net.ipv6.address, subnet.net.ipv6.prefixlength, sizeof(ipv6_t)))) {
                logger(LOG_ERR, "Network address and prefix length do not match for configuration variable %s in %s line %d",
-                          cfg->variable, cfg->file, cfg->line);
+                      cfg->variable, cfg->file, cfg->line);
                return false;
        }
 
@@ -219,26 +235,31 @@ bool get_config_subnet(const config_t *cfg, subnet_t ** result) {
 /*
   Read exactly one line and strip the trailing newline if any.
 */
-static char *readline(FILE * fp, char *buf, size_t buflen) {
+static char *readline(FILE *fp, char *buf, size_t buflen) {
        char *newline = NULL;
        char *p;
 
-       if(feof(fp))
+       if(feof(fp)) {
                return NULL;
+       }
 
        p = fgets(buf, buflen, fp);
 
-       if(!p)
+       if(!p) {
                return NULL;
+       }
 
        newline = strchr(p, '\n');
 
-       if(!newline)
+       if(!newline) {
                return buf;
+       }
+
+       *newline = '\0';        /* kill newline */
 
-       *newline = '\0';        /* kill newline */
-       if(newline > p && newline[-1] == '\r')  /* and carriage return if necessary */
+       if(newline > p && newline[-1] == '\r') { /* and carriage return if necessary */
                newline[-1] = '\0';
+       }
 
        return buf;
 }
@@ -250,26 +271,32 @@ config_t *parse_config_line(char *line, const char *fname, int lineno) {
        variable = value = line;
 
        eol = line + strlen(line);
-       while(strchr("\t ", *--eol))
+
+       while(strchr("\t ", *--eol)) {
                *eol = '\0';
+       }
 
        len = strcspn(value, "\t =");
        value += len;
        value += strspn(value, "\t ");
+
        if(*value == '=') {
                value++;
                value += strspn(value, "\t ");
        }
+
        variable[len] = '\0';
 
        if(!*value) {
                const char err[] = "No value for variable";
-               if (fname)
+
+               if(fname)
                        logger(LOG_ERR, "%s `%s' on line %d while reading config file %s",
-                               err, variable, lineno, fname);
+                              err, variable, lineno, fname);
                else
                        logger(LOG_ERR, "%s `%s' in command line option %d",
-                               err, variable, lineno);
+                              err, variable, lineno);
+
                return NULL;
        }
 
@@ -306,30 +333,38 @@ bool read_config_file(avl_tree_t *config_tree, const char *fname) {
                line = readline(fp, buffer, sizeof(buffer));
 
                if(!line) {
-                       if(feof(fp))
+                       if(feof(fp)) {
                                result = true;
+                       }
+
                        break;
                }
 
                lineno++;
 
-               if(!*line || *line == '#')
+               if(!*line || *line == '#') {
                        continue;
+               }
 
                if(ignore) {
-                       if(!strncmp(line, "-----END", 8))
+                       if(!strncmp(line, "-----END", 8)) {
                                ignore = false;
+                       }
+
                        continue;
                }
-               
+
                if(!strncmp(line, "-----BEGIN", 10)) {
                        ignore = true;
                        continue;
                }
 
                cfg = parse_config_line(line, fname, lineno);
-               if (!cfg)
+
+               if(!cfg) {
                        break;
+               }
+
                config_add(config_tree, cfg);
        }
 
@@ -345,12 +380,14 @@ void read_config_options(avl_tree_t *config_tree, const char *prefix) {
                const config_t *cfg = node->data;
 
                if(!prefix) {
-                       if(strchr(cfg->variable, '.'))
+                       if(strchr(cfg->variable, '.')) {
                                continue;
+                       }
                } else {
                        if(strncmp(prefix, cfg->variable, prefix_len) ||
-                          cfg->variable[prefix_len] != '.')
+                                       cfg->variable[prefix_len] != '.') {
                                continue;
+                       }
                }
 
                config_t *new = new_config();
@@ -380,23 +417,27 @@ bool read_server_config(void) {
        x = read_config_file(config_tree, fname);
 
        // We will try to read the conf files in the "conf.d" dir
-       if (x) {
+       if(x) {
                char dname[PATH_MAX];
                snprintf(dname, sizeof(dname), "%s/conf.d", confbase);
-               DIR *dir = opendir (dname);
+               DIR *dir = opendir(dname);
+
                // If we can find this dir
-               if (dir) { 
+               if(dir) {
                        struct dirent *ep;
+
                        // We list all the files in it
-                       while (x && (ep = readdir (dir))) {
+                       while(x && (ep = readdir(dir))) {
                                size_t l = strlen(ep->d_name);
+
                                // And we try to read the ones that end with ".conf"
-                               if (l > 5 && !strcmp(".conf", & ep->d_name[ l - 5 ])) {
+                               if(l > 5 && !strcmp(".conf", & ep->d_name[ l - 5 ])) {
                                        snprintf(fname, sizeof(fname), "%s/%s", dname, ep->d_name);
                                        x = read_config_file(config_tree, fname);
                                }
                        }
-                       closedir (dir);
+
+                       closedir(dir);
                }
        }
 
@@ -426,34 +467,38 @@ static void disable_old_keys(const char *filename) {
        FILE *r, *w;
 
        r = fopen(filename, "r");
-       if(!r)
+
+       if(!r) {
                return;
+       }
 
        snprintf(tmpfile, sizeof(tmpfile), "%s.tmp", filename);
 
        w = fopen(tmpfile, "w");
 
        while(fgets(buf, sizeof(buf), r)) {
-               if(!strncmp(buf, "-----BEGIN RSA", 14)) {       
+               if(!strncmp(buf, "-----BEGIN RSA", 14)) {
                        buf[11] = 'O';
                        buf[12] = 'L';
                        buf[13] = 'D';
                        disabled = true;
-               }
-               else if(!strncmp(buf, "-----END RSA", 12)) {    
+               } else if(!strncmp(buf, "-----END RSA", 12)) {
                        buf[ 9] = 'O';
                        buf[10] = 'L';
                        buf[11] = 'D';
                        disabled = true;
                }
+
                if(w && fputs(buf, w) < 0) {
                        disabled = false;
                        break;
                }
        }
 
-       if(w)
+       if(w) {
                fclose(w);
+       }
+
        fclose(r);
 
        if(!w && disabled) {
@@ -466,9 +511,11 @@ static void disable_old_keys(const char *filename) {
                // We cannot atomically replace files on Windows.
                char bakfile[PATH_MAX] = "";
                snprintf(bakfile, sizeof(bakfile), "%s.bak", filename);
+
                if(rename(filename, bakfile) || rename(tmpfile, filename)) {
                        rename(bakfile, filename);
 #else
+
                if(rename(tmpfile, filename)) {
 #endif
                        fprintf(stderr, "Warning: old key(s) found, remove them by hand!\n");
@@ -499,25 +546,29 @@ FILE *ask_and_open(const char *filename, const char *what) {
        } else {
                /* Ask for a file and/or directory name. */
                fprintf(stdout, "Please enter a file to save %s to [%s]: ",
-                               what, filename);
+                       what, filename);
                fflush(stdout);
 
                fn = readline(stdin, line, sizeof(line));
 
                if(!fn) {
                        fprintf(stderr, "Error while reading stdin: %s\n",
-                                       strerror(errno));
+                               strerror(errno));
                        return NULL;
                }
 
                if(!strlen(fn))
                        /* User just pressed enter. */
+               {
                        fn = filename;
+               }
        }
 
 #ifdef HAVE_MINGW
+
        if(fn[0] != '\\' && fn[0] != '/' && !strchr(fn, ':')) {
 #else
+
        if(fn[0] != '/') {
 #endif
                /* The directory is a relative path or a filename. */
@@ -526,7 +577,7 @@ FILE *ask_and_open(const char *filename, const char *what) {
                fn = abspath;
        }
 
-       umask(0077);                            /* Disallow everything for group and other */
+       umask(0077);                            /* Disallow everything for group and other */
 
        disable_old_keys(fn);
 
@@ -536,7 +587,7 @@ FILE *ask_and_open(const char *filename, const char *what) {
 
        if(!r) {
                fprintf(stderr, "Error opening file `%s': %s\n",
-                               fn, strerror(errno));
+                       fn, strerror(errno));
                return NULL;
        }
 
index 1be18c3..cef5d77 100644 (file)
@@ -46,7 +46,7 @@ extern list_t *cmdline_conf;
 
 extern void init_configuration(avl_tree_t **);
 extern void exit_configuration(avl_tree_t **);
-extern config_t *new_config(void) __attribute__ ((__malloc__));
+extern config_t *new_config(void) __attribute__((__malloc__));
 extern void free_config(config_t *);
 extern void config_add(avl_tree_t *, config_t *);
 extern config_t *lookup_config(const avl_tree_t *, char *);
index 46b11c8..38b3ccf 100644 (file)
@@ -28,7 +28,7 @@
 #include "utils.h"
 #include "xalloc.h"
 
-avl_tree_t *connection_tree;   /* Meta connections */
+avl_tree_t *connection_tree;    /* Meta connections */
 connection_t *everyone;
 
 static int connection_compare(const connection_t *a, const connection_t *b) {
@@ -52,8 +52,9 @@ connection_t *new_connection(void) {
 
        c = xmalloc_and_zero(sizeof(connection_t));
 
-       if(!c)
+       if(!c) {
                return NULL;
+       }
 
        gettimeofday(&c->start, NULL);
 
@@ -118,8 +119,9 @@ void free_connection(connection_t *c) {
        free(c->name);
        free(c->hostname);
 
-       if(c->config_tree)
+       if(c->config_tree) {
                exit_configuration(&c->config_tree);
+       }
 
        free(c);
 }
@@ -141,8 +143,8 @@ void dump_connections(void) {
        for(node = connection_tree->head; node; node = node->next) {
                c = node->data;
                logger(LOG_DEBUG, " %s at %s options %x socket %d status %04x outbuf %d/%d/%d",
-                          c->name, c->hostname, c->options, c->socket, bitfield_to_int(&c->status, sizeof(c->status)),
-                          c->outbufsize, c->outbufstart, c->outbuflen);
+                      c->name, c->hostname, c->options, c->socket, bitfield_to_int(&c->status, sizeof(c->status)),
+                      c->outbufsize, c->outbufstart, c->outbuflen);
        }
 
        logger(LOG_DEBUG, "End of connections.");
index 206d520..1cc9818 100644 (file)
 
 #include "avl_tree.h"
 
-#define OPTION_INDIRECT                0x0001
-#define OPTION_TCPONLY         0x0002
-#define OPTION_PMTU_DISCOVERY  0x0004
-#define OPTION_CLAMP_MSS       0x0008
+#define OPTION_INDIRECT         0x0001
+#define OPTION_TCPONLY          0x0002
+#define OPTION_PMTU_DISCOVERY   0x0004
+#define OPTION_CLAMP_MSS        0x0008
 
 typedef struct connection_status_t {
-       unsigned int pinged:1;                          /* sent ping */
-       unsigned int active:1;                          /* 1 if active.. */
-       unsigned int connecting:1;                      /* 1 if we are waiting for a non-blocking connect() to finish */
-       unsigned int unused_termreq:1;                  /* the termination of this connection was requested */
-       unsigned int remove:1;                          /* Set to 1 if you want this connection removed */
-       unsigned int timeout:1;                         /* 1 if gotten timeout */
-       unsigned int encryptout:1;                      /* 1 if we can encrypt outgoing traffic */
-       unsigned int decryptin:1;                       /* 1 if we have to decrypt incoming traffic */
-       unsigned int mst:1;                             /* 1 if this connection is part of a minimum spanning tree */
-       unsigned int proxy_passed:1;                    /* 1 if we are connecting via a proxy and we have finished talking with it */
-       unsigned int unused:22;
+       unsigned int pinged: 1;                         /* sent ping */
+       unsigned int active: 1;                         /* 1 if active.. */
+       unsigned int connecting: 1;                     /* 1 if we are waiting for a non-blocking connect() to finish */
+       unsigned int unused_termreq: 1;                 /* the termination of this connection was requested */
+       unsigned int remove: 1;                         /* Set to 1 if you want this connection removed */
+       unsigned int timeout: 1;                        /* 1 if gotten timeout */
+       unsigned int encryptout: 1;                     /* 1 if we can encrypt outgoing traffic */
+       unsigned int decryptin: 1;                      /* 1 if we have to decrypt incoming traffic */
+       unsigned int mst: 1;                            /* 1 if this connection is part of a minimum spanning tree */
+       unsigned int proxy_passed: 1;                   /* 1 if we are connecting via a proxy and we have finished talking with it */
+       unsigned int unused: 22;
 } connection_status_t;
 
 #include "edge.h"
@@ -50,57 +50,57 @@ typedef struct connection_status_t {
 #include "node.h"
 
 typedef struct connection_t {
-       char *name;                                     /* name he claims to have */
-
-       union sockaddr_t address;                       /* his real (internet) ip */
-       char *hostname;                         /* the hostname of its real ip */
-       int protocol_version;           /* used protocol */
-
-       int socket;                                     /* socket used for this connection */
-       uint32_t options;                       /* options for this connection */
-       connection_status_t status;     /* status info */
-       int estimated_weight;           /* estimation for the weight of the edge for this connection */
-       struct timeval start;           /* time this connection was started, used for above estimation */
-       struct outgoing_t *outgoing;    /* used to keep track of outgoing connections */
-
-       struct node_t *node;            /* node associated with the other end */
-       struct edge_t *edge;            /* edge associated with this connection */
-
-       RSA *rsa_key;                           /* his public/private key */
-       const EVP_CIPHER *incipher;     /* Cipher he will use to send data to us */
-       const EVP_CIPHER *outcipher;    /* Cipher we will use to send data to him */
-       EVP_CIPHER_CTX *inctx;          /* Context of encrypted meta data that will come from him to us */
-       EVP_CIPHER_CTX *outctx;         /* Context of encrypted meta data that will be sent from us to him */
+       char *name;                                     /* name he claims to have */
+
+       union sockaddr_t address;                       /* his real (internet) ip */
+       char *hostname;                         /* the hostname of its real ip */
+       int protocol_version;           /* used protocol */
+
+       int socket;                                     /* socket used for this connection */
+       uint32_t options;                       /* options for this connection */
+       connection_status_t status;     /* status info */
+       int estimated_weight;           /* estimation for the weight of the edge for this connection */
+       struct timeval start;           /* time this connection was started, used for above estimation */
+       struct outgoing_t *outgoing;    /* used to keep track of outgoing connections */
+
+       struct node_t *node;            /* node associated with the other end */
+       struct edge_t *edge;            /* edge associated with this connection */
+
+       RSA *rsa_key;                           /* his public/private key */
+       const EVP_CIPHER *incipher;     /* Cipher he will use to send data to us */
+       const EVP_CIPHER *outcipher;    /* Cipher we will use to send data to him */
+       EVP_CIPHER_CTX *inctx;          /* Context of encrypted meta data that will come from him to us */
+       EVP_CIPHER_CTX *outctx;         /* Context of encrypted meta data that will be sent from us to him */
        uint64_t inbudget;              /* Encrypted bytes send budget */
        uint64_t outbudget;             /* Encrypted bytes receive budget */
-       char *inkey;                            /* His symmetric meta key + iv */
-       char *outkey;                           /* Our symmetric meta key + iv */
-       int inkeylength;                        /* Length of his key + iv */
-       int outkeylength;                       /* Length of our key + iv */
+       char *inkey;                            /* His symmetric meta key + iv */
+       char *outkey;                           /* Our symmetric meta key + iv */
+       int inkeylength;                        /* Length of his key + iv */
+       int outkeylength;                       /* Length of our key + iv */
        const EVP_MD *indigest;
        const EVP_MD *outdigest;
        int inmaclength;
        int outmaclength;
        int incompression;
        int outcompression;
-       char *mychallenge;                      /* challenge we received from him */
-       char *hischallenge;                     /* challenge we sent to him */
+       char *mychallenge;                      /* challenge we received from him */
+       char *hischallenge;                     /* challenge we sent to him */
 
-       char buffer[MAXBUFSIZE];        /* metadata input buffer */
-       int buflen;                                     /* bytes read into buffer */
-       int reqlen;                                     /* length of incoming request */
-       int tcplen;                                     /* length of incoming TCPpacket */
-       int allow_request;                      /* defined if there's only one request possible */
+       char buffer[MAXBUFSIZE];        /* metadata input buffer */
+       int buflen;                                     /* bytes read into buffer */
+       int reqlen;                                     /* length of incoming request */
+       int tcplen;                                     /* length of incoming TCPpacket */
+       int allow_request;                      /* defined if there's only one request possible */
 
-       char *outbuf;                           /* metadata output buffer */
-       int outbufstart;                        /* index of first meaningful byte in output buffer */
-       int outbuflen;                          /* number of meaningful bytes in output buffer */
-       int outbufsize;                         /* number of bytes allocated to output buffer */
+       char *outbuf;                           /* metadata output buffer */
+       int outbufstart;                        /* index of first meaningful byte in output buffer */
+       int outbuflen;                          /* number of meaningful bytes in output buffer */
+       int outbufsize;                         /* number of bytes allocated to output buffer */
 
-       time_t last_ping_time;          /* last time we saw some activity from the other end or pinged them */
-       time_t last_flushed_time;       /* last time buffer was empty. Only meaningful if outbuflen > 0 */
+       time_t last_ping_time;          /* last time we saw some activity from the other end or pinged them */
+       time_t last_flushed_time;       /* last time buffer was empty. Only meaningful if outbuflen > 0 */
 
-       avl_tree_t *config_tree;        /* Pointer to configuration tree belonging to him */
+       avl_tree_t *config_tree;        /* Pointer to configuration tree belonging to him */
 } connection_t;
 
 extern avl_tree_t *connection_tree;
@@ -108,7 +108,7 @@ extern connection_t *everyone;
 
 extern void init_connections(void);
 extern void exit_connections(void);
-extern connection_t *new_connection(void) __attribute__ ((__malloc__));
+extern connection_t *new_connection(void) __attribute__((__malloc__));
 extern void free_connection(connection_t *);
 extern void free_connection_partially(connection_t *);
 extern void connection_add(connection_t *);
index 9fce9be..3a242bf 100644 (file)
@@ -61,8 +61,9 @@ static bool setup_device(void) {
        get_config_string(lookup_config(config_tree, "Device"), &device);
        get_config_string(lookup_config(config_tree, "Interface"), &iface);
 
-       if(device && iface)
+       if(device && iface) {
                logger(LOG_WARNING, "Warning: both Device and Interface specified, results may not be as expected");
+       }
 
        /* Open registry and look for network adapters */
 
@@ -71,44 +72,51 @@ static bool setup_device(void) {
                return false;
        }
 
-       for (i = 0; ; i++) {
+       for(i = 0; ; i++) {
                len = sizeof(adapterid);
-               if(RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL))
+
+               if(RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL)) {
                        break;
+               }
 
                /* Find out more about this adapter */
 
                snprintf(regpath, sizeof(regpath), "%s\\%s\\Connection", NETWORK_CONNECTIONS_KEY, adapterid);
 
-                if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regpath, 0, KEY_READ, &key2))
+               if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regpath, 0, KEY_READ, &key2)) {
                        continue;
+               }
 
                len = sizeof(adaptername);
                err = RegQueryValueEx(key2, "Name", 0, 0, adaptername, &len);
 
                RegCloseKey(key2);
 
-               if(err)
+               if(err) {
                        continue;
+               }
 
                if(device) {
                        if(!strcmp(device, adapterid)) {
                                found = true;
                                break;
-                       } else
+                       } else {
                                continue;
+                       }
                }
 
                if(iface) {
                        if(!strcmp(iface, adaptername)) {
                                found = true;
                                break;
-                       } else
+                       } else {
                                continue;
+                       }
                }
 
                snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, adapterid);
                device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, 0);
+
                if(device_handle != INVALID_HANDLE_VALUE) {
                        CloseHandle(device_handle);
                        found = true;
@@ -123,14 +131,16 @@ static bool setup_device(void) {
                return false;
        }
 
-       if(!device)
+       if(!device) {
                device = xstrdup(adapterid);
+       }
 
-       if(!iface)
+       if(!iface) {
                iface = xstrdup(adaptername);
+       }
 
        snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, device);
-       
+
        /* Now we are going to open this device twice: once for reading and once for writing.
           We do this because apparently it isn't possible to check for activity in the select() loop.
           Furthermore I don't really know how to do it the "Windows" way. */
@@ -141,9 +151,9 @@ static bool setup_device(void) {
        }
 
        /* The parent opens the tap device for writing. */
-       
-       device_handle = CreateFile(tapname, GENERIC_WRITE,  FILE_SHARE_READ,  0,  OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM , 0);
-       
+
+       device_handle = CreateFile(tapname, GENERIC_WRITE,  FILE_SHARE_READ,  0,  OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, 0);
+
        if(device_handle == INVALID_HANDLE_VALUE) {
                logger(LOG_ERR, "Could not open Windows tap device %s (%s) for writing: %s", device, iface, winerror(GetLastError()));
                return false;
@@ -174,7 +184,7 @@ static bool setup_device(void) {
        if(!reader_pid) {
                /* The child opens the tap device for reading, blocking.
                   It passes everything it reads to the socket. */
-       
+
                char buf[MTU];
                long lenin;
 
@@ -205,6 +215,7 @@ static bool setup_device(void) {
        }
 
        read(device_fd, &gelukt, 1);
+
        if(gelukt != 1) {
                logger(LOG_DEBUG, "Tap reader failed!");
                return false;
@@ -233,16 +244,16 @@ static bool read_packet(vpn_packet_t *packet) {
 
        if((lenin = read(sp[0], packet->data, MTU)) <= 0) {
                logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                          device, strerror(errno));
+                      device, strerror(errno));
                return false;
        }
-       
+
        packet->len = lenin;
 
        device_total_in += packet->len;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
-                          device_info);
+                               device_info);
 
        return true;
 }
@@ -251,9 +262,9 @@ static bool write_packet(vpn_packet_t *packet) {
        long lenout;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
-       if(!WriteFile (device_handle, packet->data, packet->len, &lenout, NULL)) {
+       if(!WriteFile(device_handle, packet->data, packet->len, &lenout, NULL)) {
                logger(LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError()));
                return false;
        }
index 49d5662..93511f1 100644 (file)
@@ -25,7 +25,7 @@
 #ifndef HAVE_DAEMON
 /*
   Replacement for the daemon() function.
-  
+
   The daemon() function is for programs wishing to detach themselves
   from the controlling terminal and run in the background as system
   daemons.
@@ -50,8 +50,9 @@ int daemon(int nochdir, int noclose) {
        }
 
        /* If we are the parent, terminate */
-       if(pid)
+       if(pid) {
                exit(0);
+       }
 
        /* Detach by becoming the new process group leader */
        if(setsid() < 0) {
@@ -109,8 +110,9 @@ int vasprintf(char **buf, const char *fmt, va_list ap) {
        buf[len - 1] = 0;
        va_end(aq);
 
-       if(status >= 0)
+       if(status >= 0) {
                *buf = xrealloc(*buf, status + 1);
+       }
 
        if(status > len - 1) {
                len = status;
index e42dbd1..c30d6cc 100644 (file)
@@ -28,7 +28,7 @@
 #include "utils.h"
 #include "xalloc.h"
 
-avl_tree_t *edge_weight_tree;  /* Tree with all edges, sorted on weight */
+avl_tree_t *edge_weight_tree;   /* Tree with all edges, sorted on weight */
 
 static int edge_compare(const edge_t *a, const edge_t *b) {
        return strcmp(a->to->name, b->to->name);
@@ -39,13 +39,15 @@ static int edge_weight_compare(const edge_t *a, const edge_t *b) {
 
        result = a->weight - b->weight;
 
-       if(result)
+       if(result) {
                return result;
+       }
 
        result = strcmp(a->from->name, b->from->name);
 
-       if(result)
+       if(result) {
                return result;
+       }
 
        return strcmp(a->to->name, b->to->name);
 }
@@ -84,13 +86,15 @@ void edge_add(edge_t *e) {
 
        e->reverse = lookup_edge(e->to, e->from);
 
-       if(e->reverse)
+       if(e->reverse) {
                e->reverse->reverse = e;
+       }
 }
 
 void edge_del(edge_t *e) {
-       if(e->reverse)
+       if(e->reverse) {
                e->reverse->reverse = NULL;
+       }
 
        avl_delete(edge_weight_tree, e);
        avl_delete(e->from->edge_tree, e);
@@ -98,7 +102,7 @@ void edge_del(edge_t *e) {
 
 edge_t *lookup_edge(node_t *from, node_t *to) {
        edge_t v;
-       
+
        v.from = from;
        v.to = to;
 
@@ -115,11 +119,12 @@ void dump_edges(void) {
 
        for(node = node_tree->head; node; node = node->next) {
                n = node->data;
+
                for(node2 = n->edge_tree->head; node2; node2 = node2->next) {
                        e = node2->data;
                        address = sockaddr2hostname(&e->address);
                        logger(LOG_DEBUG, " %s to %s at %s options %x weight %d",
-                                  e->from->name, e->to->name, address, e->options, e->weight);
+                              e->from->name, e->to->name, address, e->options, e->weight);
                        free(address);
                }
        }
index ad92641..ef4feef 100644 (file)
@@ -31,20 +31,20 @@ typedef struct edge_t {
        struct node_t *to;
        sockaddr_t address;
 
-       uint32_t options;                       /* options turned on for this edge */
-       int weight;                                     /* weight of this edge */
+       uint32_t options;                       /* options turned on for this edge */
+       int weight;                                     /* weight of this edge */
 
-       struct connection_t *connection;        /* connection associated with this edge, if available */
-       struct edge_t *reverse;         /* edge in the opposite direction, if available */
+       struct connection_t *connection;        /* connection associated with this edge, if available */
+       struct edge_t *reverse;         /* edge in the opposite direction, if available */
 } edge_t;
 
-extern avl_tree_t *edge_weight_tree;   /* Tree with all known edges sorted on weight */
+extern avl_tree_t *edge_weight_tree;    /* Tree with all known edges sorted on weight */
 
 extern void init_edges(void);
 extern void exit_edges(void);
-extern edge_t *new_edge(void) __attribute__ ((__malloc__));
+extern edge_t *new_edge(void) __attribute__((__malloc__));
 extern void free_edge(edge_t *);
-extern avl_tree_t *new_edge_tree(void) __attribute__ ((__malloc__));
+extern avl_tree_t *new_edge_tree(void) __attribute__((__malloc__));
 extern void free_edge_tree(avl_tree_t *);
 extern void edge_add(edge_t *);
 extern void edge_del(edge_t *);
index eea78dd..32f5553 100644 (file)
@@ -50,7 +50,7 @@ struct ether_header {
        uint8_t ether_dhost[ETH_ALEN];
        uint8_t ether_shost[ETH_ALEN];
        uint16_t ether_type;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #endif
 
 #ifndef HAVE_STRUCT_ARPHDR
@@ -58,17 +58,17 @@ struct arphdr {
        uint16_t ar_hrd;
        uint16_t ar_pro;
        uint8_t ar_hln;
-       uint8_t ar_pln; 
-       uint16_t ar_op; 
-} __attribute__ ((__packed__));
+       uint8_t ar_pln;
+       uint16_t ar_op;
+} __attribute__((__packed__));
 
-#define ARPOP_REQUEST 1 
-#define ARPOP_REPLY 2 
-#define ARPOP_RREQUEST 3 
-#define ARPOP_RREPLY 4 
-#define ARPOP_InREQUEST 8 
-#define ARPOP_InREPLY 9 
-#define ARPOP_NAK 10 
+#define ARPOP_REQUEST 1
+#define ARPOP_REPLY 2
+#define ARPOP_RREQUEST 3
+#define ARPOP_RREPLY 4
+#define ARPOP_InREQUEST 8
+#define ARPOP_InREPLY 9
+#define ARPOP_NAK 10
 #endif
 
 #ifndef HAVE_STRUCT_ETHER_ARP
@@ -78,7 +78,7 @@ struct  ether_arp {
        uint8_t arp_spa[4];
        uint8_t arp_tha[ETH_ALEN];
        uint8_t arp_tpa[4];
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #define arp_hrd ea_hdr.ar_hrd
 #define arp_pro ea_hdr.ar_pro
 #define arp_hln ea_hdr.ar_hln
index 89ee022..85b18f7 100644 (file)
@@ -31,11 +31,13 @@ extern time_t now;
 static int id;
 
 static int event_compare(const event_t *a, const event_t *b) {
-       if(a->time > b->time)
+       if(a->time > b->time) {
                return 1;
+       }
 
-       if(a->time < b->time)
+       if(a->time < b->time) {
                return -1;
+       }
 
        return a->id - b->id;
 }
@@ -55,18 +57,21 @@ void expire_events(void) {
 
        /*
         * Make all events appear expired by substracting the difference between
-         * the expiration time of the last event and the current time.
+        * the expiration time of the last event and the current time.
         */
 
-       if(!event_tree->tail)
+       if(!event_tree->tail) {
                return;
+       }
 
        event = event_tree->tail->data;
-       if(event->time <= now)
+
+       if(event->time <= now) {
                return;
+       }
 
        diff = event->time - now;
-       
+
        for(node = event_tree->head; node; node = node->next) {
                event = node->data;
                event->time -= diff;
@@ -108,7 +113,9 @@ event_t *get_expired_event(void) {
 }
 
 event_t *peek_next_event(void) {
-       if (event_tree->head)
+       if(event_tree->head) {
                return event_tree->head->data;
+       }
+
        return NULL;
 }
index d1ca9d2..c6bd207 100644 (file)
@@ -37,7 +37,7 @@ typedef struct event {
 extern void init_events(void);
 extern void exit_events(void);
 extern void expire_events(void);
-extern event_t *new_event(void) __attribute__ ((__malloc__));
+extern event_t *new_event(void) __attribute__((__malloc__));
 extern void free_event(event_t *);
 extern void event_add(event_t *);
 extern void event_del(event_t *);
index 10672b7..231bd5c 100644 (file)
 #include "xalloc.h"
 
 #if !HAVE_DECL_GAI_STRERROR
-char *gai_strerror(int ecode)
-{
-       switch (ecode) {
-               case EAI_NODATA:
-                       return "No address associated with hostname";
-               case EAI_MEMORY:
-                       return "Memory allocation failure";
-               case EAI_FAMILY:
-                       return "Address family not supported";
-               default:
-                       return "Unknown error";
+char *gai_strerror(int ecode) {
+       switch(ecode) {
+       case EAI_NODATA:
+               return "No address associated with hostname";
+
+       case EAI_MEMORY:
+               return "Memory allocation failure";
+
+       case EAI_FAMILY:
+               return "Address family not supported";
+
+       default:
+               return "Unknown error";
        }
-}    
+}
 #endif /* !HAVE_GAI_STRERROR */
 
 #if !HAVE_DECL_FREEADDRINFO
-void freeaddrinfo(struct addrinfo *ai)
-{
+void freeaddrinfo(struct addrinfo *ai) {
        struct addrinfo *next;
 
        while(ai) {
@@ -46,56 +47,58 @@ void freeaddrinfo(struct addrinfo *ai)
 #endif /* !HAVE_FREEADDRINFO */
 
 #if !HAVE_DECL_GETADDRINFO
-static struct addrinfo *malloc_ai(uint16_t port, uint32_t addr)
-{
+static struct addrinfo *malloc_ai(uint16_t port, uint32_t addr) {
        struct addrinfo *ai;
 
        ai = xmalloc_and_zero(sizeof(struct addrinfo) + sizeof(struct sockaddr_in));
-       
+
        ai->ai_addr = (struct sockaddr *)(ai + 1);
        ai->ai_addrlen = sizeof(struct sockaddr_in);
        ai->ai_addr->sa_family = ai->ai_family = AF_INET;
 
        ((struct sockaddr_in *)(ai)->ai_addr)->sin_port = port;
        ((struct sockaddr_in *)(ai)->ai_addr)->sin_addr.s_addr = addr;
-       
+
        return ai;
 }
 
-int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res)
-{
+int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res) {
        struct addrinfo *prev = NULL;
        struct hostent *hp;
        struct in_addr in = {0};
        int i;
        uint16_t port = 0;
 
-       if(hints && hints->ai_family != AF_INET && hints->ai_family != AF_UNSPEC)
+       if(hints && hints->ai_family != AF_INET && hints->ai_family != AF_UNSPEC) {
                return EAI_FAMILY;
+       }
 
-       if (servname)
+       if(servname) {
                port = htons(atoi(servname));
+       }
 
-       if (hints && hints->ai_flags & AI_PASSIVE) {
+       if(hints && hints->ai_flags & AI_PASSIVE) {
                *res = malloc_ai(port, htonl(0x00000000));
                return 0;
        }
-               
-       if (!hostname) {
+
+       if(!hostname) {
                *res = malloc_ai(port, htonl(0x7f000001));
                return 0;
        }
-       
+
        hp = gethostbyname(hostname);
 
-       if(!hp || !hp->h_addr_list || !hp->h_addr_list[0])
+       if(!hp || !hp->h_addr_list || !hp->h_addr_list[0]) {
                return EAI_NODATA;
+       }
 
-       for (i = 0; hp->h_addr_list[i]; i++) {
+       for(i = 0; hp->h_addr_list[i]; i++) {
                *res = malloc_ai(port, ((struct in_addr *)hp->h_addr_list[i])->s_addr);
 
-               if(prev)
+               if(prev) {
                        prev->ai_next = *res;
+               }
 
                prev = *res;
        }
index 9316f5a..a79a611 100644 (file)
@@ -2,15 +2,15 @@
 #define TINC_FAKE_GETADDRINFO_H
 
 #ifndef EAI_NODATA
-#define EAI_NODATA     1
+#define EAI_NODATA      1
 #endif
 
 #ifndef EAI_MEMORY
-#define EAI_MEMORY     2
+#define EAI_MEMORY      2
 #endif
 
 #ifndef EAI_FAMILY
-#define EAI_FAMILY     3
+#define EAI_FAMILY      3
 #endif
 
 #ifndef AI_PASSIVE
 
 #ifndef HAVE_STRUCT_ADDRINFO
 struct addrinfo {
-       int     ai_flags;       /* AI_PASSIVE, AI_CANONNAME */
-       int     ai_family;      /* PF_xxx */
-       int     ai_socktype;    /* SOCK_xxx */
-       int     ai_protocol;    /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
-       size_t  ai_addrlen;     /* length of ai_addr */
-       char    *ai_canonname;  /* canonical name for hostname */
-       struct sockaddr *ai_addr;       /* binary address */
-       struct addrinfo *ai_next;       /* next structure in linked list */
+       int     ai_flags;       /* AI_PASSIVE, AI_CANONNAME */
+       int     ai_family;      /* PF_xxx */
+       int     ai_socktype;    /* SOCK_xxx */
+       int     ai_protocol;    /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+       size_t  ai_addrlen;     /* length of ai_addr */
+       char    *ai_canonname;  /* canonical name for hostname */
+       struct sockaddr *ai_addr;       /* binary address */
+       struct addrinfo *ai_next;       /* next structure in linked list */
 };
 #endif /* !HAVE_STRUCT_ADDRINFO */
 
 #if !HAVE_DECL_GETADDRINFO
-int getaddrinfo(const char *hostname, const char *servname, 
+int getaddrinfo(const char *hostname, const char *servname,
                 const struct addrinfo *hints, struct addrinfo **res);
 #endif /* !HAVE_GETADDRINFO */
 
index 8047173..88b78a5 100644 (file)
 
 #if !HAVE_DECL_GETNAMEINFO
 
-int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags)
-{
+int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) {
        struct sockaddr_in *sin = (struct sockaddr_in *)sa;
        struct hostent *hp;
        int len;
 
-       if(sa->sa_family != AF_INET)
+       if(sa->sa_family != AF_INET) {
                return EAI_FAMILY;
+       }
 
        if(serv && servlen) {
                len = snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
-               if(len < 0 || len >= servlen)
+
+               if(len < 0 || len >= servlen) {
                        return EAI_MEMORY;
+               }
        }
 
-       if(!host || !hostlen)
+       if(!host || !hostlen) {
                return 0;
+       }
 
        if(flags & NI_NUMERICHOST) {
                len = snprintf(host, hostlen, "%s", inet_ntoa(sin->sin_addr));
-               if(len < 0 || len >= hostlen)
+
+               if(len < 0 || len >= hostlen) {
                        return EAI_MEMORY;
+               }
+
                return 0;
        }
 
        hp = gethostbyaddr((char *)&sin->sin_addr, sizeof(struct in_addr), AF_INET);
-       
-       if(!hp || !hp->h_name || !hp->h_name[0])
+
+       if(!hp || !hp->h_name || !hp->h_name[0]) {
                return EAI_NODATA;
-       
+       }
+
        len = snprintf(host, hostlen, "%s", hp->h_name);
-       if(len < 0 || len >= hostlen)
+
+       if(len < 0 || len >= hostlen) {
                return EAI_MEMORY;
+       }
 
        return 0;
 }
index f939ffc..4f24ad1 100644 (file)
@@ -2,7 +2,7 @@
 #define TINC_FAKE_GETNAMEINFO_H
 
 #if !HAVE_DECL_GETNAMEINFO
-int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, 
+int getnameinfo(const struct sockaddr *sa, size_t salen, char *host,
                 size_t hostlen, char *serv, size_t servlen, int flags);
 #endif /* !HAVE_GETNAMEINFO */
 
index 273a000..f84562c 100644 (file)
@@ -4,7 +4,7 @@
    before changing it!
 
    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
-       Free Software Foundation, Inc.
+        Free Software Foundation, Inc.
 
 NOTE: The canonical source of this file is maintained with the GNU C Library.
 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
@@ -69,12 +69,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 /* This needs to come after some library #include
    to get GNU_LIBRARY defined.  */
-#ifdef GNU_LIBRARY
+#ifdef  GNU_LIBRARY
 /* Don't include stdlib.h for non-GNU C libraries because some of them
    contain conflicting prototypes for getopt.  */
 #include <stdlib.h>
 #include <unistd.h>
-#endif /* GNU C library.  */
+#endif  /* GNU C library.  */
 
 #ifdef VMS
 #include <unixlib.h>
@@ -183,40 +183,41 @@ int optopt = '?';
    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
 
-static enum
-{
-  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+static enum {
+       REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
 } ordering;
 
 /* Value of POSIXLY_CORRECT environment variable.  */
 static char *posixly_correct;
 \f
-#ifdef GNU_LIBRARY
+#ifdef  GNU_LIBRARY
 /* We want to avoid inclusion of string.h with non-GNU libraries
    because there are many ways it can cause trouble.
    On some systems, it contains special magic macros that don't work
    in GCC.  */
 #include <string.h>
-#define        my_index        strchr
+#define my_index        strchr
 #else
 
 /* Avoid depending on library functions or files
    whose names are inconsistent.  */
 
-char *getenv ();
+char *getenv();
 
 static char *
-my_index (str, chr)
-     const char *str;
-     int chr;
+my_index(str, chr)
+const char *str;
+int chr;
 {
-  while (*str)
-    {
-      if (*str == chr)
-       return (char *) str;
-      str++;
-    }
-  return 0;
+       while(*str) {
+               if(*str == chr) {
+                       return (char *) str;
+               }
+
+               str++;
+       }
+
+       return 0;
 }
 
 /* If using GCC, we can safely declare strlen this way.
@@ -227,7 +228,7 @@ my_index (str, chr)
 #if !defined (STDC) || !STDC
 /* gcc with -traditional declares the built-in strlen to return int,
    and has done so at least since version 2.4.5. -- rms.  */
-extern int strlen (const char *);
+extern int strlen(const char *);
 #endif /* not STDC */
 #endif /* GNUC */
 
@@ -261,26 +262,25 @@ extern pid_t libc_pid;
    is valid for the getopt call we must make sure that the ARGV passed
    to getopt is that one passed to the process.  */
 static void
-__attribute__ ((__unused__))
-store_args_and_env (int argc, char *const *argv)
-{
-  /* XXX This is no good solution.  We should rather copy the args so
-     that we can compare them later.  But we must not use malloc(3).  */
-  original_argc = argc;
-  original_argv = argv;
+__attribute__((__unused__))
+store_args_and_env(int argc, char *const *argv) {
+       /* XXX This is no good solution.  We should rather copy the args so
+          that we can compare them later.  But we must not use malloc(3).  */
+       original_argc = argc;
+       original_argv = argv;
 }
-text_set_element (libc_subinit, store_args_and_env);
+text_set_element(libc_subinit, store_args_and_env);
 
 # define SWAP_FLAGS(ch1, ch2) \
-  if (nonoption_flags_len > 0)                                               \
-    {                                                                        \
-      char tmp = getopt_nonoption_flags[ch1];                        \
-      getopt_nonoption_flags[ch1] = getopt_nonoption_flags[ch2];             \
-      getopt_nonoption_flags[ch2] = tmp;                                     \
-    }
-#else  /* !_LIBC */
+       if (nonoption_flags_len > 0)                                                \
+       {                                                                         \
+               char tmp = getopt_nonoption_flags[ch1];                         \
+               getopt_nonoption_flags[ch1] = getopt_nonoption_flags[ch2];              \
+               getopt_nonoption_flags[ch2] = tmp;                                      \
+       }
+#else   /* !_LIBC */
 # define SWAP_FLAGS(ch1, ch2)
-#endif /* _LIBC */
+#endif  /* _LIBC */
 
 /* Exchange two adjacent subsequences of ARGV.
    One subsequence is elements [first_nonopt,last_nonopt)
@@ -292,161 +292,158 @@ text_set_element (libc_subinit, store_args_and_env);
    the new indices of the non-options in ARGV after they are moved.  */
 
 #if defined (STDC) && STDC
-static void exchange (char **);
+static void exchange(char **);
 #endif
 
 static void
-exchange (argv)
-     char **argv;
+exchange(argv)
+char **argv;
 {
-  int bottom = first_nonopt;
-  int middle = last_nonopt;
-  int top = optind;
-  char *tem;
+       int bottom = first_nonopt;
+       int middle = last_nonopt;
+       int top = optind;
+       char *tem;
 
-  /* Exchange the shorter segment with the far end of the longer segment.
-     That puts the shorter segment into the right place.
-     It leaves the longer segment in the right place overall,
-     but it consists of two parts that need to be swapped next.  */
+       /* Exchange the shorter segment with the far end of the longer segment.
+          That puts the shorter segment into the right place.
+          It leaves the longer segment in the right place overall,
+          but it consists of two parts that need to be swapped next.  */
 
 #ifdef _LIBC
-  /* First make sure the handling of the `getopt_nonoption_flags'
-     string can work normally.  Our top argument must be in the range
-     of the string.  */
-  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
-    {
-      /* We must extend the array.  The user plays games with us and
-        presents new arguments.  */
-      char *new_str = malloc (top + 1);
-      if (new_str == NULL)
-       nonoption_flags_len = nonoption_flags_max_len = 0;
-      else
-       {
-         memcpy (new_str, getopt_nonoption_flags, nonoption_flags_max_len);
-         memset (&new_str[nonoption_flags_max_len], '\0',
-                 top + 1 - nonoption_flags_max_len);
-         nonoption_flags_max_len = top + 1;
-         getopt_nonoption_flags = new_str;
+
+       /* First make sure the handling of the `getopt_nonoption_flags'
+          string can work normally.  Our top argument must be in the range
+          of the string.  */
+       if(nonoption_flags_len > 0 && top >= nonoption_flags_max_len) {
+               /* We must extend the array.  The user plays games with us and
+                presents new arguments.  */
+               char *new_str = malloc(top + 1);
+
+               if(new_str == NULL) {
+                       nonoption_flags_len = nonoption_flags_max_len = 0;
+               } else {
+                       memcpy(new_str, getopt_nonoption_flags, nonoption_flags_max_len);
+                       memset(&new_str[nonoption_flags_max_len], '\0',
+                              top + 1 - nonoption_flags_max_len);
+                       nonoption_flags_max_len = top + 1;
+                       getopt_nonoption_flags = new_str;
+               }
        }
-    }
+
 #endif
 
-  while (top > middle && middle > bottom)
-    {
-      if (top - middle > middle - bottom)
-       {
-         /* Bottom segment is the short one.  */
-         int len = middle - bottom;
-         register int i;
-
-         /* Swap it with the top part of the top segment.  */
-         for (i = 0; i < len; i++)
-           {
-             tem = argv[bottom + i];
-             argv[bottom + i] = argv[top - (middle - bottom) + i];
-             argv[top - (middle - bottom) + i] = tem;
-             SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
-           }
-         /* Exclude the moved bottom segment from further swapping.  */
-         top -= len;
-       }
-      else
-       {
-         /* Top segment is the short one.  */
-         int len = top - middle;
-         register int i;
-
-         /* Swap it with the bottom part of the bottom segment.  */
-         for (i = 0; i < len; i++)
-           {
-             tem = argv[bottom + i];
-             argv[bottom + i] = argv[middle + i];
-             argv[middle + i] = tem;
-             SWAP_FLAGS (bottom + i, middle + i);
-           }
-         /* Exclude the moved top segment from further swapping.  */
-         bottom += len;
+       while(top > middle && middle > bottom) {
+               if(top - middle > middle - bottom) {
+                       /* Bottom segment is the short one.  */
+                       int len = middle - bottom;
+                       register int i;
+
+                       /* Swap it with the top part of the top segment.  */
+                       for(i = 0; i < len; i++) {
+                               tem = argv[bottom + i];
+                               argv[bottom + i] = argv[top - (middle - bottom) + i];
+                               argv[top - (middle - bottom) + i] = tem;
+                               SWAP_FLAGS(bottom + i, top - (middle - bottom) + i);
+                       }
+
+                       /* Exclude the moved bottom segment from further swapping.  */
+                       top -= len;
+               } else {
+                       /* Top segment is the short one.  */
+                       int len = top - middle;
+                       register int i;
+
+                       /* Swap it with the bottom part of the bottom segment.  */
+                       for(i = 0; i < len; i++) {
+                               tem = argv[bottom + i];
+                               argv[bottom + i] = argv[middle + i];
+                               argv[middle + i] = tem;
+                               SWAP_FLAGS(bottom + i, middle + i);
+                       }
+
+                       /* Exclude the moved top segment from further swapping.  */
+                       bottom += len;
+               }
        }
-    }
 
-  /* Update records for the slots the non-options now occupy.  */
+       /* Update records for the slots the non-options now occupy.  */
 
-  first_nonopt += (optind - last_nonopt);
-  last_nonopt = optind;
+       first_nonopt += (optind - last_nonopt);
+       last_nonopt = optind;
 }
 
 /* Initialize the internal data when the first call is made.  */
 
 #if defined (STDC) && STDC
-static const char *_getopt_initialize (int, char *const *, const char *);
+static const char *_getopt_initialize(int, char *const *, const char *);
 #endif
 static const char *
-_getopt_initialize (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
+_getopt_initialize(argc, argv, optstring)
+int argc;
+char *const *argv;
+const char *optstring;
 {
-  /* Start processing options with ARGV-element 1 (since ARGV-element 0
-     is the program name); the sequence of previously skipped
-     non-option ARGV-elements is empty.  */
+       /* Start processing options with ARGV-element 1 (since ARGV-element 0
+          is the program name); the sequence of previously skipped
+          non-option ARGV-elements is empty.  */
 
-  first_nonopt = last_nonopt = optind;
+       first_nonopt = last_nonopt = optind;
 
-  nextchar = NULL;
+       nextchar = NULL;
 
-  posixly_correct = getenv ("POSIXLY_CORRECT");
+       posixly_correct = getenv("POSIXLY_CORRECT");
 
-  /* Determine how to handle the ordering of options and nonoptions.  */
+       /* Determine how to handle the ordering of options and nonoptions.  */
 
-  if (optstring[0] == '-')
-    {
-      ordering = RETURN_IN_ORDER;
-      ++optstring;
-    }
-  else if (optstring[0] == '+')
-    {
-      ordering = REQUIRE_ORDER;
-      ++optstring;
-    }
-  else if (posixly_correct != NULL)
-    ordering = REQUIRE_ORDER;
-  else
-    ordering = PERMUTE;
+       if(optstring[0] == '-') {
+               ordering = RETURN_IN_ORDER;
+               ++optstring;
+       } else if(optstring[0] == '+') {
+               ordering = REQUIRE_ORDER;
+               ++optstring;
+       } else if(posixly_correct != NULL) {
+               ordering = REQUIRE_ORDER;
+       } else {
+               ordering = PERMUTE;
+       }
 
 #ifdef _LIBC
-  if (posixly_correct == NULL
-      && argc == original_argc && argv == original_argv)
-    {
-      if (nonoption_flags_max_len == 0)
-       {
-         if (getopt_nonoption_flags == NULL
-             || getopt_nonoption_flags[0] == '\0')
-           nonoption_flags_max_len = -1;
-         else
-           {
-             const char *orig_str = getopt_nonoption_flags;
-             int len = nonoption_flags_max_len = strlen (orig_str);
-             if (nonoption_flags_max_len < argc)
-               nonoption_flags_max_len = argc;
-             getopt_nonoption_flags =
-               (char *) malloc (nonoption_flags_max_len);
-             if (getopt_nonoption_flags == NULL)
-               nonoption_flags_max_len = -1;
-             else
-               {
-                 memcpy (getopt_nonoption_flags, orig_str, len);
-                 memset (&getopt_nonoption_flags[len], '\0',
-                         nonoption_flags_max_len - len);
+
+       if(posixly_correct == NULL
+                       && argc == original_argc && argv == original_argv) {
+               if(nonoption_flags_max_len == 0) {
+                       if(getopt_nonoption_flags == NULL
+                                       || getopt_nonoption_flags[0] == '\0') {
+                               nonoption_flags_max_len = -1;
+                       } else {
+                               const char *orig_str = getopt_nonoption_flags;
+                               int len = nonoption_flags_max_len = strlen(orig_str);
+
+                               if(nonoption_flags_max_len < argc) {
+                                       nonoption_flags_max_len = argc;
+                               }
+
+                               getopt_nonoption_flags =
+                                       (char *) malloc(nonoption_flags_max_len);
+
+                               if(getopt_nonoption_flags == NULL) {
+                                       nonoption_flags_max_len = -1;
+                               } else {
+                                       memcpy(getopt_nonoption_flags, orig_str, len);
+                                       memset(&getopt_nonoption_flags[len], '\0',
+                                              nonoption_flags_max_len - len);
+                               }
+                       }
                }
-           }
+
+               nonoption_flags_len = nonoption_flags_max_len;
+       } else {
+               nonoption_flags_len = 0;
        }
-      nonoption_flags_len = nonoption_flags_max_len;
-    }
-  else
-    nonoption_flags_len = 0;
+
 #endif
 
-  return optstring;
+       return optstring;
 }
 \f
 /* Scan elements of ARGV (whose length is ARGC) for option characters
@@ -506,474 +503,476 @@ _getopt_initialize (argc, argv, optstring)
    long-named options.  */
 
 int
-_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
-     int argc;
-     char *const *argv;
-     const char *optstring;
-     const struct option *longopts;
-     int *longind;
-     int long_only;
+_getopt_internal(argc, argv, optstring, longopts, longind, long_only)
+int argc;
+char *const *argv;
+const char *optstring;
+const struct option *longopts;
+int *longind;
+int long_only;
 {
-  optarg = NULL;
-
-  if (optind == 0 || !getopt_initialized)
-    {
-      if (optind == 0)
-       optind = 1;     /* Don't scan ARGV[0], the program name.  */
-      optstring = _getopt_initialize (argc, argv, optstring);
-      getopt_initialized = 1;
-    }
-
-  /* Test whether ARGV[optind] points to a non-option argument.
-     Either it does not have option syntax, or there is an environment flag
-     from the shell indicating it is not an option.  The later information
-     is only used when the used in the GNU libc.  */
+       optarg = NULL;
+
+       if(optind == 0 || !getopt_initialized) {
+               if(optind == 0) {
+                       optind = 1;        /* Don't scan ARGV[0], the program name.  */
+               }
+
+               optstring = _getopt_initialize(argc, argv, optstring);
+               getopt_initialized = 1;
+       }
+
+       /* Test whether ARGV[optind] points to a non-option argument.
+          Either it does not have option syntax, or there is an environment flag
+          from the shell indicating it is not an option.  The later information
+          is only used when the used in the GNU libc.  */
 #ifdef _LIBC
-#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
-                    || (optind < nonoption_flags_len                         \
-                        && getopt_nonoption_flags[optind] == '1'))
+#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
+                     || (optind < nonoption_flags_len                         \
+                         && getopt_nonoption_flags[optind] == '1'))
 #else
 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
 #endif
 
-  if (nextchar == NULL || *nextchar == '\0')
-    {
-      /* Advance to the next ARGV-element.  */
+       if(nextchar == NULL || *nextchar == '\0') {
+               /* Advance to the next ARGV-element.  */
 
-      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
-        moved back by the user (who may also have changed the arguments).  */
-      if (last_nonopt > optind)
-       last_nonopt = optind;
-      if (first_nonopt > optind)
-       first_nonopt = optind;
+               /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+                moved back by the user (who may also have changed the arguments).  */
+               if(last_nonopt > optind) {
+                       last_nonopt = optind;
+               }
 
-      if (ordering == PERMUTE)
-       {
-         /* If we have just processed some options following some non-options,
-            exchange them so that the options come first.  */
+               if(first_nonopt > optind) {
+                       first_nonopt = optind;
+               }
 
-         if (first_nonopt != last_nonopt && last_nonopt != optind)
-           exchange ((char **) argv);
-         else if (last_nonopt != optind)
-           first_nonopt = optind;
+               if(ordering == PERMUTE) {
+                       /* If we have just processed some options following some non-options,
+                          exchange them so that the options come first.  */
 
-         /* Skip any additional non-options
-            and extend the range of non-options previously skipped.  */
+                       if(first_nonopt != last_nonopt && last_nonopt != optind) {
+                               exchange((char **) argv);
+                       } else if(last_nonopt != optind) {
+                               first_nonopt = optind;
+                       }
 
-         while (optind < argc && NONOPTION_P)
-           optind++;
-         last_nonopt = optind;
-       }
+                       /* Skip any additional non-options
+                          and extend the range of non-options previously skipped.  */
 
-      /* The special ARGV-element `--' means premature end of options.
-        Skip it like a null option,
-        then exchange with previous non-options as if it were an option,
-        then skip everything else like a non-option.  */
+                       while(optind < argc && NONOPTION_P) {
+                               optind++;
+                       }
 
-      if (optind != argc && !strcmp (argv[optind], "--"))
-       {
-         optind++;
+                       last_nonopt = optind;
+               }
 
-         if (first_nonopt != last_nonopt && last_nonopt != optind)
-           exchange ((char **) argv);
-         else if (first_nonopt == last_nonopt)
-           first_nonopt = optind;
-         last_nonopt = argc;
+               /* The special ARGV-element `--' means premature end of options.
+                Skip it like a null option,
+                then exchange with previous non-options as if it were an option,
+                then skip everything else like a non-option.  */
 
-         optind = argc;
-       }
+               if(optind != argc && !strcmp(argv[optind], "--")) {
+                       optind++;
 
-      /* If we have done all the ARGV-elements, stop the scan
-        and back over any non-options that we skipped and permuted.  */
+                       if(first_nonopt != last_nonopt && last_nonopt != optind) {
+                               exchange((char **) argv);
+                       } else if(first_nonopt == last_nonopt) {
+                               first_nonopt = optind;
+                       }
 
-      if (optind == argc)
-       {
-         /* Set the next-arg-index to point at the non-options
-            that we previously skipped, so the caller will digest them.  */
-         if (first_nonopt != last_nonopt)
-           optind = first_nonopt;
-         return -1;
-       }
+                       last_nonopt = argc;
 
-      /* If we have come to a non-option and did not permute it,
-        either stop the scan or describe it to the caller and pass it by.  */
+                       optind = argc;
+               }
 
-      if (NONOPTION_P)
-       {
-         if (ordering == REQUIRE_ORDER)
-           return -1;
-         optarg = argv[optind++];
-         return 1;
-       }
+               /* If we have done all the ARGV-elements, stop the scan
+                and back over any non-options that we skipped and permuted.  */
 
-      /* We have found another option-ARGV-element.
-        Skip the initial punctuation.  */
-
-      nextchar = (argv[optind] + 1
-                 + (longopts != NULL && argv[optind][1] == '-'));
-    }
-
-  /* Decode the current option-ARGV-element.  */
-
-  /* Check whether the ARGV-element is a long option.
-
-     If long_only and the ARGV-element has the form "-f", where f is
-     a valid short option, don't consider it an abbreviated form of
-     a long option that starts with f.  Otherwise there would be no
-     way to give the -f short option.
-
-     On the other hand, if there's a long option "fubar" and
-     the ARGV-element is "-fu", do consider that an abbreviation of
-     the long option, just like "--fu", and not "-f" with arg "u".
-
-     This distinction seems to be the most useful approach.  */
-
-  if (longopts != NULL
-      && (argv[optind][1] == '-'
-         || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
-    {
-      char *nameend;
-      const struct option *p;
-      const struct option *pfound = NULL;
-      int exact = 0;
-      int ambig = 0;
-      int indfound = -1;
-      int option_index;
-
-      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-       /* Do nothing.  */ ;
-
-      /* Test all long options for either exact match
-        or abbreviated matches.  */
-      for (p = longopts, option_index = 0; p->name; p++, option_index++)
-       if (!strncmp (p->name, nextchar, nameend - nextchar))
-         {
-           if ((unsigned int) (nameend - nextchar)
-               == (unsigned int) strlen (p->name))
-             {
-               /* Exact match found.  */
-               pfound = p;
-               indfound = option_index;
-               exact = 1;
-               break;
-             }
-           else if (pfound == NULL)
-             {
-               /* First nonexact match found.  */
-               pfound = p;
-               indfound = option_index;
-             }
-           else
-             /* Second or later nonexact match found.  */
-             ambig = 1;
-         }
-
-      if (ambig && !exact)
-       {
-         if (opterr)
-           fprintf (stderr, "%s: option `%s' is ambiguous\n",
-                    argv[0], argv[optind]);
-         nextchar += strlen (nextchar);
-         optind++;
-         optopt = 0;
-         return '?';
+               if(optind == argc) {
+                       /* Set the next-arg-index to point at the non-options
+                          that we previously skipped, so the caller will digest them.  */
+                       if(first_nonopt != last_nonopt) {
+                               optind = first_nonopt;
+                       }
+
+                       return -1;
+               }
+
+               /* If we have come to a non-option and did not permute it,
+                either stop the scan or describe it to the caller and pass it by.  */
+
+               if(NONOPTION_P) {
+                       if(ordering == REQUIRE_ORDER) {
+                               return -1;
+                       }
+
+                       optarg = argv[optind++];
+                       return 1;
+               }
+
+               /* We have found another option-ARGV-element.
+                Skip the initial punctuation.  */
+
+               nextchar = (argv[optind] + 1
+                           + (longopts != NULL && argv[optind][1] == '-'));
        }
 
-      if (pfound != NULL)
-       {
-         option_index = indfound;
-         optind++;
-         if (*nameend)
-           {
-             /* Don't test has_arg with >, because some C compilers don't
-                allow it to be used on enums.  */
-             if (pfound->has_arg)
-               optarg = nameend + 1;
-             else
-               {
-                 if (opterr)
-                   {
-                    if (argv[optind - 1][1] == '-')
-                     /* --option */
-                     fprintf (stderr,
-                      "%s: option `--%s' doesn't allow an argument\n",
-                      argv[0], pfound->name);
-                    else
-                     /* +option or -option */
-                     fprintf (stderr,
-                      "%s: option `%c%s' doesn't allow an argument\n",
-                      argv[0], argv[optind - 1][0], pfound->name);
-                   }
-
-                 nextchar += strlen (nextchar);
-
-                 optopt = pfound->val;
-                 return '?';
+       /* Decode the current option-ARGV-element.  */
+
+       /* Check whether the ARGV-element is a long option.
+
+          If long_only and the ARGV-element has the form "-f", where f is
+          a valid short option, don't consider it an abbreviated form of
+          a long option that starts with f.  Otherwise there would be no
+          way to give the -f short option.
+
+          On the other hand, if there's a long option "fubar" and
+          the ARGV-element is "-fu", do consider that an abbreviation of
+          the long option, just like "--fu", and not "-f" with arg "u".
+
+          This distinction seems to be the most useful approach.  */
+
+       if(longopts != NULL
+                       && (argv[optind][1] == '-'
+                           || (long_only && (argv[optind][2] || !my_index(optstring, argv[optind][1]))))) {
+               char *nameend;
+               const struct option *p;
+               const struct option *pfound = NULL;
+               int exact = 0;
+               int ambig = 0;
+               int indfound = -1;
+               int option_index;
+
+               for(nameend = nextchar; *nameend && *nameend != '='; nameend++)
+                       /* Do nothing.  */ ;
+
+               /* Test all long options for either exact match
+                or abbreviated matches.  */
+               for(p = longopts, option_index = 0; p->name; p++, option_index++)
+                       if(!strncmp(p->name, nextchar, nameend - nextchar)) {
+                               if((unsigned int)(nameend - nextchar)
+                                               == (unsigned int) strlen(p->name)) {
+                                       /* Exact match found.  */
+                                       pfound = p;
+                                       indfound = option_index;
+                                       exact = 1;
+                                       break;
+                               } else if(pfound == NULL) {
+                                       /* First nonexact match found.  */
+                                       pfound = p;
+                                       indfound = option_index;
+                               } else
+                                       /* Second or later nonexact match found.  */
+                               {
+                                       ambig = 1;
+                               }
+                       }
+
+               if(ambig && !exact) {
+                       if(opterr)
+                               fprintf(stderr, "%s: option `%s' is ambiguous\n",
+                                       argv[0], argv[optind]);
+
+                       nextchar += strlen(nextchar);
+                       optind++;
+                       optopt = 0;
+                       return '?';
                }
-           }
-         else if (pfound->has_arg == 1)
-           {
-             if (optind < argc)
-               optarg = argv[optind++];
-             else
-               {
-                 if (opterr)
-                   fprintf (stderr,
-                          "%s: option `%s' requires an argument\n",
-                          argv[0], argv[optind - 1]);
-                 nextchar += strlen (nextchar);
-                 optopt = pfound->val;
-                 return optstring[0] == ':' ? ':' : '?';
+
+               if(pfound != NULL) {
+                       option_index = indfound;
+                       optind++;
+
+                       if(*nameend) {
+                               /* Don't test has_arg with >, because some C compilers don't
+                                allow it to be used on enums.  */
+                               if(pfound->has_arg) {
+                                       optarg = nameend + 1;
+                               } else {
+                                       if(opterr) {
+                                               if(argv[optind - 1][1] == '-')
+                                                       /* --option */
+                                                       fprintf(stderr,
+                                                               "%s: option `--%s' doesn't allow an argument\n",
+                                                               argv[0], pfound->name);
+                                               else
+                                                       /* +option or -option */
+                                                       fprintf(stderr,
+                                                               "%s: option `%c%s' doesn't allow an argument\n",
+                                                               argv[0], argv[optind - 1][0], pfound->name);
+                                       }
+
+                                       nextchar += strlen(nextchar);
+
+                                       optopt = pfound->val;
+                                       return '?';
+                               }
+                       } else if(pfound->has_arg == 1) {
+                               if(optind < argc) {
+                                       optarg = argv[optind++];
+                               } else {
+                                       if(opterr)
+                                               fprintf(stderr,
+                                                       "%s: option `%s' requires an argument\n",
+                                                       argv[0], argv[optind - 1]);
+
+                                       nextchar += strlen(nextchar);
+                                       optopt = pfound->val;
+                                       return optstring[0] == ':' ? ':' : '?';
+                               }
+                       }
+
+                       nextchar += strlen(nextchar);
+
+                       if(longind != NULL) {
+                               *longind = option_index;
+                       }
+
+                       if(pfound->flag) {
+                               *(pfound->flag) = pfound->val;
+                               return 0;
+                       }
+
+                       return pfound->val;
+               }
+
+               /* Can't find it as a long option.  If this is not getopt_long_only,
+                or the option starts with '--' or is not a valid short
+                option, then it's an error.
+                Otherwise interpret it as a short option.  */
+               if(!long_only || argv[optind][1] == '-'
+                               || my_index(optstring, *nextchar) == NULL) {
+                       if(opterr) {
+                               if(argv[optind][1] == '-')
+                                       /* --option */
+                                       fprintf(stderr, "%s: unrecognized option `--%s'\n",
+                                               argv[0], nextchar);
+                               else
+                                       /* +option or -option */
+                                       fprintf(stderr, "%s: unrecognized option `%c%s'\n",
+                                               argv[0], argv[optind][0], nextchar);
+                       }
+
+                       nextchar = (char *) "";
+                       optind++;
+                       optopt = 0;
+                       return '?';
                }
-           }
-         nextchar += strlen (nextchar);
-         if (longind != NULL)
-           *longind = option_index;
-         if (pfound->flag)
-           {
-             *(pfound->flag) = pfound->val;
-             return 0;
-           }
-         return pfound->val;
        }
 
-      /* Can't find it as a long option.  If this is not getopt_long_only,
-        or the option starts with '--' or is not a valid short
-        option, then it's an error.
-        Otherwise interpret it as a short option.  */
-      if (!long_only || argv[optind][1] == '-'
-         || my_index (optstring, *nextchar) == NULL)
+       /* Look at and handle the next short option-character.  */
+
        {
-         if (opterr)
-           {
-             if (argv[optind][1] == '-')
-               /* --option */
-               fprintf (stderr, "%s: unrecognized option `--%s'\n",
-                        argv[0], nextchar);
-             else
-               /* +option or -option */
-               fprintf (stderr, "%s: unrecognized option `%c%s'\n",
-                        argv[0], argv[optind][0], nextchar);
-           }
-         nextchar = (char *) "";
-         optind++;
-         optopt = 0;
-         return '?';
-       }
-    }
-
-  /* Look at and handle the next short option-character.  */
-
-  {
-    char c = *nextchar++;
-    char *temp = my_index (optstring, c);
-
-    /* Increment `optind' when we start to process its last character.  */
-    if (*nextchar == '\0')
-      ++optind;
-
-    if (temp == NULL || c == ':')
-      {
-       if (opterr)
-         {
-           if (posixly_correct)
-             /* 1003.2 specifies the format of this message.  */
-             fprintf (stderr, "%s: illegal option -- %c\n",
-                      argv[0], c);
-           else
-             fprintf (stderr, "%s: invalid option -- %c\n",
-                      argv[0], c);
-         }
-       optopt = c;
-       return '?';
-      }
-    /* Convenience. Treat POSIX -W foo same as long option --foo */
-    if (temp[0] == 'W' && temp[1] == ';')
-      {
-       char *nameend;
-       const struct option *p;
-       const struct option *pfound = NULL;
-       int exact = 0;
-       int ambig = 0;
-       int indfound = 0;
-       int option_index;
-
-       /* This is an option that requires an argument.  */
-       if (*nextchar != '\0')
-         {
-           optarg = nextchar;
-           /* If we end this ARGV-element by taking the rest as an arg,
-              we must advance to the next element now.  */
-           optind++;
-         }
-       else if (optind == argc)
-         {
-           if (opterr)
-             {
-               /* 1003.2 specifies the format of this message.  */
-               fprintf (stderr, "%s: option requires an argument -- %c\n",
-                        argv[0], c);
-             }
-           optopt = c;
-           if (optstring[0] == ':')
-             c = ':';
-           else
-             c = '?';
-           return c;
-         }
-       else
-         /* We already incremented `optind' once;
-            increment it again when taking next ARGV-elt as argument.  */
-         optarg = argv[optind++];
-
-       /* optarg is now the argument, see if it's in the
-          table of longopts.  */
-
-       for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
-         /* Do nothing.  */ ;
-
-       /* Test all long options for either exact match
-          or abbreviated matches.  */
-       for (p = longopts, option_index = 0; p->name; p++, option_index++)
-         if (!strncmp (p->name, nextchar, nameend - nextchar))
-           {
-             if ((unsigned int) (nameend - nextchar) == strlen (p->name))
-               {
-                 /* Exact match found.  */
-                 pfound = p;
-                 indfound = option_index;
-                 exact = 1;
-                 break;
+               char c = *nextchar++;
+               char *temp = my_index(optstring, c);
+
+               /* Increment `optind' when we start to process its last character.  */
+               if(*nextchar == '\0') {
+                       ++optind;
                }
-             else if (pfound == NULL)
-               {
-                 /* First nonexact match found.  */
-                 pfound = p;
-                 indfound = option_index;
+
+               if(temp == NULL || c == ':') {
+                       if(opterr) {
+                               if(posixly_correct)
+                                       /* 1003.2 specifies the format of this message.  */
+                                       fprintf(stderr, "%s: illegal option -- %c\n",
+                                               argv[0], c);
+                               else
+                                       fprintf(stderr, "%s: invalid option -- %c\n",
+                                               argv[0], c);
+                       }
+
+                       optopt = c;
+                       return '?';
+               }
+
+               /* Convenience. Treat POSIX -W foo same as long option --foo */
+               if(temp[0] == 'W' && temp[1] == ';') {
+                       char *nameend;
+                       const struct option *p;
+                       const struct option *pfound = NULL;
+                       int exact = 0;
+                       int ambig = 0;
+                       int indfound = 0;
+                       int option_index;
+
+                       /* This is an option that requires an argument.  */
+                       if(*nextchar != '\0') {
+                               optarg = nextchar;
+                               /* If we end this ARGV-element by taking the rest as an arg,
+                                  we must advance to the next element now.  */
+                               optind++;
+                       } else if(optind == argc) {
+                               if(opterr) {
+                                       /* 1003.2 specifies the format of this message.  */
+                                       fprintf(stderr, "%s: option requires an argument -- %c\n",
+                                               argv[0], c);
+                               }
+
+                               optopt = c;
+
+                               if(optstring[0] == ':') {
+                                       c = ':';
+                               } else {
+                                       c = '?';
+                               }
+
+                               return c;
+                       } else
+                               /* We already incremented `optind' once;
+                                  increment it again when taking next ARGV-elt as argument.  */
+                       {
+                               optarg = argv[optind++];
+                       }
+
+                       /* optarg is now the argument, see if it's in the
+                          table of longopts.  */
+
+                       for(nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+                               /* Do nothing.  */ ;
+
+                       /* Test all long options for either exact match
+                          or abbreviated matches.  */
+                       for(p = longopts, option_index = 0; p->name; p++, option_index++)
+                               if(!strncmp(p->name, nextchar, nameend - nextchar)) {
+                                       if((unsigned int)(nameend - nextchar) == strlen(p->name)) {
+                                               /* Exact match found.  */
+                                               pfound = p;
+                                               indfound = option_index;
+                                               exact = 1;
+                                               break;
+                                       } else if(pfound == NULL) {
+                                               /* First nonexact match found.  */
+                                               pfound = p;
+                                               indfound = option_index;
+                                       } else
+                                               /* Second or later nonexact match found.  */
+                                       {
+                                               ambig = 1;
+                                       }
+                               }
+
+                       if(ambig && !exact) {
+                               if(opterr)
+                                       fprintf(stderr, "%s: option `-W %s' is ambiguous\n",
+                                               argv[0], argv[optind]);
+
+                               nextchar += strlen(nextchar);
+                               optind++;
+                               return '?';
+                       }
+
+                       if(pfound != NULL) {
+                               option_index = indfound;
+
+                               if(*nameend) {
+                                       /* Don't test has_arg with >, because some C compilers don't
+                                          allow it to be used on enums.  */
+                                       if(pfound->has_arg) {
+                                               optarg = nameend + 1;
+                                       } else {
+                                               if(opterr)
+                                                       fprintf(stderr,
+                                                               "%s: option `-W %s' doesn't allow an argument\n",
+                                                               argv[0], pfound->name);
+
+                                               nextchar += strlen(nextchar);
+                                               return '?';
+                                       }
+                               } else if(pfound->has_arg == 1) {
+                                       if(optind < argc) {
+                                               optarg = argv[optind++];
+                                       } else {
+                                               if(opterr)
+                                                       fprintf(stderr,
+                                                               "%s: option `%s' requires an argument\n",
+                                                               argv[0], argv[optind - 1]);
+
+                                               nextchar += strlen(nextchar);
+                                               return optstring[0] == ':' ? ':' : '?';
+                                       }
+                               }
+
+                               nextchar += strlen(nextchar);
+
+                               if(longind != NULL) {
+                                       *longind = option_index;
+                               }
+
+                               if(pfound->flag) {
+                                       *(pfound->flag) = pfound->val;
+                                       return 0;
+                               }
+
+                               return pfound->val;
+                       }
+
+                       nextchar = NULL;
+                       return 'W';   /* Let the application handle it.   */
                }
-             else
-               /* Second or later nonexact match found.  */
-               ambig = 1;
-           }
-       if (ambig && !exact)
-         {
-           if (opterr)
-             fprintf (stderr, "%s: option `-W %s' is ambiguous\n",
-                      argv[0], argv[optind]);
-           nextchar += strlen (nextchar);
-           optind++;
-           return '?';
-         }
-       if (pfound != NULL)
-         {
-           option_index = indfound;
-           if (*nameend)
-             {
-               /* Don't test has_arg with >, because some C compilers don't
-                  allow it to be used on enums.  */
-               if (pfound->has_arg)
-                 optarg = nameend + 1;
-               else
-                 {
-                   if (opterr)
-                     fprintf (stderr,
-                              "%s: option `-W %s' doesn't allow an argument\n",
-                              argv[0], pfound->name);
-
-                   nextchar += strlen (nextchar);
-                   return '?';
-                 }
-             }
-           else if (pfound->has_arg == 1)
-             {
-               if (optind < argc)
-                 optarg = argv[optind++];
-               else
-                 {
-                   if (opterr)
-                     fprintf (stderr,
-                              "%s: option `%s' requires an argument\n",
-                              argv[0], argv[optind - 1]);
-                   nextchar += strlen (nextchar);
-                   return optstring[0] == ':' ? ':' : '?';
-                 }
-             }
-           nextchar += strlen (nextchar);
-           if (longind != NULL)
-             *longind = option_index;
-           if (pfound->flag)
-             {
-               *(pfound->flag) = pfound->val;
-               return 0;
-             }
-           return pfound->val;
-         }
-         nextchar = NULL;
-         return 'W';   /* Let the application handle it.   */
-      }
-    if (temp[1] == ':')
-      {
-       if (temp[2] == ':')
-         {
-           /* This is an option that accepts an argument optionally.  */
-           if (*nextchar != '\0')
-             {
-               optarg = nextchar;
-               optind++;
-             }
-           else
-             optarg = NULL;
-           nextchar = NULL;
-         }
-       else
-         {
-           /* This is an option that requires an argument.  */
-           if (*nextchar != '\0')
-             {
-               optarg = nextchar;
-               /* If we end this ARGV-element by taking the rest as an arg,
-                  we must advance to the next element now.  */
-               optind++;
-             }
-           else if (optind == argc)
-             {
-               if (opterr)
-                 {
-                   /* 1003.2 specifies the format of this message.  */
-                   fprintf (stderr,
-                          "%s: option requires an argument -- %c\n",
-                          argv[0], c);
-                 }
-               optopt = c;
-               if (optstring[0] == ':')
-                 c = ':';
-               else
-                 c = '?';
-             }
-           else
-             /* We already incremented `optind' once;
-                increment it again when taking next ARGV-elt as argument.  */
-             optarg = argv[optind++];
-           nextchar = NULL;
-         }
-      }
-    return c;
-  }
+
+               if(temp[1] == ':') {
+                       if(temp[2] == ':') {
+                               /* This is an option that accepts an argument optionally.  */
+                               if(*nextchar != '\0') {
+                                       optarg = nextchar;
+                                       optind++;
+                               } else {
+                                       optarg = NULL;
+                               }
+
+                               nextchar = NULL;
+                       } else {
+                               /* This is an option that requires an argument.  */
+                               if(*nextchar != '\0') {
+                                       optarg = nextchar;
+                                       /* If we end this ARGV-element by taking the rest as an arg,
+                                          we must advance to the next element now.  */
+                                       optind++;
+                               } else if(optind == argc) {
+                                       if(opterr) {
+                                               /* 1003.2 specifies the format of this message.  */
+                                               fprintf(stderr,
+                                                       "%s: option requires an argument -- %c\n",
+                                                       argv[0], c);
+                                       }
+
+                                       optopt = c;
+
+                                       if(optstring[0] == ':') {
+                                               c = ':';
+                                       } else {
+                                               c = '?';
+                                       }
+                               } else
+                                       /* We already incremented `optind' once;
+                                        increment it again when taking next ARGV-elt as argument.  */
+                               {
+                                       optarg = argv[optind++];
+                               }
+
+                               nextchar = NULL;
+                       }
+               }
+
+               return c;
+       }
 }
 
 int
-getopt (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
+getopt(argc, argv, optstring)
+int argc;
+char *const *argv;
+const char *optstring;
 {
-  return _getopt_internal (argc, argv, optstring,
-                          (const struct option *) 0,
-                          (int *) 0,
-                          0);
+       return _getopt_internal(argc, argv, optstring,
+                               (const struct option *) 0,
+                               (int *) 0,
+                               0);
 }
 
-#endif /* Not ELIDE_CODE.  */
+#endif  /* Not ELIDE_CODE.  */
 \f
 #ifdef TEST
 
@@ -981,68 +980,72 @@ getopt (argc, argv, optstring)
    the above definition of `getopt'.  */
 
 int
-main (argc, argv)
-     int argc;
-     char **argv;
+main(argc, argv)
+int argc;
+char **argv;
 {
-  int c;
-  int digit_optind = 0;
+       int c;
+       int digit_optind = 0;
 
-  while (1)
-    {
-      int this_option_optind = optind ? optind : 1;
+       while(1) {
+               int this_option_optind = optind ? optind : 1;
 
-      c = getopt (argc, argv, "abc:d:0123456789");
-      if (c == -1)
-       break;
+               c = getopt(argc, argv, "abc:d:0123456789");
 
-      switch (c)
-       {
-       case '0':
-       case '1':
-       case '2':
-       case '3':
-       case '4':
-       case '5':
-       case '6':
-       case '7':
-       case '8':
-       case '9':
-         if (digit_optind != 0 && digit_optind != this_option_optind)
-           printf ("digits occur in two different argv-elements.\n");
-         digit_optind = this_option_optind;
-         printf ("option %c\n", c);
-         break;
-
-       case 'a':
-         printf ("option a\n");
-         break;
-
-       case 'b':
-         printf ("option b\n");
-         break;
-
-       case 'c':
-         printf ("option c with value `%s'\n", optarg);
-         break;
-
-       case '?':
-         break;
-
-       default:
-         printf ("?? getopt returned character code 0%o ??\n", c);
+               if(c == -1) {
+                       break;
+               }
+
+               switch(c) {
+               case '0':
+               case '1':
+               case '2':
+               case '3':
+               case '4':
+               case '5':
+               case '6':
+               case '7':
+               case '8':
+               case '9':
+                       if(digit_optind != 0 && digit_optind != this_option_optind) {
+                               printf("digits occur in two different argv-elements.\n");
+                       }
+
+                       digit_optind = this_option_optind;
+                       printf("option %c\n", c);
+                       break;
+
+               case 'a':
+                       printf("option a\n");
+                       break;
+
+               case 'b':
+                       printf("option b\n");
+                       break;
+
+               case 'c':
+                       printf("option c with value `%s'\n", optarg);
+                       break;
+
+               case '?':
+                       break;
+
+               default:
+                       printf("?? getopt returned character code 0%o ??\n", c);
+               }
        }
-    }
 
-  if (optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-       printf ("%s ", argv[optind++]);
-      printf ("\n");
-    }
+       if(optind < argc) {
+               printf("non-option ARGV-elements: ");
+
+               while(optind < argc) {
+                       printf("%s ", argv[optind++]);
+               }
+
+               printf("\n");
+       }
 
-  exit (0);
+       exit(0);
 }
 
 #endif /* TEST */
index 2290d7c..cd77d67 100644 (file)
@@ -22,111 +22,110 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifdef cplusplus
+#ifdef  cplusplus
 extern "C" {
 #endif
 
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
+       /* For communication from `getopt' to the caller.
+          When `getopt' finds an option that takes an argument,
+          the argument value is returned here.
+          Also, when `ordering' is RETURN_IN_ORDER,
+          each non-option ARGV-element is returned here.  */
 
-extern char *optarg;
+       extern char *optarg;
 
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
+       /* Index in ARGV of the next element to be scanned.
+          This is used for communication to and from the caller
+          and for communication between successive calls to `getopt'.
 
-   On entry to `getopt', zero means this is the first call; initialize.
+          On entry to `getopt', zero means this is the first call; initialize.
 
-   When `getopt' returns -1, this is the index of the first of the
-   non-option elements that the caller should itself scan.
+          When `getopt' returns -1, this is the index of the first of the
+          non-option elements that the caller should itself scan.
 
-   Otherwise, `optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
+          Otherwise, `optind' communicates from one call to the next
+          how much of ARGV has been scanned so far.  */
 
-extern int optind;
+       extern int optind;
 
-/* Callers store zero here to inhibit the error message `getopt' prints
-   for unrecognized options.  */
+       /* Callers store zero here to inhibit the error message `getopt' prints
+          for unrecognized options.  */
 
-extern int opterr;
+       extern int opterr;
 
-/* Set to an option character which was unrecognized.  */
+       /* Set to an option character which was unrecognized.  */
 
-extern int optopt;
+       extern int optopt;
 
-/* Describe the long-named options requested by the application.
-   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
-   of `struct option' terminated by an element containing a name which is
-   zero.
+       /* Describe the long-named options requested by the application.
+          The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+          of `struct option' terminated by an element containing a name which is
+          zero.
 
-   The field `has_arg' is:
-   no_argument         (or 0) if the option does not take an argument,
-   required_argument   (or 1) if the option requires an argument,
-   optional_argument   (or 2) if the option takes an optional argument.
+          The field `has_arg' is:
+          no_argument          (or 0) if the option does not take an argument,
+          required_argument    (or 1) if the option requires an argument,
+          optional_argument    (or 2) if the option takes an optional argument.
 
-   If the field `flag' is not NULL, it points to a variable that is set
-   to the value given in the field `val' when the option is found, but
-   left unchanged if the option is not found.
+          If the field `flag' is not NULL, it points to a variable that is set
+          to the value given in the field `val' when the option is found, but
+          left unchanged if the option is not found.
 
-   To have a long-named option do something other than set an `int' to
-   a compiled-in constant, such as set a value from `optarg', set the
-   option's `flag' field to zero and its `val' field to a nonzero
-   value (the equivalent single-letter option character, if there is
-   one).  For long options that have a zero `flag' field, `getopt'
-   returns the contents of the `val' field.  */
+          To have a long-named option do something other than set an `int' to
+          a compiled-in constant, such as set a value from `optarg', set the
+          option's `flag' field to zero and its `val' field to a nonzero
+          value (the equivalent single-letter option character, if there is
+          one).  For long options that have a zero `flag' field, `getopt'
+          returns the contents of the `val' field.  */
 
-struct option
-{
+       struct option {
 #if defined (STDC) && STDC
-  const char *name;
+               const char *name;
 #else
-  char *name;
+               char *name;
 #endif
-  /* has_arg can't be an enum because some compilers complain about
-     type mismatches in all the code that assumes it is an int.  */
-  int has_arg;
-  int *flag;
-  int val;
-};
+               /* has_arg can't be an enum because some compilers complain about
+                  type mismatches in all the code that assumes it is an int.  */
+               int has_arg;
+               int *flag;
+               int val;
+       };
 
-/* Names for the values of the `has_arg' field of `struct option'.  */
+       /* Names for the values of the `has_arg' field of `struct option'.  */
 
-#define        no_argument             0
-#define required_argument      1
-#define optional_argument      2
+#define no_argument             0
+#define required_argument       1
+#define optional_argument       2
 
 #if defined (STDC) && STDC
 #ifdef GNU_LIBRARY
-/* Many other libraries have conflicting prototypes for getopt, with
-   differences in the consts, in stdlib.h.  To avoid compilation
-   errors, only prototype getopt for the GNU C library.  */
-extern int getopt (int argc, char *const *argv, const char *shortopts);
+       /* Many other libraries have conflicting prototypes for getopt, with
+          differences in the consts, in stdlib.h.  To avoid compilation
+          errors, only prototype getopt for the GNU C library.  */
+       extern int getopt(int argc, char *const *argv, const char *shortopts);
 #else /* not GNU_LIBRARY */
-extern int getopt ();
+       extern int getopt();
 #endif /* GNU_LIBRARY */
-extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-                       const struct option *longopts, int *longind);
-extern int getopt_long_only (int argc, char *const *argv,
-                            const char *shortopts,
-                            const struct option *longopts, int *longind);
-
-/* Internal only.  Users should not call this directly.  */
-extern int _getopt_internal (int argc, char *const *argv,
-                            const char *shortopts,
-                            const struct option *longopts, int *longind,
-                            int long_only);
+       extern int getopt_long(int argc, char *const *argv, const char *shortopts,
+                              const struct option *longopts, int *longind);
+       extern int getopt_long_only(int argc, char *const *argv,
+                                   const char *shortopts,
+                                   const struct option *longopts, int *longind);
+
+       /* Internal only.  Users should not call this directly.  */
+       extern int _getopt_internal(int argc, char *const *argv,
+                                   const char *shortopts,
+                                   const struct option *longopts, int *longind,
+                                   int long_only);
 #else /* not STDC */
-extern int getopt ();
-extern int getopt_long ();
-extern int getopt_long_only ();
+       extern int getopt();
+       extern int getopt_long();
+       extern int getopt_long_only();
 
-extern int _getopt_internal ();
+       extern int _getopt_internal();
 #endif /* STDC */
 
-#ifdef cplusplus
+#ifdef  cplusplus
 }
 #endif
 
index 07f5b2d..87ee95e 100644 (file)
@@ -60,19 +60,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <stdlib.h>
 #endif
 
-#ifndef        NULL
+#ifndef NULL
 #define NULL 0
 #endif
 
 int
-getopt_long (argc, argv, options, long_options, opt_index)
-     int argc;
-     char *const *argv;
-     const char *options;
-     const struct option *long_options;
-     int *opt_index;
+getopt_long(argc, argv, options, long_options, opt_index)
+int argc;
+char *const *argv;
+const char *options;
+const struct option *long_options;
+int *opt_index;
 {
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+       return _getopt_internal(argc, argv, options, long_options, opt_index, 0);
 }
 
 /* Like getopt_long, but '-' as well as '--' can indicate a long option.
@@ -81,109 +81,115 @@ getopt_long (argc, argv, options, long_options, opt_index)
    instead.  */
 
 int
-getopt_long_only (argc, argv, options, long_options, opt_index)
-     int argc;
-     char *const *argv;
-     const char *options;
-     const struct option *long_options;
-     int *opt_index;
+getopt_long_only(argc, argv, options, long_options, opt_index)
+int argc;
+char *const *argv;
+const char *options;
+const struct option *long_options;
+int *opt_index;
 {
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+       return _getopt_internal(argc, argv, options, long_options, opt_index, 1);
 }
 
 
-#endif /* Not ELIDE_CODE.  */
+#endif  /* Not ELIDE_CODE.  */
 \f
 #ifdef TEST
 
 #include <stdio.h>
 
 int
-main (argc, argv)
-     int argc;
-     char **argv;
+main(argc, argv)
+int argc;
+char **argv;
 {
-  int c;
-  int digit_optind = 0;
-
-  while (1)
-    {
-      int this_option_optind = optind ? optind : 1;
-      int option_index = 0;
-      static struct option long_options[] =
-      {
-       {"add", 1, 0, 0},
-       {"append", 0, 0, 0},
-       {"delete", 1, 0, 0},
-       {"verbose", 0, 0, 0},
-       {"create", 0, 0, 0},
-       {"file", 1, 0, 0},
-       {0, 0, 0, 0}
-      };
-
-      c = getopt_long (argc, argv, "abc:d:0123456789",
-                      long_options, &option_index);
-      if (c == -1)
-       break;
-
-      switch (c)
-       {
-       case 0:
-         printf ("option %s", long_options[option_index].name);
-         if (optarg)
-           printf (" with arg %s", optarg);
-         printf ("\n");
-         break;
-
-       case '0':
-       case '1':
-       case '2':
-       case '3':
-       case '4':
-       case '5':
-       case '6':
-       case '7':
-       case '8':
-       case '9':
-         if (digit_optind != 0 && digit_optind != this_option_optind)
-           printf ("digits occur in two different argv-elements.\n");
-         digit_optind = this_option_optind;
-         printf ("option %c\n", c);
-         break;
-
-       case 'a':
-         printf ("option a\n");
-         break;
-
-       case 'b':
-         printf ("option b\n");
-         break;
-
-       case 'c':
-         printf ("option c with value `%s'\n", optarg);
-         break;
-
-       case 'd':
-         printf ("option d with value `%s'\n", optarg);
-         break;
-
-       case '?':
-         break;
-
-       default:
-         printf ("?? getopt returned character code 0%o ??\n", c);
+       int c;
+       int digit_optind = 0;
+
+       while(1) {
+               int this_option_optind = optind ? optind : 1;
+               int option_index = 0;
+               static struct option long_options[] = {
+                       {"add", 1, 0, 0},
+                       {"append", 0, 0, 0},
+                       {"delete", 1, 0, 0},
+                       {"verbose", 0, 0, 0},
+                       {"create", 0, 0, 0},
+                       {"file", 1, 0, 0},
+                       {0, 0, 0, 0}
+               };
+
+               c = getopt_long(argc, argv, "abc:d:0123456789",
+                               long_options, &option_index);
+
+               if(c == -1) {
+                       break;
+               }
+
+               switch(c) {
+               case 0:
+                       printf("option %s", long_options[option_index].name);
+
+                       if(optarg) {
+                               printf(" with arg %s", optarg);
+                       }
+
+                       printf("\n");
+                       break;
+
+               case '0':
+               case '1':
+               case '2':
+               case '3':
+               case '4':
+               case '5':
+               case '6':
+               case '7':
+               case '8':
+               case '9':
+                       if(digit_optind != 0 && digit_optind != this_option_optind) {
+                               printf("digits occur in two different argv-elements.\n");
+                       }
+
+                       digit_optind = this_option_optind;
+                       printf("option %c\n", c);
+                       break;
+
+               case 'a':
+                       printf("option a\n");
+                       break;
+
+               case 'b':
+                       printf("option b\n");
+                       break;
+
+               case 'c':
+                       printf("option c with value `%s'\n", optarg);
+                       break;
+
+               case 'd':
+                       printf("option d with value `%s'\n", optarg);
+                       break;
+
+               case '?':
+                       break;
+
+               default:
+                       printf("?? getopt returned character code 0%o ??\n", c);
+               }
        }
-    }
 
-  if (optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-       printf ("%s ", argv[optind++]);
-      printf ("\n");
-    }
+       if(optind < argc) {
+               printf("non-option ARGV-elements: ");
 
-  exit (0);
+               while(optind < argc) {
+                       printf("%s ", argv[optind++]);
+               }
+
+               printf("\n");
+       }
+
+       exit(0);
 }
 
 #endif /* TEST */
index 5b90c62..832e017 100644 (file)
@@ -84,8 +84,9 @@ static void mst_kruskal(void) {
 
        /* Do we have something to do at all? */
 
-       if(!edge_weight_tree->head)
+       if(!edge_weight_tree->head) {
                return;
+       }
 
        ifdebug(SCARY_THINGS) logger(LOG_DEBUG, "Running Kruskal's algorithm:");
 
@@ -101,6 +102,7 @@ static void mst_kruskal(void) {
 
        for(node = edge_weight_tree->head; node; node = node->next) {
                e = node->data;
+
                if(e->from->status.reachable) {
                        e->from->status.visited = true;
                        break;
@@ -121,16 +123,18 @@ static void mst_kruskal(void) {
                e->from->status.visited = true;
                e->to->status.visited = true;
 
-               if(e->connection)
+               if(e->connection) {
                        e->connection->status.mst = true;
+               }
 
-               if(e->reverse->connection)
+               if(e->reverse->connection) {
                        e->reverse->connection->status.mst = true;
+               }
 
                safe_edges++;
 
                ifdebug(SCARY_THINGS) logger(LOG_DEBUG, " Adding edge %s - %s weight %d", e->from->name,
-                                  e->to->name, e->weight);
+                                            e->to->name, e->weight);
 
                if(skipped) {
                        skipped = false;
@@ -140,7 +144,7 @@ static void mst_kruskal(void) {
        }
 
        ifdebug(SCARY_THINGS) logger(LOG_DEBUG, "Done, counted %d nodes and %d safe edges.", nodes,
-                          safe_edges);
+                                    safe_edges);
 }
 
 /* Implementation of a simple breadth-first search algorithm.
@@ -180,22 +184,23 @@ static void sssp_bfs(void) {
 
        /* Loop while todo_list is filled */
 
-       for(from = todo_list->head; from; from = todonext) {    /* "from" is the node from which we start */
+       for(from = todo_list->head; from; from = todonext) {    /* "from" is the node from which we start */
                n = from->data;
 
-               for(to = n->edge_tree->head; to; to = to->next) {       /* "to" is the edge connected to "from" */
+               for(to = n->edge_tree->head; to; to = to->next) {       /* "to" is the edge connected to "from" */
                        e = to->data;
 
-                       if(!e->reverse)
+                       if(!e->reverse) {
                                continue;
+                       }
 
                        /* Situation:
 
-                                  /
-                                 /
+                                  /
+                                 /
                           ----->(n)---e-->(e->to)
-                                 \
-                                  \
+                                 \
+                                  \
 
                           Where e is an edge, (n) and (e->to) are nodes.
                           n->address is set to the e->address of the edge left of n to n.
@@ -209,13 +214,15 @@ static void sssp_bfs(void) {
                        indirect = n->status.indirect || e->options & OPTION_INDIRECT;
 
                        if(e->to->status.visited
-                          && (!e->to->status.indirect || indirect))
+                                       && (!e->to->status.indirect || indirect)) {
                                continue;
+                       }
 
                        // Only update nexthop the first time we visit this node.
 
-                       if(!e->to->status.visited)
+                       if(!e->to->status.visited) {
                                e->to->nexthop = (n->nexthop == myself) ? e->to : n->nexthop;
+                       }
 
                        e->to->status.visited = true;
                        e->to->status.indirect = indirect;
@@ -223,8 +230,9 @@ static void sssp_bfs(void) {
                        e->to->via = indirect ? n->via : e->to;
                        e->to->options = e->options;
 
-                       if(e->to->address.sa.sa_family == AF_UNSPEC && e->address.sa.sa_family != AF_UNKNOWN)
+                       if(e->to->address.sa.sa_family == AF_UNSPEC && e->address.sa.sa_family != AF_UNKNOWN) {
                                update_node_udp(e->to, &e->address);
+                       }
 
                        list_insert_tail(todo_list, e->to);
                }
@@ -246,10 +254,10 @@ static void sssp_bfs(void) {
 
                        if(n->status.reachable) {
                                ifdebug(TRAFFIC) logger(LOG_DEBUG, "Node %s (%s) became reachable",
-                                          n->name, n->hostname);
+                                                       n->name, n->hostname);
                        } else {
                                ifdebug(TRAFFIC) logger(LOG_DEBUG, "Node %s (%s) became unreachable",
-                                          n->name, n->hostname);
+                                                       n->name, n->hostname);
                        }
 
                        /* TODO: only clear status.validkey if node is unreachable? */
@@ -278,16 +286,17 @@ static void sssp_bfs(void) {
                        execute_script(n->status.reachable ? "host-up" : "host-down", envp);
 
                        xasprintf(&name,
-                                        n->status.reachable ? "hosts/%s-up" : "hosts/%s-down",
-                                        n->name);
+                                 n->status.reachable ? "hosts/%s-up" : "hosts/%s-down",
+                                 n->name);
                        execute_script(name, envp);
 
                        free(name);
                        free(address);
                        free(port);
 
-                       for(i = 0; i < 7; i++)
+                       for(i = 0; i < 7; i++) {
                                free(envp[i]);
+                       }
 
                        subnet_update(n, NULL, n->status.reachable);
 
@@ -312,7 +321,7 @@ void graph(void) {
 
 
 /* Dump nodes and edges to a graphviz file.
-          
+
    The file can be converted to an image with
    dot -Tpng graph_filename -o image_filename.png -Gconcentrate=true
 */
@@ -323,14 +332,15 @@ void dump_graph(void) {
        edge_t *e;
        char *filename = NULL, *tmpname = NULL;
        FILE *file, *pipe = NULL;
-       
-       if(!graph_changed || !get_config_string(lookup_config(config_tree, "GraphDumpFile"), &filename))
+
+       if(!graph_changed || !get_config_string(lookup_config(config_tree, "GraphDumpFile"), &filename)) {
                return;
+       }
 
        graph_changed = false;
 
        ifdebug(PROTOCOL) logger(LOG_NOTICE, "Dumping graph");
-       
+
        if(filename[0] == '|') {
                file = pipe = popen(filename + 1, "w");
        } else {
@@ -346,7 +356,7 @@ void dump_graph(void) {
        }
 
        fprintf(file, "digraph {\n");
-       
+
        /* dump all nodes first */
        for(node = node_tree->head; node; node = node->next) {
                n = node->data;
@@ -359,8 +369,8 @@ void dump_graph(void) {
                fprintf(file, " %s -> %s;\n", e->from->name, e->to->name);
        }
 
-       fprintf(file, "}\n");   
-       
+       fprintf(file, "}\n");
+
        if(pipe) {
                pclose(pipe);
        } else {
@@ -368,8 +378,11 @@ void dump_graph(void) {
 #ifdef HAVE_MINGW
                unlink(filename);
 #endif
-               if(rename(tmpname, filename))
+
+               if(rename(tmpname, filename)) {
                        logger(LOG_ERR, "Could not rename %s to %s: %s\n", tmpname, filename, strerror(errno));
+               }
+
                free(tmpname);
        }
 
index 5fc1afe..7f45ad7 100644 (file)
 #ifndef HAVE_STRUCT_IP
 struct ip {
 #if BYTE_ORDER == LITTLE_ENDIAN
-       unsigned int ip_hl:4;
-       unsigned int ip_v:4;
+       unsigned int ip_hl: 4;
+       unsigned int ip_v: 4;
 #else
-       unsigned int ip_v:4;
-       unsigned int ip_hl:4;
+       unsigned int ip_v: 4;
+       unsigned int ip_hl: 4;
 #endif
        uint8_t ip_tos;
        uint16_t ip_len;
-       uint16_t ip_id; 
+       uint16_t ip_id;
        uint16_t ip_off;
 #define IP_RF 0x8000
 #define IP_DF 0x4000
@@ -81,7 +81,7 @@ struct ip {
        uint8_t ip_p;
        uint16_t ip_sum;
        struct in_addr ip_src, ip_dst;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #endif
 
 #ifndef IP_OFFMASK
@@ -143,7 +143,7 @@ struct icmp {
 #define icmp_radv icmp_dun.id_radv
 #define icmp_mask icmp_dun.id_mask
 #define icmp_data icmp_dun.id_data
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #endif
 
 #endif
index b6862b6..1642278 100644 (file)
@@ -36,7 +36,7 @@ struct in6_addr {
                uint16_t u6_addr16[8];
                uint32_t u6_addr32[4];
        } in6_u;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #define s6_addr in6_u.u6_addr8
 #define s6_addr16 in6_u.u6_addr16
 #define s6_addr32 in6_u.u6_addr32
@@ -49,14 +49,14 @@ struct sockaddr_in6 {
        uint32_t sin6_flowinfo;
        struct in6_addr sin6_addr;
        uint32_t sin6_scope_id;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #endif
 
 #ifndef IN6_IS_ADDR_V4MAPPED
 #define IN6_IS_ADDR_V4MAPPED(a) \
-        ((((const uint32_t *) (a))[0] == 0) \
-        && (((const uint32_t *) (a))[1] == 0) \
-        && (((const uint32_t *) (a))[2] == htonl (0xffff)))
+       ((((const uint32_t *) (a))[0] == 0) \
+        && (((const uint32_t *) (a))[1] == 0) \
+        && (((const uint32_t *) (a))[2] == htonl (0xffff)))
 #endif
 
 #ifndef HAVE_STRUCT_IP6_HDR
@@ -72,7 +72,7 @@ struct ip6_hdr {
        } ip6_ctlun;
        struct in6_addr ip6_src;
        struct in6_addr ip6_dst;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #define ip6_vfc ip6_ctlun.ip6_un2_vfc
 #define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow
 #define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen
@@ -91,7 +91,7 @@ struct icmp6_hdr {
                uint16_t icmp6_un_data16[2];
                uint8_t icmp6_un_data8[4];
        } icmp6_dataun;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #define ICMP6_DST_UNREACH_NOROUTE 0
 #define ICMP6_DST_UNREACH 1
 #define ICMP6_PACKET_TOO_BIG 2
@@ -111,7 +111,7 @@ struct icmp6_hdr {
 struct nd_neighbor_solicit {
        struct icmp6_hdr nd_ns_hdr;
        struct in6_addr nd_ns_target;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #define ND_OPT_SOURCE_LINKADDR 1
 #define ND_OPT_TARGET_LINKADDR 2
 #define nd_ns_type nd_ns_hdr.icmp6_type
@@ -124,7 +124,7 @@ struct nd_neighbor_solicit {
 struct nd_opt_hdr {
        uint8_t nd_opt_type;
        uint8_t nd_opt_len;
-} __attribute__ ((__packed__));
+} __attribute__((__packed__));
 #endif
 
 #endif
index 8d042d2..f75f4bd 100644 (file)
@@ -56,13 +56,16 @@ static bool setup_device(void) {
        struct ifreq ifr;
        bool t1q = false;
 
-       if(!get_config_string(lookup_config(config_tree, "Device"), &device))
+       if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
                device = xstrdup(DEFAULT_DEVICE);
+       }
 
        if(!get_config_string(lookup_config(config_tree, "Interface"), &iface))
 #ifdef HAVE_LINUX_IF_TUN_H
-               if (netname != NULL)
+               if(netname != NULL) {
                        iface = xstrdup(netname);
+               }
+
 #else
                iface = xstrdup(strrchr(device, '/') ? strrchr(device, '/') + 1 : device);
 #endif
@@ -94,17 +97,22 @@ static bool setup_device(void) {
                device_type = DEVICE_TYPE_TUN;
                device_info = "Linux tun/tap device (tun mode)";
        } else {
-               if (routing_mode == RMODE_ROUTER)
+               if(routing_mode == RMODE_ROUTER) {
                        overwrite_mac = true;
+               }
+
                ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
                device_type = DEVICE_TYPE_TAP;
                device_info = "Linux tun/tap device (tap mode)";
        }
 
 #ifdef IFF_ONE_QUEUE
+
        /* Set IFF_ONE_QUEUE flag... */
-       if(get_config_bool(lookup_config(config_tree, "IffOneQueue"), &t1q) && t1q)
+       if(get_config_bool(lookup_config(config_tree, "IffOneQueue"), &t1q) && t1q) {
                ifr.ifr_flags |= IFF_ONE_QUEUE;
+       }
+
 #endif
 
        if(iface) {
@@ -126,16 +134,19 @@ static bool setup_device(void) {
        } else
 #endif
        {
-               if(routing_mode == RMODE_ROUTER)
+               if(routing_mode == RMODE_ROUTER) {
                        overwrite_mac = true;
+               }
+
                device_info = "Linux ethertap device";
                device_type = DEVICE_TYPE_ETHERTAP;
                free(iface);
                iface = xstrdup(strrchr(device, '/') ? strrchr(device, '/') + 1 : device);
        }
 
-       if(overwrite_mac && !ioctl(device_fd, SIOCGIFHWADDR, &ifr))
+       if(overwrite_mac && !ioctl(device_fd, SIOCGIFHWADDR, &ifr)) {
                memcpy(mymac.x, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
+       }
 
        logger(LOG_INFO, "%s is a %s", device, device_info);
 
@@ -152,81 +163,89 @@ static void close_device(void) {
 
 static bool read_packet(vpn_packet_t *packet) {
        int lenin;
-       
+
        switch(device_type) {
-               case DEVICE_TYPE_TUN:
-                       lenin = read(device_fd, packet->data + 10, MTU - 10);
-
-                       if(lenin <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s",
-                                          device_info, device, strerror(errno));
-                               return false;
-                       }
-
-                       memset(packet->data, 0, 12);
-                       packet->len = lenin + 10;
-                       break;
-               case DEVICE_TYPE_TAP:
-                       lenin = read(device_fd, packet->data, MTU);
-
-                       if(lenin <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s",
-                                          device_info, device, strerror(errno));
-                               return false;
-                       }
-
-                       packet->len = lenin;
-                       break;
-               case DEVICE_TYPE_ETHERTAP:
-                       lenin = read(device_fd, packet->data - 2, MTU + 2);
-
-                       if(lenin <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s",
-                                          device_info, device, strerror(errno));
-                               return false;
-                       }
-
-                       packet->len = lenin - 2;
-                       break;
+       case DEVICE_TYPE_TUN:
+               lenin = read(device_fd, packet->data + 10, MTU - 10);
+
+               if(lenin <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s",
+                              device_info, device, strerror(errno));
+                       return false;
+               }
+
+               memset(packet->data, 0, 12);
+               packet->len = lenin + 10;
+               break;
+
+       case DEVICE_TYPE_TAP:
+               lenin = read(device_fd, packet->data, MTU);
+
+               if(lenin <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s",
+                              device_info, device, strerror(errno));
+                       return false;
+               }
+
+               packet->len = lenin;
+               break;
+
+       case DEVICE_TYPE_ETHERTAP:
+               lenin = read(device_fd, packet->data - 2, MTU + 2);
+
+               if(lenin <= 0) {
+                       logger(LOG_ERR, "Error while reading from %s %s: %s",
+                              device_info, device, strerror(errno));
+                       return false;
+               }
+
+               packet->len = lenin - 2;
+               break;
        }
 
        device_total_in += packet->len;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
-                          device_info);
+                               device_info);
 
        return true;
 }
 
 static bool write_packet(vpn_packet_t *packet) {
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
        switch(device_type) {
-               case DEVICE_TYPE_TUN:
-                       packet->data[10] = packet->data[11] = 0;
-                       if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
-                               logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
-                                          strerror(errno));
-                               return false;
-                       }
-                       break;
-               case DEVICE_TYPE_TAP:
-                       if(write(device_fd, packet->data, packet->len) < 0) {
-                               logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
-                                          strerror(errno));
-                               return false;
-                       }
-                       break;
-               case DEVICE_TYPE_ETHERTAP:
-                       memcpy(packet->data - 2, &packet->len, 2);
-
-                       if(write(device_fd, packet->data - 2, packet->len + 2) < 0) {
-                               logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
-                                          strerror(errno));
-                               return false;
-                       }
-                       break;
+       case DEVICE_TYPE_TUN:
+               packet->data[10] = packet->data[11] = 0;
+
+               if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
+                       logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
+                              strerror(errno));
+                       return false;
+               }
+
+               break;
+
+       case DEVICE_TYPE_TAP:
+               if(write(device_fd, packet->data, packet->len) < 0) {
+                       logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
+                              strerror(errno));
+                       return false;
+               }
+
+               break;
+
+       case DEVICE_TYPE_ETHERTAP:
+               memcpy(packet->data - 2, &packet->len, 2);
+
+               if(write(device_fd, packet->data - 2, packet->len + 2) < 0) {
+                       logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
+                              strerror(errno));
+                       return false;
+               }
+
+               break;
        }
 
        device_total_out += packet->len;
index a26c58d..a807c6d 100644 (file)
@@ -43,8 +43,9 @@ list_node_t *list_alloc_node(void) {
 }
 
 void list_free_node(list_t *list, list_node_t *node) {
-       if(node->data && list->delete)
+       if(node->data && list->delete) {
                list->delete(node->data);
+       }
 
        free(node);
 }
@@ -61,10 +62,11 @@ list_node_t *list_insert_head(list_t *list, void *data) {
        node->next = list->head;
        list->head = node;
 
-       if(node->next)
+       if(node->next) {
                node->next->prev = node;
-       else
+       } else {
                list->tail = node;
+       }
 
        list->count++;
 
@@ -81,10 +83,11 @@ list_node_t *list_insert_tail(list_t *list, void *data) {
        node->prev = list->tail;
        list->tail = node;
 
-       if(node->prev)
+       if(node->prev) {
                node->prev->next = node;
-       else
+       } else {
                list->head = node;
+       }
 
        list->count++;
 
@@ -92,15 +95,17 @@ list_node_t *list_insert_tail(list_t *list, void *data) {
 }
 
 void list_unlink_node(list_t *list, list_node_t *node) {
-       if(node->prev)
+       if(node->prev) {
                node->prev->next = node->next;
-       else
+       } else {
                list->head = node->next;
+       }
 
-       if(node->next)
+       if(node->next) {
                node->next->prev = node->prev;
-       else
+       } else {
                list->tail = node->prev;
+       }
 
        list->count--;
 }
@@ -121,17 +126,19 @@ void list_delete_tail(list_t *list) {
 /* Head/tail lookup */
 
 void *list_get_head(list_t *list) {
-       if(list->head)
+       if(list->head) {
                return list->head->data;
-       else
+       } else {
                return NULL;
+       }
 }
 
 void *list_get_tail(list_t *list) {
-       if(list->tail)
+       if(list->tail) {
                return list->tail->data;
-       else
+       } else {
                return NULL;
+       }
 }
 
 /* Fast list deletion */
@@ -163,7 +170,9 @@ void list_foreach(list_t *list, list_action_t action) {
 
        for(node = list->head; node; node = next) {
                next = node->next;
-               if(node->data)
+
+               if(node->data) {
                        action(node->data);
+               }
        }
 }
index 2b22c04..69d1ff4 100644 (file)
@@ -45,7 +45,7 @@ typedef struct list_t {
 
 /* (De)constructors */
 
-extern list_t *list_alloc(list_action_t) __attribute__ ((__malloc__));
+extern list_t *list_alloc(list_action_t) __attribute__((__malloc__));
 extern void list_free(list_t *);
 extern list_node_t *list_alloc_node(void);
 extern void list_free_node(list_t *, list_node_t *);
index 77c8133..89dbe26 100644 (file)
@@ -36,48 +36,58 @@ static const char *logident = NULL;
 void openlogger(const char *ident, logmode_t mode) {
        logident = ident;
        logmode = mode;
-       
+
        switch(mode) {
-               case LOGMODE_STDERR:
-                       logpid = getpid();
-                       break;
-               case LOGMODE_FILE:
-                       logpid = getpid();
-                       logfile = fopen(logfilename, "a");
-                       if(!logfile) {
-                               fprintf(stderr, "Could not open log file %s: %s\n", logfilename, strerror(errno));
-                               logmode = LOGMODE_NULL;
-                       }
-                       break;
-               case LOGMODE_SYSLOG:
+       case LOGMODE_STDERR:
+               logpid = getpid();
+               break;
+
+       case LOGMODE_FILE:
+               logpid = getpid();
+               logfile = fopen(logfilename, "a");
+
+               if(!logfile) {
+                       fprintf(stderr, "Could not open log file %s: %s\n", logfilename, strerror(errno));
+                       logmode = LOGMODE_NULL;
+               }
+
+               break;
+
+       case LOGMODE_SYSLOG:
 #ifdef HAVE_MINGW
-                       loghandle = RegisterEventSource(NULL, logident);
-                       if(!loghandle) {
-                               fprintf(stderr, "Could not open log handle!");
-                               logmode = LOGMODE_NULL;
-                       }
-                       break;
+               loghandle = RegisterEventSource(NULL, logident);
+
+               if(!loghandle) {
+                       fprintf(stderr, "Could not open log handle!");
+                       logmode = LOGMODE_NULL;
+               }
+
+               break;
 #else
 #ifdef HAVE_SYSLOG_H
-                       openlog(logident, LOG_CONS | LOG_PID, LOG_DAEMON);
-                       break;
+               openlog(logident, LOG_CONS | LOG_PID, LOG_DAEMON);
+               break;
 #endif
 #endif
-               case LOGMODE_NULL:
-                       break;
+
+       case LOGMODE_NULL:
+               break;
        }
 }
 
 void reopenlogger() {
-       if(logmode != LOGMODE_FILE)
+       if(logmode != LOGMODE_FILE) {
                return;
+       }
 
        fflush(logfile);
        FILE *newfile = fopen(logfilename, "a");
+
        if(!newfile) {
                logger(LOG_ERR, "Unable to reopen log file %s: %s", logfilename, strerror(errno));
                return;
        }
+
        fclose(logfile);
        logfile = newfile;
 }
@@ -90,44 +100,48 @@ void logger(int priority, const char *format, ...) {
        va_start(ap, format);
 
        switch(logmode) {
-               case LOGMODE_STDERR:
-                       vfprintf(stderr, format, ap);
-                       fprintf(stderr, "\n");
-                       fflush(stderr);
-                       break;
-               case LOGMODE_FILE:
-                       now = time(NULL);
-                       strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", localtime(&now));
-                       fprintf(logfile, "%s %s[%ld]: ", timestr, logident, (long)logpid);
-                       vfprintf(logfile, format, ap);
-                       fprintf(logfile, "\n");
-                       fflush(logfile);
-                       break;
-               case LOGMODE_SYSLOG:
+       case LOGMODE_STDERR:
+               vfprintf(stderr, format, ap);
+               fprintf(stderr, "\n");
+               fflush(stderr);
+               break;
+
+       case LOGMODE_FILE:
+               now = time(NULL);
+               strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", localtime(&now));
+               fprintf(logfile, "%s %s[%ld]: ", timestr, logident, (long)logpid);
+               vfprintf(logfile, format, ap);
+               fprintf(logfile, "\n");
+               fflush(logfile);
+               break;
+
+       case LOGMODE_SYSLOG:
 #ifdef HAVE_MINGW
-                       {
-                               char message[4096];
-                               const char *messages[] = {message};
-                               vsnprintf(message, sizeof(message), format, ap);
-                               message[sizeof(message) - 1] = 0;
-                               ReportEvent(loghandle, priority, 0, 0, NULL, 1, 0, messages, NULL);
-                       }
+               {
+                       char message[4096];
+                       const char *messages[] = {message};
+                       vsnprintf(message, sizeof(message), format, ap);
+                       message[sizeof(message) - 1] = 0;
+                       ReportEvent(loghandle, priority, 0, 0, NULL, 1, 0, messages, NULL);
+               }
+
 #else
 #ifdef HAVE_SYSLOG_H
 #ifdef HAVE_VSYSLOG
-                       vsyslog(priority, format, ap);
+               vsyslog(priority, format, ap);
 #else
-                       {
-                               char message[4096];
-                               vsnprintf(message, sizeof(message), format, ap);
-                               syslog(priority, "%s", message);
-                       }
+               {
+                       char message[4096];
+                       vsnprintf(message, sizeof(message), format, ap);
+                       syslog(priority, "%s", message);
+               }
 #endif
-                       break;
+               break;
 #endif
 #endif
-               case LOGMODE_NULL:
-                       break;
+
+       case LOGMODE_NULL:
+               break;
        }
 
        va_end(ap);
@@ -135,22 +149,24 @@ void logger(int priority, const char *format, ...) {
 
 void closelogger(void) {
        switch(logmode) {
-               case LOGMODE_FILE:
-                       fclose(logfile);
-                       break;
-               case LOGMODE_SYSLOG:
+       case LOGMODE_FILE:
+               fclose(logfile);
+               break;
+
+       case LOGMODE_SYSLOG:
 #ifdef HAVE_MINGW
-                       DeregisterEventSource(loghandle);
-                       break;
+               DeregisterEventSource(loghandle);
+               break;
 #else
 #ifdef HAVE_SYSLOG_H
-                       closelog();
-                       break;
+               closelog();
+               break;
 #endif
 #endif
-               case LOGMODE_NULL:
-               case LOGMODE_STDERR:
-                       break;
-                       break;
+
+       case LOGMODE_NULL:
+       case LOGMODE_STDERR:
+               break;
+               break;
        }
 }
index f50c17e..1c5d80e 100644 (file)
 */
 
 typedef enum debug_t {
-       DEBUG_NOTHING = 0,                      /* Quiet mode, only show starting/stopping of the daemon */
+       DEBUG_NOTHING = 0,                      /* Quiet mode, only show starting/stopping of the daemon */
        DEBUG_ALWAYS = 0,
-       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_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_t;
 
 typedef enum logmode_t {
@@ -67,7 +67,7 @@ enum {
 extern debug_t debug_level;
 extern void openlogger(const char *, logmode_t);
 extern void reopenlogger(void);
-extern void logger(int, const char *, ...) __attribute__ ((__format__(printf, 2, 3)));
+extern void logger(int, const char *, ...) __attribute__((__format__(printf, 2, 3)));
 extern void closelogger(void);
 
 #define ifdebug(l) if(debug_level >= DEBUG_##l)
index 60814c7..4930818 100644 (file)
@@ -39,10 +39,11 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
        int result;
 
        ifdebug(META) logger(LOG_DEBUG, "Sending %d bytes of metadata to %s (%s)", length,
-                          c->name, c->hostname);
+                            c->name, c->hostname);
 
-       if(!c->outbuflen)
+       if(!c->outbuflen) {
                c->last_flushed_time = now;
+       }
 
        /* Find room in connection's buffer */
        if(length + c->outbuflen > c->outbufsize) {
@@ -66,15 +67,17 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
                }
 
                result = EVP_EncryptUpdate(c->outctx, (unsigned char *)c->outbuf + c->outbufstart + c->outbuflen,
-                               &outlen, (unsigned char *)buffer, length);
+                                          &outlen, (unsigned char *)buffer, length);
+
                if(!result || outlen < length) {
                        logger(LOG_ERR, "Error while encrypting metadata to %s (%s): %s",
-                                       c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
+                              c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
                        return false;
                } else if(outlen > length) {
                        logger(LOG_EMERG, "Encrypted data too long! Heap corrupted!");
                        abort();
                }
+
                c->outbuflen += outlen;
        } else {
                memcpy(c->outbuf + c->outbufstart + c->outbuflen, buffer, length);
@@ -86,25 +89,26 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
 
 bool flush_meta(connection_t *c) {
        int result;
-       
+
        ifdebug(META) logger(LOG_DEBUG, "Flushing %d bytes to %s (%s)",
-                        c->outbuflen, c->name, c->hostname);
+                            c->outbuflen, c->name, c->hostname);
 
        while(c->outbuflen) {
                result = send(c->socket, c->outbuf + c->outbufstart, c->outbuflen, 0);
+
                if(result <= 0) {
                        if(!errno || errno == EPIPE) {
                                ifdebug(CONNECTIONS) logger(LOG_NOTICE, "Connection closed by %s (%s)",
-                                                  c->name, c->hostname);
+                                                           c->name, c->hostname);
                        } else if(errno == EINTR) {
                                continue;
                        } else if(sockwouldblock(sockerrno)) {
                                ifdebug(META) logger(LOG_DEBUG, "Flushing %d bytes to %s (%s) would block",
-                                               c->outbuflen, c->name, c->hostname);
+                                                    c->outbuflen, c->name, c->hostname);
                                return true;
                        } else {
                                logger(LOG_ERR, "Flushing meta data to %s (%s) failed: %s", c->name,
-                                          c->hostname, sockstrerror(sockerrno));
+                                      c->hostname, sockstrerror(sockerrno));
                        }
 
                        return false;
@@ -125,8 +129,9 @@ void broadcast_meta(connection_t *from, const char *buffer, int length) {
        for(node = connection_tree->head; node; node = node->next) {
                c = node->data;
 
-               if(c != from && c->status.active)
+               if(c != from && c->status.active) {
                        send_meta(c, buffer, length);
+               }
        }
 }
 
@@ -150,12 +155,12 @@ bool receive_meta(connection_t *c) {
        if(lenin <= 0) {
                if(!lenin || !errno) {
                        ifdebug(CONNECTIONS) logger(LOG_NOTICE, "Connection closed by %s (%s)",
-                                          c->name, c->hostname);
-               } else if(sockwouldblock(sockerrno))
+                                                   c->name, c->hostname);
+               } else if(sockwouldblock(sockerrno)) {
                        return true;
-               else
+               else
                        logger(LOG_ERR, "Metadata socket read error for %s (%s): %s",
-                                  c->name, c->hostname, sockstrerror(sockerrno));
+                              c->name, c->hostname, sockstrerror(sockerrno));
 
                return false;
        }
@@ -170,8 +175,11 @@ bool receive_meta(connection_t *c) {
 
                if(c->allow_request == PROXY) {
                        reqlen = receive_proxy_meta(c, oldlen, lenin);
-                       if(reqlen < 0)
+
+                       if(reqlen < 0) {
                                return false;
+                       }
+
                        goto consume;
                }
 
@@ -187,11 +195,13 @@ bool receive_meta(connection_t *c) {
                        }
 
                        result = EVP_DecryptUpdate(c->inctx, (unsigned char *)inbuf, &lenout, (unsigned char *)c->buffer + oldlen, lenin);
+
                        if(!result || lenout != lenin) {
                                logger(LOG_ERR, "Error while decrypting metadata from %s (%s): %s",
-                                               c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
+                                      c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
                                return false;
                        }
+
                        memcpy(c->buffer + oldlen, inbuf, lenin);
                        decrypted = true;
                }
@@ -214,17 +224,19 @@ bool receive_meta(connection_t *c) {
 
                        for(i = oldlen; i < c->buflen; i++) {
                                if(c->buffer[i] == '\n') {
-                                       c->buffer[i] = '\0';    /* replace end-of-line by end-of-string so we can use sscanf */
+                                       c->buffer[i] = '\0';    /* replace end-of-line by end-of-string so we can use sscanf */
                                        c->reqlen = reqlen = i + 1;
                                        break;
                                }
                        }
 
-                       if(reqlen && !receive_request(c))
+                       if(reqlen && !receive_request(c)) {
                                return false;
+                       }
                }
 
 consume:
+
                if(reqlen) {
                        c->buflen -= reqlen;
                        lenin -= reqlen - oldlen;
@@ -238,7 +250,7 @@ consume:
 
        if(c->buflen >= MAXBUFSIZE) {
                logger(LOG_ERR, "Metadata read buffer overflow for %s (%s)",
-                          c->name, c->hostname);
+                      c->name, c->hostname);
                return false;
        }
 
index 6e5e75c..41b9dc5 100644 (file)
@@ -37,7 +37,7 @@
 //=============
 
 #define TAP_CONTROL_CODE(request,method) \
-  CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
+       CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
 
 #define TAP_IOCTL_GET_MAC               TAP_CONTROL_CODE (1, METHOD_BUFFERED)
 #define TAP_IOCTL_GET_VERSION           TAP_CONTROL_CODE (2, METHOD_BUFFERED)
index 3ff6759..341d7a9 100644 (file)
@@ -66,17 +66,21 @@ static DWORD WINAPI tapreader(void *bla) {
                if(!status) {
                        if(GetLastError() == ERROR_IO_PENDING) {
                                WaitForSingleObject(r_overlapped.hEvent, INFINITE);
-                               if(!GetOverlappedResult(device_handle, &r_overlapped, &len, FALSE))
+
+                               if(!GetOverlappedResult(device_handle, &r_overlapped, &len, FALSE)) {
                                        continue;
+                               }
                        } else {
                                logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                                          device, strerror(errno));
+                                      device, strerror(errno));
                                errors++;
+
                                if(errors >= 10) {
                                        EnterCriticalSection(&mutex);
                                        running = false;
                                        LeaveCriticalSection(&mutex);
                                }
+
                                usleep(1000000);
                                continue;
                        }
@@ -113,8 +117,9 @@ static bool setup_device(void) {
        get_config_string(lookup_config(config_tree, "Device"), &device);
        get_config_string(lookup_config(config_tree, "Interface"), &iface);
 
-       if(device && iface)
+       if(device && iface) {
                logger(LOG_WARNING, "Warning: both Device and Interface specified, results may not be as expected");
+       }
 
        /* Open registry and look for network adapters */
 
@@ -123,44 +128,51 @@ static bool setup_device(void) {
                return false;
        }
 
-       for (i = 0; ; i++) {
+       for(i = 0; ; i++) {
                len = sizeof(adapterid);
-               if(RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL))
+
+               if(RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL)) {
                        break;
+               }
 
                /* Find out more about this adapter */
 
                snprintf(regpath, sizeof(regpath), "%s\\%s\\Connection", NETWORK_CONNECTIONS_KEY, adapterid);
 
-                if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regpath, 0, KEY_READ, &key2))
+               if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regpath, 0, KEY_READ, &key2)) {
                        continue;
+               }
 
                len = sizeof(adaptername);
                err = RegQueryValueEx(key2, "Name", 0, 0, (LPBYTE)adaptername, &len);
 
                RegCloseKey(key2);
 
-               if(err)
+               if(err) {
                        continue;
+               }
 
                if(device) {
                        if(!strcmp(device, adapterid)) {
                                found = true;
                                break;
-                       } else
+                       } else {
                                continue;
+                       }
                }
 
                if(iface) {
                        if(!strcmp(iface, adaptername)) {
                                found = true;
                                break;
-                       } else
+                       } else {
                                continue;
+                       }
                }
 
                snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, adapterid);
                device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
+
                if(device_handle != INVALID_HANDLE_VALUE) {
                        found = true;
                        break;
@@ -174,11 +186,13 @@ static bool setup_device(void) {
                return false;
        }
 
-       if(!device)
+       if(!device) {
                device = xstrdup(adapterid);
+       }
 
-       if(!iface)
+       if(!iface) {
                iface = xstrdup(adaptername);
+       }
 
        /* Try to open the corresponding tap device */
 
@@ -186,7 +200,7 @@ static bool setup_device(void) {
                snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, device);
                device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
        }
-       
+
        if(device_handle == INVALID_HANDLE_VALUE) {
                logger(LOG_ERR, "%s (%s) is not a usable Windows tap device: %s", device, iface, winerror(GetLastError()));
                return false;
@@ -245,18 +259,20 @@ static bool write_packet(vpn_packet_t *packet) {
        static vpn_packet_t queue;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
        /* Check if there is something in progress */
 
        if(queue.len) {
                DWORD size;
                BOOL success = GetOverlappedResult(device_handle, &w_overlapped, &size, FALSE);
+
                if(success) {
                        ResetEvent(&w_overlapped);
                        queue.len = 0;
                } else {
                        int err = GetLastError();
+
                        if(err != ERROR_IO_INCOMPLETE) {
                                ifdebug(TRAFFIC) logger(LOG_DEBUG, "Error completing previously queued write: %s", winerror(err));
                                ResetEvent(&w_overlapped);
@@ -275,10 +291,12 @@ static bool write_packet(vpn_packet_t *packet) {
 
        if(!WriteFile(device_handle, queue.data, packet->len, &lenout, &w_overlapped)) {
                int err = GetLastError();
+
                if(err != ERROR_IO_PENDING) {
                        logger(LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(err));
                        return false;
                }
+
                // Write is being done asynchronously.
                queue.len = packet->len;
        } else {
index 5053036..2cc7163 100644 (file)
@@ -54,6 +54,7 @@ static bool setup_device(void) {
 
        host = xstrdup(device);
        space = strchr(host, ' ');
+
        if(!space) {
                logger(LOG_ERR, "Port number required for %s", device_info);
                free(host);
@@ -70,12 +71,14 @@ static bool setup_device(void) {
        }
 
        ai = str2addrinfo(host, port, SOCK_DGRAM);
+
        if(!ai) {
                free(host);
                return false;
        }
 
        device_fd = socket(ai->ai_family, SOCK_DGRAM, IPPROTO_UDP);
+
        if(device_fd < 0) {
                logger(LOG_ERR, "Creating socket failed: %s", sockstrerror(sockerrno));
                free(host);
@@ -98,54 +101,62 @@ static bool setup_device(void) {
 
        switch(ai->ai_family) {
 #ifdef IP_ADD_MEMBERSHIP
-               case AF_INET: {
-                       struct ip_mreq mreq;
-                       struct sockaddr_in in;
-                       memcpy(&in, ai->ai_addr, sizeof(in));
-                       mreq.imr_multiaddr.s_addr = in.sin_addr.s_addr;
-                       mreq.imr_interface.s_addr = htonl(INADDR_ANY);
-                       if(setsockopt(device_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void *)&mreq, sizeof(mreq))) {
-                               logger(LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
-                               closesocket(device_fd);
-                               free(host);
-                               return false;
-                       }
+
+       case AF_INET: {
+               struct ip_mreq mreq;
+               struct sockaddr_in in;
+               memcpy(&in, ai->ai_addr, sizeof(in));
+               mreq.imr_multiaddr.s_addr = in.sin_addr.s_addr;
+               mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+
+               if(setsockopt(device_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void *)&mreq, sizeof(mreq))) {
+                       logger(LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
+                       closesocket(device_fd);
+                       free(host);
+                       return false;
+               }
+
 #ifdef IP_MULTICAST_LOOP
-                       setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_LOOP, (const void *)&one, sizeof(one));
+               setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_LOOP, (const void *)&one, sizeof(one));
 #endif
 #ifdef IP_MULTICAST_TTL
-                       setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&ttl, sizeof(ttl));
+               setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&ttl, sizeof(ttl));
 #endif
-               } break;
+       }
+       break;
 #endif
 
 #ifdef IPV6_JOIN_GROUP
-               case AF_INET6: {
-                       struct ipv6_mreq mreq;
-                       struct sockaddr_in6 in6;
-                       memcpy(&in6, ai->ai_addr, sizeof(in6));
-                       memcpy(&mreq.ipv6mr_multiaddr, &in6.sin6_addr, sizeof(mreq.ipv6mr_multiaddr));
-                       mreq.ipv6mr_interface = in6.sin6_scope_id;
-                       if(setsockopt(device_fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (void *)&mreq, sizeof(mreq))) {
-                               logger(LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
-                               closesocket(device_fd);
-                               free(host);
-                               return false;
-                       }
+
+       case AF_INET6: {
+               struct ipv6_mreq mreq;
+               struct sockaddr_in6 in6;
+               memcpy(&in6, ai->ai_addr, sizeof(in6));
+               memcpy(&mreq.ipv6mr_multiaddr, &in6.sin6_addr, sizeof(mreq.ipv6mr_multiaddr));
+               mreq.ipv6mr_interface = in6.sin6_scope_id;
+
+               if(setsockopt(device_fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (void *)&mreq, sizeof(mreq))) {
+                       logger(LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
+                       closesocket(device_fd);
+                       free(host);
+                       return false;
+               }
+
 #ifdef IPV6_MULTICAST_LOOP
-                       setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (const void *)&one, sizeof(one));
+               setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (const void *)&one, sizeof(one));
 #endif
 #ifdef IPV6_MULTICAST_HOPS
-                       setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (void *)&ttl, sizeof(ttl));
+               setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (void *)&ttl, sizeof(ttl));
 #endif
-               } break;
+       }
+       break;
 #endif
-       
-               default:
-                       logger(LOG_ERR, "Multicast for address family %x unsupported", ai->ai_family);
-                       closesocket(device_fd);
-                       free(host);
-                       return false;
+
+       default:
+               logger(LOG_ERR, "Multicast for address family %x unsupported", ai->ai_family);
+               closesocket(device_fd);
+               free(host);
+               return false;
        }
 
        free(host);
@@ -160,8 +171,9 @@ static void close_device(void) {
        free(device);
        free(iface);
 
-       if(ai)
+       if(ai) {
                freeaddrinfo(ai);
+       }
 }
 
 static bool read_packet(vpn_packet_t *packet) {
@@ -169,7 +181,7 @@ static bool read_packet(vpn_packet_t *packet) {
 
        if((lenin = recv(device_fd, (void *)packet->data, MTU, 0)) <= 0) {
                logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
-                          device, strerror(errno));
+                      device, strerror(errno));
                return false;
        }
 
@@ -184,18 +196,18 @@ static bool read_packet(vpn_packet_t *packet) {
        device_total_in += packet->len;
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
-                          device_info);
+                               device_info);
 
        return true;
 }
 
 static bool write_packet(vpn_packet_t *packet) {
        ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
-                          packet->len, device_info);
+                               packet->len, device_info);
 
        if(sendto(device_fd, (void *)packet->data, packet->len, 0, ai->ai_addr, ai->ai_addrlen) < 0) {
                logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
-                          strerror(errno));
+                      strerror(errno));
                return false;
        }
 
index cac15f9..4b64492 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -3,7 +3,7 @@
     Copyright (C) 1998-2005 Ivo Timmermans,
                   2000-2015 Guus Sliepen <guus@tinc-vpn.org>
                   2006      Scott Lamb <slamb@slamb.org>
-                 2011      Loïc Grenié <loic.grenie@gmail.com>
+                  2011      Loïc Grenié <loic.grenie@gmail.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -70,21 +70,26 @@ static void purge(void) {
 
                if(!n->status.reachable) {
                        ifdebug(SCARY_THINGS) logger(LOG_DEBUG, "Purging node %s (%s)", n->name,
-                                          n->hostname);
+                                                    n->hostname);
 
                        for(snode = n->subnet_tree->head; snode; snode = snext) {
                                snext = snode->next;
                                s = snode->data;
                                send_del_subnet(everyone, s);
-                               if(!strictsubnets)
+
+                               if(!strictsubnets) {
                                        subnet_del(n, s);
+                               }
                        }
 
                        for(enode = n->edge_tree->head; enode; enode = enext) {
                                enext = enode->next;
                                e = enode->data;
-                               if(!tunnelserver)
+
+                               if(!tunnelserver) {
                                        send_del_edge(everyone, e);
+                               }
+
                                edge_del(e);
                        }
                }
@@ -101,13 +106,16 @@ static void purge(void) {
                                enext = enode->next;
                                e = enode->data;
 
-                               if(e->to == n)
+                               if(e->to == n) {
                                        break;
+                               }
                        }
 
                        if(!enode && (!strictsubnets || !n->subnet_tree->head))
                                /* in strictsubnets mode do not delete nodes with subnets */
+                       {
                                node_del(n);
+                       }
                }
        }
 }
@@