K&R style braces.

This is essentially commit f02d3ed3e135b5326003e7f69f8331ff6a3cc219 from the
1.1 branch, making it easier to merge between master and 1.1.

diff --git a/lib/dropin.c b/lib/dropin.c
index 572617c..89039da 100644 (file)
--- a/lib/dropin.c
+++ b/lib/dropin.c
@@ -36,8 +36,7 @@
   Unless the argument noclose is non-zero, daemon() will redirect
   standard input, standard output and standard error to /dev/null.
 */
-int daemon(int nochdir, int noclose)
-{
+int daemon(int nochdir, int noclose) {
 #ifdef HAVE_FORK
        pid_t pid;
        int fd;
@@ -95,8 +94,7 @@ int daemon(int nochdir, int noclose)
   current directory name.  If the environment variable PWD is set, and
   its value is correct, then that value will be returned.
 */
-char *get_current_dir_name(void)
-{
+char *get_current_dir_name(void) {
        size_t size;
        char *buf;
        char *r;

diff --git a/lib/list.c b/lib/list.c
index bf52280..a26c58d 100644 (file)
--- a/lib/list.c
+++ b/lib/list.c
@@ -25,8 +25,7 @@
 
 /* (De)constructors */
 
-list_t *list_alloc(list_action_t delete)
-{
+list_t *list_alloc(list_action_t delete) {
        list_t *list;
 
        list = xmalloc_and_zero(sizeof(list_t));
@@ -35,18 +34,15 @@ list_t *list_alloc(list_action_t delete)
        return list;
 }
 
-void list_free(list_t *list)
-{
+void list_free(list_t *list) {
        free(list);
 }
 
-list_node_t *list_alloc_node(void)
-{
+list_node_t *list_alloc_node(void) {
        return xmalloc_and_zero(sizeof(list_node_t));
 }
 
-void list_free_node(list_t *list, list_node_t *node)
-{
+void list_free_node(list_t *list, list_node_t *node) {
        if(node->data && list->delete)
                list->delete(node->data);
 
@@ -55,8 +51,7 @@ void list_free_node(list_t *list, list_node_t *node)
 
 /* Insertion and deletion */
 
-list_node_t *list_insert_head(list_t *list, void *data)
-{
+list_node_t *list_insert_head(list_t *list, void *data) {
        list_node_t *node;
 
        node = list_alloc_node();
@@ -76,8 +71,7 @@ list_node_t *list_insert_head(list_t *list, void *data)
        return node;
 }
 
-list_node_t *list_insert_tail(list_t *list, void *data)
-{
+list_node_t *list_insert_tail(list_t *list, void *data) {
        list_node_t *node;
 
        node = list_alloc_node();
@@ -97,8 +91,7 @@ list_node_t *list_insert_tail(list_t *list, void *data)
        return node;
 }
 
-void list_unlink_node(list_t *list, list_node_t *node)
-{
+void list_unlink_node(list_t *list, list_node_t *node) {
        if(node->prev)
                node->prev->next = node->next;
        else
@@ -112,34 +105,29 @@ void list_unlink_node(list_t *list, list_node_t *node)
        list->count--;
 }
 
-void list_delete_node(list_t *list, list_node_t *node)
-{
+void list_delete_node(list_t *list, list_node_t *node) {
        list_unlink_node(list, node);
        list_free_node(list, node);
 }
 
-void list_delete_head(list_t *list)
-{
+void list_delete_head(list_t *list) {
        list_delete_node(list, list->head);
 }
 
-void list_delete_tail(list_t *list)
-{
+void list_delete_tail(list_t *list) {
        list_delete_node(list, list->tail);
 }
 
 /* Head/tail lookup */
 
-void *list_get_head(list_t *list)
-{
+void *list_get_head(list_t *list) {
        if(list->head)
                return list->head->data;
        else
                return NULL;
 }
 
-void *list_get_tail(list_t *list)
-{
+void *list_get_tail(list_t *list) {
        if(list->tail)
                return list->tail->data;
        else
@@ -148,8 +136,7 @@ void *list_get_tail(list_t *list)
 
 /* Fast list deletion */
 
-void list_delete_list(list_t *list)
-{
+void list_delete_list(list_t *list) {
        list_node_t *node, *next;
 
        for(node = list->head; node; node = next) {
@@ -162,8 +149,7 @@ void list_delete_list(list_t *list)
 
 /* Traversing */
 
-void list_foreach_node(list_t *list, list_action_node_t action)
-{
+void list_foreach_node(list_t *list, list_action_node_t action) {
        list_node_t *node, *next;
 
        for(node = list->head; node; node = next) {
@@ -172,8 +158,7 @@ void list_foreach_node(list_t *list, list_action_node_t action)
        }
 }
 
-void list_foreach(list_t *list, list_action_t action)
-{
+void list_foreach(list_t *list, list_action_t action) {
        list_node_t *node, *next;
 
        for(node = list->head; node; node = next) {

diff --git a/lib/utils.c b/lib/utils.c
index 4795ed0..b327a49 100644 (file)
--- a/lib/utils.c
+++ b/lib/utils.c
@@ -31,8 +31,7 @@ volatile int cp_index = 0;
 
 const char hexadecimals[] = "0123456789ABCDEF";
 
-int charhex2bin(char c)
-{
+int charhex2bin(char c) {
        if(isdigit(c))
                return c - '0';
        else
@@ -40,15 +39,13 @@ int charhex2bin(char c)
 }
 
 
-void hex2bin(char *src, char *dst, int length)
-{
+void hex2bin(char *src, char *dst, int length) {
        int i;
        for(i = 0; i < length; i++)
                dst[i] = charhex2bin(src[i * 2]) * 16 + charhex2bin(src[i * 2 + 1]);
 }
 
-void bin2hex(char *src, char *dst, int length)
-{
+void bin2hex(char *src, char *dst, int length) {
        int i;
        for(i = length - 1; i >= 0; i--) {
                dst[i * 2 + 1] = hexadecimals[(unsigned char) src[i] & 15];
@@ -57,8 +54,7 @@ void bin2hex(char *src, char *dst, int length)
 }
 
 #ifdef ENABLE_TRACING
-void cp_trace()
-{
+void cp_trace() {
        logger(LOG_DEBUG, "Checkpoint trace: %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d <- %s:%d...",
                   cp_file[(cp_index + 15) % 16], cp_line[(cp_index + 15) % 16],
                   cp_file[(cp_index + 14) % 16], cp_line[(cp_index + 14) % 16],

diff --git a/src/bsd/device.c b/src/bsd/device.c
index 7633a0d..5fe8dc0 100644 (file)
--- a/src/bsd/device.c
+++ b/src/bsd/device.c
@@ -277,8 +277,7 @@ bool read_packet(vpn_packet_t *packet) {
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        cp();
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
@@ -349,8 +348,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/conf.c b/src/conf.c
index 5058d31..e7703c1 100644 (file)
--- a/src/conf.c
+++ b/src/conf.c
@@ -36,8 +36,7 @@ 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 */
 
-static int config_compare(const config_t *a, const config_t *b)
-{
+static int config_compare(const config_t *a, const config_t *b) {
        int result;
 
        result = strcasecmp(a->variable, b->variable);
@@ -53,30 +52,26 @@ static int config_compare(const config_t *a, const config_t *b)
                return strcmp(a->file, b->file);
 }
 
-void init_configuration(avl_tree_t ** config_tree)
-{
+void init_configuration(avl_tree_t ** config_tree) {
        cp();
 
        *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) {
        cp();
 
        avl_delete_tree(*config_tree);
        *config_tree = NULL;
 }
 
-config_t *new_config(void)
-{
+config_t *new_config(void) {
        cp();
 
        return xmalloc_and_zero(sizeof(config_t));
 }
 
-void free_config(config_t *cfg)
-{
+void free_config(config_t *cfg) {
        cp();
 
        if(cfg->variable)
@@ -91,15 +86,13 @@ void free_config(config_t *cfg)
        free(cfg);
 }
 
-void config_add(avl_tree_t *config_tree, config_t *cfg)
-{
+void config_add(avl_tree_t *config_tree, config_t *cfg) {
        cp();
 
        avl_insert(config_tree, cfg);
 }
 
-config_t *lookup_config(avl_tree_t *config_tree, char *variable)
-{
+config_t *lookup_config(avl_tree_t *config_tree, char *variable) {
        config_t cfg, *found;
 
        cp();
@@ -119,8 +112,7 @@ config_t *lookup_config(avl_tree_t *config_tree, char *variable)
        return found;
 }
 
-config_t *lookup_config_next(avl_tree_t *config_tree, const config_t *cfg)
-{
+config_t *lookup_config_next(avl_tree_t *config_tree, const config_t *cfg) {
        avl_node_t *node;
        config_t *found;
 
@@ -140,8 +132,7 @@ config_t *lookup_config_next(avl_tree_t *config_tree, const config_t *cfg)
        return NULL;
 }
 
-bool get_config_bool(const config_t *cfg, bool *result)
-{
+bool get_config_bool(const config_t *cfg, bool *result) {
        cp();
 
        if(!cfg)
@@ -161,8 +152,7 @@ bool get_config_bool(const config_t *cfg, bool *result)
        return false;
 }
 
-bool get_config_int(const config_t *cfg, int *result)
-{
+bool get_config_int(const config_t *cfg, int *result) {
        cp();
 
        if(!cfg)
@@ -177,8 +167,7 @@ bool get_config_int(const config_t *cfg, int *result)
        return false;
 }
 
-bool get_config_string(const config_t *cfg, char **result)
-{
+bool get_config_string(const config_t *cfg, char **result) {
        cp();
 
        if(!cfg)
@@ -189,8 +178,7 @@ bool get_config_string(const config_t *cfg, char **result)
        return true;
 }
 
-bool get_config_address(const config_t *cfg, struct addrinfo **result)
-{
+bool get_config_address(const config_t *cfg, struct addrinfo **result) {
        struct addrinfo *ai;
 
        cp();
@@ -211,8 +199,7 @@ bool get_config_address(const config_t *cfg, struct addrinfo **result)
        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 = {0};
 
        cp();
@@ -252,8 +239,7 @@ bool get_config_subnet(const config_t *cfg, subnet_t ** result)
   given, and buf needs to be expanded, the var pointed to by buflen
   will be increased.
 */
-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;
        char *line;                                     /* The array that contains everything that has been read so far */
@@ -317,8 +303,7 @@ static char *readline(FILE * fp, char **buf, size_t *buflen)
   Parse a configuration file and put the results in the configuration tree
   starting at *base.
 */
-int read_config_file(avl_tree_t *config_tree, const char *fname)
-{
+int read_config_file(avl_tree_t *config_tree, const char *fname) {
        int err = -2;                           /* Parse error */
        FILE *fp;
        char *buffer, *line;
@@ -408,8 +393,7 @@ int read_config_file(avl_tree_t *config_tree, const char *fname)
        return err;
 }
 
-bool read_server_config()
-{
+bool read_server_config() {
        char *fname;
        int x;
 
@@ -427,8 +411,7 @@ bool read_server_config()
        return x == 0;
 }
 
-FILE *ask_and_open(const char *filename, const char *what)
-{
+FILE *ask_and_open(const char *filename, const char *what) {
        FILE *r;
        char *directory;
        char *fn;

diff --git a/src/connection.c b/src/connection.c
index a329cd7..289c233 100644 (file)
--- a/src/connection.c
+++ b/src/connection.c
@@ -33,13 +33,11 @@
 avl_tree_t *connection_tree;   /* Meta connections */
 connection_t *broadcast;
 
-static int connection_compare(const connection_t *a, const connection_t *b)
-{
+static int connection_compare(const connection_t *a, const connection_t *b) {
        return a < b ? -1 : a == b ? 0 : 1;
 }
 
-void init_connections(void)
-{
+void init_connections(void) {
        cp();
 
        connection_tree = avl_alloc_tree((avl_compare_t) connection_compare, (avl_action_t) free_connection);
@@ -48,16 +46,14 @@ void init_connections(void)
        broadcast->hostname = xstrdup(_("BROADCAST"));
 }
 
-void exit_connections(void)
-{
+void exit_connections(void) {
        cp();
 
        avl_delete_tree(connection_tree);
        free_connection(broadcast);
 }
 
-connection_t *new_connection(void)
-{
+connection_t *new_connection(void) {
        connection_t *c;
 
        cp();
@@ -72,8 +68,7 @@ connection_t *new_connection(void)
        return c;
 }
 
-void free_connection(connection_t *c)
-{
+void free_connection(connection_t *c) {
        cp();
 
        if(c->name)
@@ -116,22 +111,19 @@ void free_connection(connection_t *c)
        free(c);
 }
 
-void connection_add(connection_t *c)
-{
+void connection_add(connection_t *c) {
        cp();
 
        avl_insert(connection_tree, c);
 }
 
-void connection_del(connection_t *c)
-{
+void connection_del(connection_t *c) {
        cp();
 
        avl_delete(connection_tree, c);
 }
 
-void dump_connections(void)
-{
+void dump_connections(void) {
        avl_node_t *node;
        connection_t *c;
 
@@ -149,8 +141,7 @@ void dump_connections(void)
        logger(LOG_DEBUG, _("End of connections."));
 }
 
-bool read_connection_config(connection_t *c)
-{
+bool read_connection_config(connection_t *c) {
        char *fname;
        int x;
 

diff --git a/src/cygwin/device.c b/src/cygwin/device.c
index 4a7b139..921205c 100644 (file)
--- a/src/cygwin/device.c
+++ b/src/cygwin/device.c
@@ -44,8 +44,7 @@ static int device_total_out = 0;
 static pid_t reader_pid;
 static int sp[2];
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        HKEY key, key2;
        int i, err;
 
@@ -216,8 +215,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
 
        close(sp[0]);
@@ -230,8 +228,7 @@ void close_device(void)
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        int lenin;
 
        cp();
@@ -252,8 +249,7 @@ bool read_packet(vpn_packet_t *packet)
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        long lenout;
 
        cp();
@@ -271,8 +267,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/edge.c b/src/edge.c
index 9509880..403dfff 100644 (file)
--- a/src/edge.c
+++ b/src/edge.c
@@ -30,13 +30,11 @@
 
 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)
-{
+static int edge_compare(const edge_t *a, const edge_t *b) {
        return strcmp(a->to->name, b->to->name);
 }
 
-static int edge_weight_compare(const edge_t *a, const edge_t *b)
-{
+static int edge_weight_compare(const edge_t *a, const edge_t *b) {
        int result;
 
        result = a->weight - b->weight;
@@ -52,29 +50,25 @@ static int edge_weight_compare(const edge_t *a, const edge_t *b)
        return strcmp(a->to->name, b->to->name);
 }
 
-void init_edges(void)
-{
+void init_edges(void) {
        cp();
 
        edge_weight_tree = avl_alloc_tree((avl_compare_t) edge_weight_compare, NULL);
 }
 
-avl_tree_t *new_edge_tree(void)
-{
+avl_tree_t *new_edge_tree(void) {
        cp();
 
        return avl_alloc_tree((avl_compare_t) edge_compare, (avl_action_t) free_edge);
 }
 
-void free_edge_tree(avl_tree_t *edge_tree)
-{
+void free_edge_tree(avl_tree_t *edge_tree) {
        cp();
 
        avl_delete_tree(edge_tree);
 }
 
-void exit_edges(void)
-{
+void exit_edges(void) {
        cp();
 
        avl_delete_tree(edge_weight_tree);
@@ -82,15 +76,13 @@ void exit_edges(void)
 
 /* Creation and deletion of connection elements */
 
-edge_t *new_edge(void)
-{
+edge_t *new_edge(void) {
        cp();
 
        return xmalloc_and_zero(sizeof(edge_t));
 }
 
-void free_edge(edge_t *e)
-{
+void free_edge(edge_t *e) {
        cp();
        
        sockaddrfree(&e->address);
@@ -98,8 +90,7 @@ void free_edge(edge_t *e)
        free(e);
 }
 
-void edge_add(edge_t *e)
-{
+void edge_add(edge_t *e) {
        cp();
 
        avl_insert(edge_weight_tree, e);
@@ -111,8 +102,7 @@ void edge_add(edge_t *e)
                e->reverse->reverse = e;
 }
 
-void edge_del(edge_t *e)
-{
+void edge_del(edge_t *e) {
        cp();
 
        if(e->reverse)
@@ -122,8 +112,7 @@ void edge_del(edge_t *e)
        avl_delete(e->from->edge_tree, e);
 }
 
-edge_t *lookup_edge(node_t *from, node_t *to)
-{
+edge_t *lookup_edge(node_t *from, node_t *to) {
        edge_t v;
        
        cp();
@@ -134,8 +123,7 @@ edge_t *lookup_edge(node_t *from, node_t *to)
        return avl_search(from->edge_tree, &v);
 }
 
-void dump_edges(void)
-{
+void dump_edges(void) {
        avl_node_t *node, *node2;
        node_t *n;
        edge_t *e;

diff --git a/src/event.c b/src/event.c
index 2fb65ec..304360c 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -30,8 +30,7 @@ extern time_t now;
 
 int id;
 
-static int event_compare(const event_t *a, const event_t *b)
-{
+static int event_compare(const event_t *a, const event_t *b) {
        if(a->time > b->time)
                return 1;
 
@@ -41,22 +40,19 @@ static int event_compare(const event_t *a, const event_t *b)
        return a->id - b->id;
 }
 
-void init_events(void)
-{
+void init_events(void) {
        cp();
 
        event_tree = avl_alloc_tree((avl_compare_t) event_compare, (avl_action_t) free_event);
 }
 
-void exit_events(void)
-{
+void exit_events(void) {
        cp();
 
        avl_delete_tree(event_tree);
 }
 
-void expire_events(void)
-{
+void expire_events(void) {
        avl_node_t *node;
        event_t *event;
        time_t diff;
@@ -83,37 +79,32 @@ void expire_events(void)
        }
 }
 
-event_t *new_event(void)
-{
+event_t *new_event(void) {
        cp();
 
        return xmalloc_and_zero(sizeof(event_t));
 }
 
-void free_event(event_t *event)
-{
+void free_event(event_t *event) {
        cp();
 
        free(event);
 }
 
-void event_add(event_t *event)
-{
+void event_add(event_t *event) {
        cp();
 
        event->id = ++id;
        avl_insert(event_tree, event);
 }
 
-void event_del(event_t *event)
-{
+void event_del(event_t *event) {
        cp();
 
        avl_delete(event_tree, event);
 }
 
-event_t *get_expired_event(void)
-{
+event_t *get_expired_event(void) {
        event_t *event;
 
        cp();

diff --git a/src/graph.c b/src/graph.c
index 12ef8b0..4f2ea49 100644 (file)
--- a/src/graph.c
+++ b/src/graph.c
@@ -64,8 +64,7 @@ static bool graph_changed = true;
    Please note that sorting on weight is already done by add_edge().
 */
 
-void mst_kruskal(void)
-{
+void mst_kruskal(void) {
        avl_node_t *node, *next;
        edge_t *e;
        node_t *n;
@@ -148,8 +147,7 @@ void mst_kruskal(void)
    Running time: O(E)
 */
 
-void sssp_bfs(void)
-{
+void sssp_bfs(void) {
        avl_node_t *node, *next, *to;
        edge_t *e;
        node_t *n;
@@ -296,8 +294,7 @@ void sssp_bfs(void)
        }
 }
 
-void graph(void)
-{
+void graph(void) {
        subnet_cache_flush();
        sssp_bfs();
        mst_kruskal();
@@ -312,8 +309,7 @@ void graph(void)
    dot -Tpng graph_filename -o image_filename.png -Gconcentrate=true
 */
 
-void dump_graph(void)
-{
+void dump_graph(void) {
        avl_node_t *node;
        node_t *n;
        edge_t *e;

diff --git a/src/linux/device.c b/src/linux/device.c
index 6d02b47..9af5038 100644 (file)
--- a/src/linux/device.c
+++ b/src/linux/device.c
@@ -50,8 +50,7 @@ static char *device_info;
 static int device_total_in = 0;
 static int device_total_out = 0;
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        struct ifreq ifr;
 
        cp();
@@ -116,8 +115,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
        
        close(device_fd);
@@ -126,8 +124,7 @@ void close_device(void)
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        int lenin;
        
        cp();
@@ -176,8 +173,7 @@ bool read_packet(vpn_packet_t *packet)
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        cp();
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
@@ -215,8 +211,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/meta.c b/src/meta.c
index 275eae3..27d2394 100644 (file)
--- a/src/meta.c
+++ b/src/meta.c
@@ -32,8 +32,7 @@
 #include "utils.h"
 #include "xalloc.h"
 
-bool send_meta(connection_t *c, const char *buffer, int length)
-{
+bool send_meta(connection_t *c, const char *buffer, int length) {
        int outlen;
        int result;
 
@@ -82,8 +81,7 @@ bool send_meta(connection_t *c, const char *buffer, int length)
        return true;
 }
 
-bool flush_meta(connection_t *c)
-{
+bool flush_meta(connection_t *c) {
        int result;
        
        ifdebug(META) logger(LOG_DEBUG, _("Flushing %d bytes to %s (%s)"),
@@ -119,8 +117,7 @@ bool flush_meta(connection_t *c)
        return true;
 }
 
-void broadcast_meta(connection_t *from, const char *buffer, int length)
-{
+void broadcast_meta(connection_t *from, const char *buffer, int length) {
        avl_node_t *node;
        connection_t *c;
 
@@ -134,8 +131,7 @@ void broadcast_meta(connection_t *from, const char *buffer, int length)
        }
 }
 
-bool receive_meta(connection_t *c)
-{
+bool receive_meta(connection_t *c) {
        int oldlen, i, result;
        int lenin, lenout, reqlen;
        bool decrypted = false;

diff --git a/src/mingw/device.c b/src/mingw/device.c
index 7d906b7..c0f02f2 100644 (file)
--- a/src/mingw/device.c
+++ b/src/mingw/device.c
@@ -82,8 +82,7 @@ static DWORD WINAPI tapreader(void *bla) {
        }
 }
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        HKEY key, key2;
        int i;
 
@@ -220,8 +219,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
 
        CloseHandle(device_handle);
@@ -230,13 +228,11 @@ void close_device(void)
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        return false;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        long lenout;
        OVERLAPPED overlapped = {0};
 
@@ -255,8 +251,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/net.c b/src/net.c
index 8af464b..0b617bd 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -46,8 +46,7 @@ time_t now = 0;
 
 /* Purge edges and subnets of unreachable nodes. Use carefully. */
 
-static void purge(void)
-{
+static void purge(void) {
        avl_node_t *nnode, *nnext, *enode, *enext, *snode, *snext;
        node_t *n;
        edge_t *e;
@@ -110,8 +109,7 @@ static void purge(void)
   put all file descriptors in an fd_set array
   While we're at it, purge stuff that needs to be removed.
 */
-static int build_fdset(fd_set *readset, fd_set *writeset)
-{
+static int build_fdset(fd_set *readset, fd_set *writeset) {
        avl_node_t *node, *next;
        connection_t *c;
        int i, max = 0;
@@ -162,8 +160,7 @@ static int build_fdset(fd_set *readset, fd_set *writeset)
   - Check if we need to retry making an outgoing connection
   - Deactivate the host
 */
-void terminate_connection(connection_t *c, bool report)
-{
+void terminate_connection(connection_t *c, bool report) {
        cp();
 
        if(c->status.remove)
@@ -226,8 +223,7 @@ void terminate_connection(connection_t *c, bool report)
   end does not reply in time, we consider them dead
   and close the connection.
 */
-static void check_dead_connections(void)
-{
+static void check_dead_connections(void) {
        avl_node_t *node, *next;
        connection_t *c;
 
@@ -282,8 +278,7 @@ static void check_dead_connections(void)
   check all connections to see if anything
   happened on their sockets
 */
-static void check_network_activity(fd_set * readset, fd_set * writeset)
-{
+static void check_network_activity(fd_set * readset, fd_set * writeset) {
        connection_t *c;
        avl_node_t *node;
        int result, i;
@@ -350,8 +345,7 @@ static void check_network_activity(fd_set * readset, fd_set * writeset)
 /*
   this is where it all happens...
 */
-int main_loop(void)
-{
+int main_loop(void) {
        fd_set readset, writeset;
        struct timeval tv;
        int r, maxfd;

diff --git a/src/net_packet.c b/src/net_packet.c
index 426fa49..0059b27 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -58,8 +58,7 @@ static void send_udppacket(node_t *, vpn_packet_t *);
 
 #define MAX_SEQNO 1073741824
 
-void send_mtu_probe(node_t *n)
-{
+void send_mtu_probe(node_t *n) {
        vpn_packet_t packet;
        int len, i;
        
@@ -118,8 +117,7 @@ void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
        }
 }
 
-static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level)
-{
+static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
        if(level == 10) {
                lzo_uint lzolen = MAXSIZE;
                lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
@@ -139,8 +137,7 @@ static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t l
        return -1;
 }
 
-static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level)
-{
+static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
        if(level > 9) {
                lzo_uint lzolen = MAXSIZE;
                if(lzo1x_decompress_safe(source, len, dest, &lzolen, NULL) == LZO_E_OK)
@@ -160,8 +157,7 @@ static length_t uncompress_packet(uint8_t *dest, const uint8_t *source, length_t
 
 /* VPN packet I/O */
 
-static void receive_packet(node_t *n, vpn_packet_t *packet)
-{
+static void receive_packet(node_t *n, vpn_packet_t *packet) {
        cp();
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Received packet of %d bytes from %s (%s)"),
@@ -170,8 +166,7 @@ static void receive_packet(node_t *n, vpn_packet_t *packet)
        route(n, packet);
 }
 
-static bool try_mac(const node_t *n, const vpn_packet_t *inpkt)
-{
+static bool try_mac(const node_t *n, const vpn_packet_t *inpkt) {
        unsigned char hmac[EVP_MAX_MD_SIZE];
 
        if(!n->indigest || !n->inmaclength || !n->inkey || inpkt->len < sizeof inpkt->seqno + n->inmaclength)
@@ -182,8 +177,7 @@ static bool try_mac(const node_t *n, const vpn_packet_t *inpkt)
        return !memcmp(hmac, (char *) &inpkt->seqno + inpkt->len - n->inmaclength, n->inmaclength);
 }
 
-static void receive_udppacket(node_t *n, vpn_packet_t *inpkt)
-{
+static void receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
        vpn_packet_t pkt1, pkt2;
        vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
        int nextpkt = 0;
@@ -300,8 +294,7 @@ static void receive_udppacket(node_t *n, vpn_packet_t *inpkt)
                receive_packet(n, inpkt);
 }
 
-void receive_tcppacket(connection_t *c, char *buffer, int len)
-{
+void receive_tcppacket(connection_t *c, char *buffer, int len) {
        vpn_packet_t outpkt;
 
        cp();
@@ -316,8 +309,7 @@ void receive_tcppacket(connection_t *c, char *buffer, int len)
        receive_packet(c->node, &outpkt);
 }
 
-static void send_udppacket(node_t *n, vpn_packet_t *origpkt)
-{
+static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
        vpn_packet_t pkt1, pkt2;
        vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
        vpn_packet_t *inpkt = origpkt;
@@ -449,8 +441,7 @@ end:
 /*
   send a packet to the given vpn ip.
 */
-void send_packet(const node_t *n, vpn_packet_t *packet)
-{
+void send_packet(const node_t *n, vpn_packet_t *packet) {
        node_t *via;
 
        cp();
@@ -486,8 +477,7 @@ void send_packet(const node_t *n, vpn_packet_t *packet)
 
 /* Broadcast a packet using the minimum spanning tree */
 
-void broadcast_packet(const node_t *from, vpn_packet_t *packet)
-{
+void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
        avl_node_t *node;
        connection_t *c;
 
@@ -537,8 +527,7 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
        return n;
 }
 
-void handle_incoming_vpn_data(int sock)
-{
+void handle_incoming_vpn_data(int sock) {
        vpn_packet_t pkt;
        char *hostname;
        sockaddr_t from;

diff --git a/src/net_setup.c b/src/net_setup.c
index a667a67..a6fd3d0 100644 (file)
--- a/src/net_setup.c
+++ b/src/net_setup.c
@@ -44,8 +44,7 @@
 
 char *myport;
 
-bool read_rsa_public_key(connection_t *c)
-{
+bool read_rsa_public_key(connection_t *c) {
        FILE *fp;
        char *fname;
        char *key;
@@ -145,8 +144,7 @@ bool read_rsa_public_key(connection_t *c)
        return false;
 }
 
-bool read_rsa_private_key(void)
-{
+bool read_rsa_private_key(void) {
        FILE *fp;
        char *fname, *key, *pubkey;
        struct stat s;
@@ -209,8 +207,7 @@ bool read_rsa_private_key(void)
 /*
   Configure node_t myself and set up the local sockets (listen only)
 */
-bool setup_myself(void)
-{
+bool setup_myself(void) {
        config_t *cfg;
        subnet_t *subnet;
        char *name, *hostname, *mode, *afname, *cipher, *digest;
@@ -506,8 +503,7 @@ bool setup_myself(void)
 /*
   initialize network
 */
-bool setup_network(void)
-{
+bool setup_network(void) {
        cp();
 
        now = time(NULL);
@@ -543,8 +539,7 @@ bool setup_network(void)
 /*
   close all open network connections
 */
-void close_network_connections(void)
-{
+void close_network_connections(void) {
        avl_node_t *node, *next;
        connection_t *c;
        char *envp[5];

diff --git a/src/net_socket.c b/src/net_socket.c
index 312030b..5f6cd2a 100644 (file)
--- a/src/net_socket.c
+++ b/src/net_socket.c
@@ -54,8 +54,7 @@ list_t *outgoing_list = NULL;
 
 /* Setup sockets */
 
-static void configure_tcp(connection_t *c)
-{
+static void configure_tcp(connection_t *c) {
        int option;
 
 #ifdef O_NONBLOCK
@@ -83,7 +82,7 @@ static void configure_tcp(connection_t *c)
 #endif
 }
 
-static bool bind_to_interface(int sd) { /* {{{ */
+static bool bind_to_interface(int sd) {
        char *iface;
 
 #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE)
@@ -110,9 +109,9 @@ static bool bind_to_interface(int sd) { /* {{{ */
 #endif
 
        return true;
-} /* }}} bool bind_to_interface */
+}
 
-static bool bind_to_address(connection_t *c) { /* {{{ */
+static bool bind_to_address(connection_t *c) {
        char *node;
        struct addrinfo *ai_list;
        struct addrinfo *ai_ptr;
@@ -168,10 +167,9 @@ static bool bind_to_address(connection_t *c) { /* {{{ */
        freeaddrinfo(ai_list);
 
        return status ? false : true;
-} /* }}} bool bind_to_address */
+}
 
-int setup_listen_socket(const sockaddr_t *sa)
-{
+int setup_listen_socket(const sockaddr_t *sa) {
        int nfd;
        char *addrstr;
        int option;
@@ -234,8 +232,7 @@ int setup_listen_socket(const sockaddr_t *sa)
        return nfd;
 }
 
-int setup_vpn_in_socket(const sockaddr_t *sa)
-{
+int setup_vpn_in_socket(const sockaddr_t *sa) {
        int nfd;
        char *addrstr;
        int option;
@@ -311,8 +308,7 @@ int setup_vpn_in_socket(const sockaddr_t *sa)
        return nfd;
 } /* int setup_vpn_in_socket */
 
-void retry_outgoing(outgoing_t *outgoing)
-{
+void retry_outgoing(outgoing_t *outgoing) {
        event_t *event;
 
        cp();
@@ -333,8 +329,7 @@ void retry_outgoing(outgoing_t *outgoing)
                           outgoing->timeout);
 }
 
-void finish_connecting(connection_t *c)
-{
+void finish_connecting(connection_t *c) {
        cp();
 
        ifdebug(CONNECTIONS) logger(LOG_INFO, _("Connected to %s (%s)"), c->name, c->hostname);
@@ -346,8 +341,7 @@ void finish_connecting(connection_t *c)
        send_id(c);
 }
 
-void do_outgoing_connection(connection_t *c)
-{
+void do_outgoing_connection(connection_t *c) {
        char *address, *port;
        int result;
 
@@ -442,8 +436,7 @@ begin:
        return;
 }
 
-void setup_outgoing_connection(outgoing_t *outgoing)
-{
+void setup_outgoing_connection(outgoing_t *outgoing) {
        connection_t *c;
        node_t *n;
 
@@ -489,8 +482,7 @@ void setup_outgoing_connection(outgoing_t *outgoing)
   accept a new tcp connect and create a
   new connection
 */
-bool handle_new_meta_connection(int sock)
-{
+bool handle_new_meta_connection(int sock) {
        connection_t *c;
        sockaddr_t sa;
        int fd;
@@ -542,8 +534,7 @@ void free_outgoing(outgoing_t *outgoing) {
        free(outgoing);
 }
 
-void try_outgoing_connections(void)
-{
+void try_outgoing_connections(void) {
        static config_t *cfg = NULL;
        char *name;
        outgoing_t *outgoing;

diff --git a/src/netutl.c b/src/netutl.c
index 8405491..9872480 100644 (file)
--- a/src/netutl.c
+++ b/src/netutl.c
@@ -32,8 +32,7 @@ bool hostnames = false;
   Turn a string into a struct addrinfo.
   Return NULL on failure.
 */
-struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype)
-{
+struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) {
        struct addrinfo *ai, hint = {0};
        int err;
 
@@ -53,8 +52,7 @@ struct addrinfo *str2addrinfo(const char *address, const char *service, int sock
        return ai;
 }
 
-sockaddr_t str2sockaddr(const char *address, const char *port)
-{
+sockaddr_t str2sockaddr(const char *address, const char *port) {
        struct addrinfo *ai, hint = {0};
        sockaddr_t result;
        int err;
@@ -82,8 +80,7 @@ sockaddr_t str2sockaddr(const char *address, const char *port)
        return result;
 }
 
-void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr)
-{
+void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr) {
        char address[NI_MAXHOST];
        char port[NI_MAXSERV];
        char *scopeid;
@@ -116,8 +113,7 @@ void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr)
        *portstr = xstrdup(port);
 }
 
-char *sockaddr2hostname(const sockaddr_t *sa)
-{
+char *sockaddr2hostname(const sockaddr_t *sa) {
        char *str;
        char address[NI_MAXHOST] = "unknown";
        char port[NI_MAXSERV] = "unknown";
@@ -142,8 +138,7 @@ char *sockaddr2hostname(const sockaddr_t *sa)
        return str;
 }
 
-int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b)
-{
+int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b) {
        int result;
 
        cp();
@@ -175,8 +170,7 @@ int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b)
        }
 }
 
-int sockaddrcmp(const sockaddr_t *a, const sockaddr_t *b)
-{
+int sockaddrcmp(const sockaddr_t *a, const sockaddr_t *b) {
        int result;
 
        cp();
@@ -244,8 +238,7 @@ void sockaddrfree(sockaddr_t *a) {
        }
 }
        
-void sockaddrunmap(sockaddr_t *sa)
-{
+void sockaddrunmap(sockaddr_t *sa) {
        cp();
 
        if(sa->sa.sa_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sa->in6.sin6_addr)) {
@@ -256,8 +249,7 @@ void sockaddrunmap(sockaddr_t *sa)
 
 /* Subnet mask handling */
 
-int maskcmp(const void *va, const void *vb, int masklen)
-{
+int maskcmp(const void *va, const void *vb, int masklen) {
        int i, m, result;
        const char *a = va;
        const char *b = vb;
@@ -277,8 +269,7 @@ int maskcmp(const void *va, const void *vb, int masklen)
        return 0;
 }
 
-void mask(void *va, int masklen, int len)
-{
+void mask(void *va, int masklen, int len) {
        int i;
        char *a = va;
 
@@ -294,8 +285,7 @@ void mask(void *va, int masklen, int len)
                a[i] = 0;
 }
 
-void maskcpy(void *va, const void *vb, int masklen, int len)
-{
+void maskcpy(void *va, const void *vb, int masklen, int len) {
        int i, m;
        char *a = va;
        const char *b = vb;
@@ -314,8 +304,7 @@ void maskcpy(void *va, const void *vb, int masklen, int len)
                a[i] = 0;
 }
 
-bool maskcheck(const void *va, int masklen, int len)
-{
+bool maskcheck(const void *va, int masklen, int len) {
        int i;
        const char *a = va;
 

diff --git a/src/node.c b/src/node.c
index 4951007..92af66a 100644 (file)
--- a/src/node.c
+++ b/src/node.c
@@ -33,34 +33,29 @@ avl_tree_t *node_udp_tree;          /* Known nodes, sorted by address and port */
 
 node_t *myself;
 
-static int node_compare(const node_t *a, const node_t *b)
-{
+static int node_compare(const node_t *a, const node_t *b) {
        return strcmp(a->name, b->name);
 }
 
-static int node_udp_compare(const node_t *a, const node_t *b)
-{
+static int node_udp_compare(const node_t *a, const node_t *b) {
        return sockaddrcmp(&a->address, &b->address);
 }
 
-void init_nodes(void)
-{
+void init_nodes(void) {
        cp();
 
        node_tree = avl_alloc_tree((avl_compare_t) node_compare, (avl_action_t) free_node);
        node_udp_tree = avl_alloc_tree((avl_compare_t) node_udp_compare, NULL);
 }
 
-void exit_nodes(void)
-{
+void exit_nodes(void) {
        cp();
 
        avl_delete_tree(node_udp_tree);
        avl_delete_tree(node_tree);
 }
 
-node_t *new_node(void)
-{
+node_t *new_node(void) {
        node_t *n = xmalloc_and_zero(sizeof(*n));
 
        cp();
@@ -75,8 +70,7 @@ node_t *new_node(void)
        return n;
 }
 
-void free_node(node_t *n)
-{
+void free_node(node_t *n) {
        cp();
 
        if(n->inkey)
@@ -108,15 +102,13 @@ void free_node(node_t *n)
        free(n);
 }
 
-void node_add(node_t *n)
-{
+void node_add(node_t *n) {
        cp();
 
        avl_insert(node_tree, n);
 }
 
-void node_del(node_t *n)
-{
+void node_del(node_t *n) {
        avl_node_t *node, *next;
        edge_t *e;
        subnet_t *s;
@@ -139,8 +131,7 @@ void node_del(node_t *n)
        avl_delete(node_tree, n);
 }
 
-node_t *lookup_node(char *name)
-{
+node_t *lookup_node(char *name) {
        node_t n = {0};
 
        cp();
@@ -150,8 +141,7 @@ node_t *lookup_node(char *name)
        return avl_search(node_tree, &n);
 }
 
-node_t *lookup_node_udp(const sockaddr_t *sa)
-{
+node_t *lookup_node_udp(const sockaddr_t *sa) {
        node_t n = {0};
 
        cp();
@@ -162,8 +152,7 @@ node_t *lookup_node_udp(const sockaddr_t *sa)
        return avl_search(node_udp_tree, &n);
 }
 
-void update_node_udp(node_t *n, const sockaddr_t *sa)
-{
+void update_node_udp(node_t *n, const sockaddr_t *sa) {
        avl_delete(node_udp_tree, n);
 
        if(n->hostname)
@@ -181,8 +170,7 @@ void update_node_udp(node_t *n, const sockaddr_t *sa)
        }
 }
 
-void dump_nodes(void)
-{
+void dump_nodes(void) {
        avl_node_t *node;
        node_t *n;
 

diff --git a/src/process.c b/src/process.c
index 598e856..4066610 100644 (file)
--- a/src/process.c
+++ b/src/process.c
@@ -47,8 +47,7 @@ sigset_t emptysigset;
 
 static int saved_debug_level = -1;
 
-static void memory_full(int size)
-{
+static void memory_full(int size) {
        logger(LOG_ERR, _("Memory exhausted (couldn't allocate %d bytes), exitting."), size);
        cp_trace();
        exit(1);
@@ -181,8 +180,7 @@ DWORD WINAPI controlhandler(DWORD request, DWORD type, LPVOID boe, LPVOID bah) {
 
 }
 
-VOID WINAPI run_service(DWORD argc, LPTSTR* argv)
-{
+VOID WINAPI run_service(DWORD argc, LPTSTR* argv) {
        int err = 1;
        extern int main2(int argc, char **argv);
 
@@ -240,8 +238,7 @@ bool init_service(void) {
 /*
   check for an existing tinc for this net, and write pid to pidfile
 */
-static bool write_pidfile(void)
-{
+static bool write_pidfile(void) {
        pid_t pid;
 
        cp();
@@ -270,8 +267,7 @@ static bool write_pidfile(void)
 /*
   kill older tincd for this net
 */
-bool kill_other(int signal)
-{
+bool kill_other(int signal) {
 #ifndef HAVE_MINGW
        pid_t pid;
 
@@ -311,8 +307,7 @@ bool kill_other(int signal)
 /*
   Detach from current terminal, write pidfile, kill parent
 */
-bool detach(void)
-{
+bool detach(void) {
        cp();
 
        setup_signals();
@@ -358,8 +353,7 @@ bool detach(void)
        return true;
 }
 
-bool execute_script(const char *name, char **envp)
-{
+bool execute_script(const char *name, char **envp) {
 #ifdef HAVE_SYSTEM
        int status, len;
        char *scriptname, *p;
@@ -443,8 +437,7 @@ bool execute_script(const char *name, char **envp)
 */
 
 #ifndef HAVE_MINGW
-static RETSIGTYPE sigterm_handler(int a)
-{
+static RETSIGTYPE sigterm_handler(int a) {
        logger(LOG_NOTICE, _("Got %s signal"), "TERM");
        if(running)
                running = false;
@@ -452,8 +445,7 @@ static RETSIGTYPE sigterm_handler(int a)
                exit(1);
 }
 
-static RETSIGTYPE sigquit_handler(int a)
-{
+static RETSIGTYPE sigquit_handler(int a) {
        logger(LOG_NOTICE, _("Got %s signal"), "QUIT");
        if(running)
                running = false;
@@ -461,16 +453,14 @@ static RETSIGTYPE sigquit_handler(int a)
                exit(1);
 }
 
-static RETSIGTYPE fatal_signal_square(int a)
-{
+static RETSIGTYPE fatal_signal_square(int a) {
        logger(LOG_ERR, _("Got another fatal signal %d (%s): not restarting."), a,
                   strsignal(a));
        cp_trace();
        exit(1);
 }
 
-static RETSIGTYPE fatal_signal_handler(int a)
-{
+static RETSIGTYPE fatal_signal_handler(int a) {
        struct sigaction act;
        logger(LOG_ERR, _("Got fatal signal %d (%s)"), a, strsignal(a));
        cp_trace();
@@ -493,14 +483,12 @@ static RETSIGTYPE fatal_signal_handler(int a)
        }
 }
 
-static RETSIGTYPE sighup_handler(int a)
-{
+static RETSIGTYPE sighup_handler(int a) {
        logger(LOG_NOTICE, _("Got %s signal"), "HUP");
        sighup = true;
 }
 
-static RETSIGTYPE sigint_handler(int a)
-{
+static RETSIGTYPE sigint_handler(int a) {
        logger(LOG_NOTICE, _("Got %s signal"), "INT");
 
        if(saved_debug_level != -1) {
@@ -517,38 +505,32 @@ static RETSIGTYPE sigint_handler(int a)
        }
 }
 
-static RETSIGTYPE sigalrm_handler(int a)
-{
+static RETSIGTYPE sigalrm_handler(int a) {
        logger(LOG_NOTICE, _("Got %s signal"), "ALRM");
        sigalrm = true;
 }
 
-static RETSIGTYPE sigusr1_handler(int a)
-{
+static RETSIGTYPE sigusr1_handler(int a) {
        dump_connections();
 }
 
-static RETSIGTYPE sigusr2_handler(int a)
-{
+static RETSIGTYPE sigusr2_handler(int a) {
        dump_device_stats();
        dump_nodes();
        dump_edges();
        dump_subnets();
 }
 
-static RETSIGTYPE sigwinch_handler(int a)
-{
+static RETSIGTYPE sigwinch_handler(int a) {
        do_purge = true;
 }
 
-static RETSIGTYPE unexpected_signal_handler(int a)
-{
+static RETSIGTYPE unexpected_signal_handler(int a) {
        logger(LOG_WARNING, _("Got unexpected signal %d (%s)"), a, strsignal(a));
        cp_trace();
 }
 
-static RETSIGTYPE ignore_signal_handler(int a)
-{
+static RETSIGTYPE ignore_signal_handler(int a) {
        ifdebug(SCARY_THINGS) logger(LOG_DEBUG, _("Ignored signal %d (%s)"), a, strsignal(a));
 }
 
@@ -573,8 +555,7 @@ static struct {
 };
 #endif
 
-void setup_signals(void)
-{
+void setup_signals(void) {
 #ifndef HAVE_MINGW
        int i;
        struct sigaction act;

diff --git a/src/protocol.c b/src/protocol.c
index 0476351..78781a6 100644 (file)
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -53,8 +53,7 @@ static char (*request_name[]) = {
 
 static avl_tree_t *past_request_tree;
 
-bool check_id(const char *id)
-{
+bool check_id(const char *id) {
        for(; *id; id++)
                if(!isalnum(*id) && *id != '_')
                        return false;
@@ -65,8 +64,7 @@ bool check_id(const char *id)
 /* Generic request routines - takes care of logging and error
    detection as well */
 
-bool send_request(connection_t *c, const char *format, ...)
-{
+bool send_request(connection_t *c, const char *format, ...) {
        va_list args;
        char buffer[MAXBUFSIZE];
        int len, request;
@@ -106,8 +104,7 @@ bool send_request(connection_t *c, const char *format, ...)
                return send_meta(c, buffer, len);
 }
 
-void forward_request(connection_t *from)
-{
+void forward_request(connection_t *from) {
        int request;
 
        cp();
@@ -128,8 +125,7 @@ void forward_request(connection_t *from)
        broadcast_meta(from, from->buffer, from->reqlen);
 }
 
-bool receive_request(connection_t *c)
-{
+bool receive_request(connection_t *c) {
        int request;
 
        cp();
@@ -178,13 +174,11 @@ bool receive_request(connection_t *c)
        return true;
 }
 
-static int past_request_compare(const past_request_t *a, const past_request_t *b)
-{
+static int past_request_compare(const past_request_t *a, const past_request_t *b) {
        return strcmp(a->request, b->request);
 }
 
-static void free_past_request(past_request_t *r)
-{
+static void free_past_request(past_request_t *r) {
        cp();
 
        if(r->request)
@@ -193,22 +187,19 @@ static void free_past_request(past_request_t *r)
        free(r);
 }
 
-void init_requests(void)
-{
+void init_requests(void) {
        cp();
 
        past_request_tree = avl_alloc_tree((avl_compare_t) past_request_compare, (avl_action_t) free_past_request);
 }
 
-void exit_requests(void)
-{
+void exit_requests(void) {
        cp();
 
        avl_delete_tree(past_request_tree);
 }
 
-bool seen_request(char *request)
-{
+bool seen_request(char *request) {
        past_request_t *new, p = {0};
 
        cp();
@@ -227,8 +218,7 @@ bool seen_request(char *request)
        }
 }
 
-void age_past_requests(void)
-{
+void age_past_requests(void) {
        avl_node_t *node, *next;
        past_request_t *p;
        int left = 0, deleted = 0;

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index a88c36b..5926a12 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -38,16 +38,14 @@
 #include "utils.h"
 #include "xalloc.h"
 
-bool send_id(connection_t *c)
-{
+bool send_id(connection_t *c) {
        cp();
 
        return send_request(c, "%d %s %d", ID, myself->connection->name,
                                                myself->connection->protocol_version);
 }
 
-bool id_h(connection_t *c)
-{
+bool id_h(connection_t *c) {
        char name[MAX_STRING_SIZE];
 
        cp();
@@ -114,8 +112,7 @@ bool id_h(connection_t *c)
        return send_metakey(c);
 }
 
-bool send_metakey(connection_t *c)
-{
+bool send_metakey(connection_t *c) {
        char *buffer;
        int len;
        bool x;
@@ -199,8 +196,7 @@ bool send_metakey(connection_t *c)
        return x;
 }
 
-bool metakey_h(connection_t *c)
-{
+bool metakey_h(connection_t *c) {
        char buffer[MAX_STRING_SIZE];
        int cipher, digest, maclength, compression;
        int len;
@@ -298,8 +294,7 @@ bool metakey_h(connection_t *c)
        return send_challenge(c);
 }
 
-bool send_challenge(connection_t *c)
-{
+bool send_challenge(connection_t *c) {
        char *buffer;
        int len;
 
@@ -329,8 +324,7 @@ bool send_challenge(connection_t *c)
        return send_request(c, "%d %s", CHALLENGE, buffer);
 }
 
-bool challenge_h(connection_t *c)
-{
+bool challenge_h(connection_t *c) {
        char buffer[MAX_STRING_SIZE];
        int len;
 
@@ -367,8 +361,7 @@ bool challenge_h(connection_t *c)
        return send_chal_reply(c);
 }
 
-bool send_chal_reply(connection_t *c)
-{
+bool send_chal_reply(connection_t *c) {
        char hash[EVP_MAX_MD_SIZE * 2 + 1];
        EVP_MD_CTX ctx;
 
@@ -394,8 +387,7 @@ bool send_chal_reply(connection_t *c)
        return send_request(c, "%d %s", CHAL_REPLY, hash);
 }
 
-bool chal_reply_h(connection_t *c)
-{
+bool chal_reply_h(connection_t *c) {
        char hishash[MAX_STRING_SIZE];
        char myhash[EVP_MAX_MD_SIZE];
        EVP_MD_CTX ctx;
@@ -454,8 +446,7 @@ bool chal_reply_h(connection_t *c)
        return send_ack(c);
 }
 
-bool send_ack(connection_t *c)
-{
+bool send_ack(connection_t *c) {
        /* ACK message contains rest of the information the other end needs
           to create node_t and edge_t structures. */
 
@@ -485,8 +476,7 @@ bool send_ack(connection_t *c)
        return send_request(c, "%d %s %d %lx", ACK, myport, c->estimated_weight, c->options);
 }
 
-static void send_everything(connection_t *c)
-{
+static void send_everything(connection_t *c) {
        avl_node_t *node, *node2;
        node_t *n;
        subnet_t *s;
@@ -518,8 +508,7 @@ static void send_everything(connection_t *c)
        }
 }
 
-bool ack_h(connection_t *c)
-{
+bool ack_h(connection_t *c) {
        char hisport[MAX_STRING_SIZE];
        char *hisaddress, *dummy;
        int weight, mtu;

diff --git a/src/protocol_edge.c b/src/protocol_edge.c
index c2a391b..6fa9dee 100644 (file)
--- a/src/protocol_edge.c
+++ b/src/protocol_edge.c
@@ -35,8 +35,7 @@
 #include "utils.h"
 #include "xalloc.h"
 
-bool send_add_edge(connection_t *c, const edge_t *e)
-{
+bool send_add_edge(connection_t *c, const edge_t *e) {
        bool x;
        char *address, *port;
 
@@ -53,8 +52,7 @@ bool send_add_edge(connection_t *c, const edge_t *e)
        return x;
 }
 
-bool add_edge_h(connection_t *c)
-{
+bool add_edge_h(connection_t *c) {
        edge_t *e;
        node_t *from, *to;
        char from_name[MAX_STRING_SIZE];
@@ -173,16 +171,14 @@ bool add_edge_h(connection_t *c)
        return true;
 }
 
-bool send_del_edge(connection_t *c, const edge_t *e)
-{
+bool send_del_edge(connection_t *c, const edge_t *e) {
        cp();
 
        return send_request(c, "%d %x %s %s", DEL_EDGE, rand(),
                                                e->from->name, e->to->name);
 }
 
-bool del_edge_h(connection_t *c)
-{
+bool del_edge_h(connection_t *c) {
        edge_t *e;
        char from_name[MAX_STRING_SIZE];
        char to_name[MAX_STRING_SIZE];

diff --git a/src/protocol_key.c b/src/protocol_key.c
index 5370e61..cd95d9c 100644 (file)
--- a/src/protocol_key.c
+++ b/src/protocol_key.c
@@ -36,8 +36,7 @@
 
 bool mykeyused = false;
 
-bool send_key_changed()
-{
+bool send_key_changed() {
        cp();
 
        /* Only send this message if some other daemon requested our key previously.
@@ -50,8 +49,7 @@ bool send_key_changed()
        return send_request(broadcast, "%d %x %s", KEY_CHANGED, rand(), myself->name);
 }
 
-bool key_changed_h(connection_t *c)
-{
+bool key_changed_h(connection_t *c) {
        char name[MAX_STRING_SIZE];
        node_t *n;
 
@@ -85,15 +83,13 @@ bool key_changed_h(connection_t *c)
        return true;
 }
 
-bool send_req_key(node_t *to)
-{
+bool send_req_key(node_t *to) {
        cp();
 
        return send_request(to->nexthop->connection, "%d %s %s", REQ_KEY, myself->name, to->name);
 }
 
-bool req_key_h(connection_t *c)
-{
+bool req_key_h(connection_t *c) {
        char from_name[MAX_STRING_SIZE];
        char to_name[MAX_STRING_SIZE];
        node_t *from, *to;
@@ -142,8 +138,7 @@ bool req_key_h(connection_t *c)
        return true;
 }
 
-bool send_ans_key(node_t *to)
-{
+bool send_ans_key(node_t *to) {
        char *key;
 
        cp();
@@ -180,8 +175,7 @@ bool send_ans_key(node_t *to)
                        to->incompression);
 }
 
-bool ans_key_h(connection_t *c)
-{
+bool ans_key_h(connection_t *c) {
        char from_name[MAX_STRING_SIZE];
        char to_name[MAX_STRING_SIZE];
        char key[MAX_STRING_SIZE];

diff --git a/src/protocol_misc.c b/src/protocol_misc.c
index 2e610cb..5499b34 100644 (file)
--- a/src/protocol_misc.c
+++ b/src/protocol_misc.c
@@ -33,8 +33,7 @@ int maxoutbufsize = 0;
 
 /* Status and error notification routines */
 
-bool send_status(connection_t *c, int statusno, const char *statusstring)
-{
+bool send_status(connection_t *c, int statusno, const char *statusstring) {
        cp();
 
        if(!statusstring)
@@ -43,8 +42,7 @@ bool send_status(connection_t *c, int statusno, const char *statusstring)
        return send_request(c, "%d %d %s", STATUS, statusno, statusstring);
 }
 
-bool status_h(connection_t *c)
-{
+bool status_h(connection_t *c) {
        int statusno;
        char statusstring[MAX_STRING_SIZE];
 
@@ -62,8 +60,7 @@ bool status_h(connection_t *c)
        return true;
 }
 
-bool send_error(connection_t *c, int err, const char *errstring)
-{
+bool send_error(connection_t *c, int err, const char *errstring) {
        cp();
 
        if(!errstring)
@@ -72,8 +69,7 @@ bool send_error(connection_t *c, int err, const char *errstring)
        return send_request(c, "%d %d %s", ERROR, err, errstring);
 }
 
-bool error_h(connection_t *c)
-{
+bool error_h(connection_t *c) {
        int err;
        char errorstring[MAX_STRING_SIZE];
 
@@ -93,15 +89,13 @@ bool error_h(connection_t *c)
        return true;
 }
 
-bool send_termreq(connection_t *c)
-{
+bool send_termreq(connection_t *c) {
        cp();
 
        return send_request(c, "%d", TERMREQ);
 }
 
-bool termreq_h(connection_t *c)
-{
+bool termreq_h(connection_t *c) {
        cp();
 
        terminate_connection(c, c->status.active);
@@ -109,8 +103,7 @@ bool termreq_h(connection_t *c)
        return true;
 }
 
-bool send_ping(connection_t *c)
-{
+bool send_ping(connection_t *c) {
        cp();
 
        c->status.pinged = true;
@@ -119,22 +112,19 @@ bool send_ping(connection_t *c)
        return send_request(c, "%d", PING);
 }
 
-bool ping_h(connection_t *c)
-{
+bool ping_h(connection_t *c) {
        cp();
 
        return send_pong(c);
 }
 
-bool send_pong(connection_t *c)
-{
+bool send_pong(connection_t *c) {
        cp();
 
        return send_request(c, "%d", PONG);
 }
 
-bool pong_h(connection_t *c)
-{
+bool pong_h(connection_t *c) {
        cp();
 
        c->status.pinged = false;
@@ -149,8 +139,7 @@ bool pong_h(connection_t *c)
 
 /* Sending and receiving packets via TCP */
 
-bool send_tcppacket(connection_t *c, vpn_packet_t *packet)
-{
+bool send_tcppacket(connection_t *c, vpn_packet_t *packet) {
        cp();
 
        /* If there already is a lot of data in the outbuf buffer, discard this packet.
@@ -165,8 +154,7 @@ bool send_tcppacket(connection_t *c, vpn_packet_t *packet)
        return send_meta(c, (char *)packet->data, packet->len);
 }
 
-bool tcppacket_h(connection_t *c)
-{
+bool tcppacket_h(connection_t *c) {
        short int len;
 
        cp();

diff --git a/src/protocol_subnet.c b/src/protocol_subnet.c
index 90c89af..c6c0187 100644 (file)
--- a/src/protocol_subnet.c
+++ b/src/protocol_subnet.c
@@ -32,8 +32,7 @@
 #include "utils.h"
 #include "xalloc.h"
 
-bool send_add_subnet(connection_t *c, const subnet_t *subnet)
-{
+bool send_add_subnet(connection_t *c, const subnet_t *subnet) {
        char netstr[MAXNETSTR];
 
        cp();
@@ -44,8 +43,7 @@ bool send_add_subnet(connection_t *c, const subnet_t *subnet)
        return send_request(c, "%d %x %s %s", ADD_SUBNET, rand(), subnet->owner->name, netstr);
 }
 
-bool add_subnet_h(connection_t *c)
-{
+bool add_subnet_h(connection_t *c) {
        char subnetstr[MAX_STRING_SIZE];
        char name[MAX_STRING_SIZE];
        node_t *owner;
@@ -151,8 +149,7 @@ bool add_subnet_h(connection_t *c)
        return true;
 }
 
-bool send_del_subnet(connection_t *c, const subnet_t *s)
-{
+bool send_del_subnet(connection_t *c, const subnet_t *s) {
        char netstr[MAXNETSTR];
 
        cp();
@@ -163,8 +160,7 @@ bool send_del_subnet(connection_t *c, const subnet_t *s)
        return send_request(c, "%d %x %s %s", DEL_SUBNET, rand(), s->owner->name, netstr);
 }
 
-bool del_subnet_h(connection_t *c)
-{
+bool del_subnet_h(connection_t *c) {
        char subnetstr[MAX_STRING_SIZE];
        char name[MAX_STRING_SIZE];
        node_t *owner;

diff --git a/src/raw_socket/device.c b/src/raw_socket/device.c
index 6c56ed6..5cefbce 100644 (file)
--- a/src/raw_socket/device.c
+++ b/src/raw_socket/device.c
@@ -38,8 +38,7 @@ static char *device_info;
 static int device_total_in = 0;
 static int device_total_out = 0;
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        struct ifreq ifr;
        struct sockaddr_ll sa;
 
@@ -83,8 +82,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
 
        close(device_fd);
@@ -93,8 +91,7 @@ void close_device(void)
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        int lenin;
 
        cp();
@@ -115,8 +112,7 @@ bool read_packet(vpn_packet_t *packet)
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        cp();
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
@@ -133,8 +129,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/route.c b/src/route.c
index a200983..6cc2fc1 100644 (file)
--- a/src/route.c
+++ b/src/route.c
@@ -51,8 +51,7 @@ static const size_t opt_size = sizeof(struct nd_opt_hdr);
 
 /* RFC 1071 */
 
-static uint16_t inet_checksum(void *data, int len, uint16_t prevsum)
-{
+static uint16_t inet_checksum(void *data, int len, uint16_t prevsum) {
        uint16_t *p = data;
        uint32_t checksum = prevsum ^ 0xFFFF;
 
@@ -100,8 +99,7 @@ static void swap_mac_addresses(vpn_packet_t *packet) {
        memcpy(&packet->data[6], &tmp, sizeof tmp);
 }
        
-static void learn_mac(mac_t *address)
-{
+static void learn_mac(mac_t *address) {
        subnet_t *subnet;
        avl_node_t *node;
        connection_t *c;
@@ -136,8 +134,7 @@ static void learn_mac(mac_t *address)
                subnet->expires = now + macexpire;
 }
 
-void age_subnets(void)
-{
+void age_subnets(void) {
        subnet_t *s;
        connection_t *c;
        avl_node_t *node, *next, *node2;
@@ -167,8 +164,7 @@ void age_subnets(void)
 
 /* RFC 792 */
 
-static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, uint8_t type, uint8_t code)
-{
+static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, uint8_t type, uint8_t code) {
        struct ip ip = {0};
        struct icmp icmp = {0};
        
@@ -293,8 +289,7 @@ static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet) {
        }       
 }
 
-static void route_ipv4_unicast(node_t *source, vpn_packet_t *packet)
-{
+static void route_ipv4_unicast(node_t *source, vpn_packet_t *packet) {
        subnet_t *subnet;
        node_t *via;
        ipv4_t dest;
@@ -344,8 +339,7 @@ static void route_ipv4_unicast(node_t *source, vpn_packet_t *packet)
        send_packet(subnet->owner, packet);
 }
 
-static void route_ipv4(node_t *source, vpn_packet_t *packet)
-{
+static void route_ipv4(node_t *source, vpn_packet_t *packet) {
        cp();
 
        if(!checklength(source, packet, ether_size + ip_size))
@@ -363,8 +357,7 @@ static void route_ipv4(node_t *source, vpn_packet_t *packet)
 
 /* RFC 2463 */
 
-static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, uint8_t type, uint8_t code)
-{
+static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, uint8_t type, uint8_t code) {
        struct ip6_hdr ip6;
        struct icmp6_hdr icmp6 = {0};
        uint16_t checksum;      
@@ -444,8 +437,7 @@ static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, uint8_t
        send_packet(source, packet);
 }
 
-static void route_ipv6_unicast(node_t *source, vpn_packet_t *packet)
-{
+static void route_ipv6_unicast(node_t *source, vpn_packet_t *packet) {
        subnet_t *subnet;
        node_t *via;
        ipv6_t dest;
@@ -493,8 +485,7 @@ static void route_ipv6_unicast(node_t *source, vpn_packet_t *packet)
 
 /* RFC 2461 */
 
-static void route_neighborsol(node_t *source, vpn_packet_t *packet)
-{
+static void route_neighborsol(node_t *source, vpn_packet_t *packet) {
        struct ip6_hdr ip6;
        struct nd_neighbor_solicit ns;
        struct nd_opt_hdr opt;
@@ -635,8 +626,7 @@ static void route_neighborsol(node_t *source, vpn_packet_t *packet)
        send_packet(source, packet);
 }
 
-static void route_ipv6(node_t *source, vpn_packet_t *packet)
-{
+static void route_ipv6(node_t *source, vpn_packet_t *packet) {
        cp();
 
        if(!checklength(source, packet, ether_size + ip6_size))
@@ -655,8 +645,7 @@ static void route_ipv6(node_t *source, vpn_packet_t *packet)
 
 /* RFC 826 */
 
-static void route_arp(node_t *source, vpn_packet_t *packet)
-{
+static void route_arp(node_t *source, vpn_packet_t *packet) {
        struct ether_arp arp;
        subnet_t *subnet;
        struct in_addr addr;
@@ -722,8 +711,7 @@ static void route_arp(node_t *source, vpn_packet_t *packet)
        send_packet(source, packet);
 }
 
-static void route_mac(node_t *source, vpn_packet_t *packet)
-{
+static void route_mac(node_t *source, vpn_packet_t *packet) {
        subnet_t *subnet;
        mac_t dest;
 
@@ -779,8 +767,7 @@ static void route_mac(node_t *source, vpn_packet_t *packet)
 }
 
 
-void route(node_t *source, vpn_packet_t *packet)
-{
+void route(node_t *source, vpn_packet_t *packet) {
        cp();
 
        if(!checklength(source, packet, ether_size))

diff --git a/src/solaris/device.c b/src/solaris/device.c
index 28c8ff7..71d9bda 100644 (file)
--- a/src/solaris/device.c
+++ b/src/solaris/device.c
@@ -41,8 +41,7 @@ static char *device_info = NULL;
 static int device_total_in = 0;
 static int device_total_out = 0;
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        int ip_fd = -1, if_fd = -1;
        int ppa;
        char *ptr;
@@ -107,8 +106,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
 
        close(device_fd);
@@ -117,8 +115,7 @@ void close_device(void)
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        int lenin;
 
        cp();
@@ -155,8 +152,7 @@ bool read_packet(vpn_packet_t *packet)
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        cp();
 
        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
@@ -173,8 +169,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);

diff --git a/src/subnet.c b/src/subnet.c
index 3c7ccc5..fa1ee63 100644 (file)
--- a/src/subnet.c
+++ b/src/subnet.c
@@ -54,8 +54,7 @@ void subnet_cache_flush() {
 
 /* Subnet comparison */
 
-static int subnet_compare_mac(const subnet_t *a, const subnet_t *b)
-{
+static int subnet_compare_mac(const subnet_t *a, const subnet_t *b) {
        int result;
 
        result = memcmp(&a->net.mac.address, &b->net.mac.address, sizeof(mac_t));
@@ -71,8 +70,7 @@ static int subnet_compare_mac(const subnet_t *a, const subnet_t *b)
        return strcmp(a->owner->name, b->owner->name);
 }
 
-static int subnet_compare_ipv4(const subnet_t *a, const subnet_t *b)
-{
+static int subnet_compare_ipv4(const subnet_t *a, const subnet_t *b) {
        int result;
 
        result = b->net.ipv4.prefixlength - a->net.ipv4.prefixlength;
@@ -93,8 +91,7 @@ static int subnet_compare_ipv4(const subnet_t *a, const subnet_t *b)
        return strcmp(a->owner->name, b->owner->name);
 }
 
-static int subnet_compare_ipv6(const subnet_t *a, const subnet_t *b)
-{
+static int subnet_compare_ipv6(const subnet_t *a, const subnet_t *b) {
        int result;
 
        result = b->net.ipv6.prefixlength - a->net.ipv6.prefixlength;
@@ -115,8 +112,7 @@ static int subnet_compare_ipv6(const subnet_t *a, const subnet_t *b)
        return strcmp(a->owner->name, b->owner->name);
 }
 
-int subnet_compare(const subnet_t *a, const subnet_t *b)
-{
+int subnet_compare(const subnet_t *a, const subnet_t *b) {
        int result;
 
        result = a->type - b->type;
@@ -143,8 +139,7 @@ int subnet_compare(const subnet_t *a, const subnet_t *b)
 
 /* Initialising trees */
 
-void init_subnets(void)
-{
+void init_subnets(void) {
        cp();
 
        subnet_tree = avl_alloc_tree((avl_compare_t) subnet_compare, (avl_action_t) free_subnet);
@@ -152,22 +147,19 @@ void init_subnets(void)
        subnet_cache_flush();
 }
 
-void exit_subnets(void)
-{
+void exit_subnets(void) {
        cp();
 
        avl_delete_tree(subnet_tree);
 }
 
-avl_tree_t *new_subnet_tree(void)
-{
+avl_tree_t *new_subnet_tree(void) {
        cp();
 
        return avl_alloc_tree((avl_compare_t) subnet_compare, NULL);
 }
 
-void free_subnet_tree(avl_tree_t *subnet_tree)
-{
+void free_subnet_tree(avl_tree_t *subnet_tree) {
        cp();
 
        avl_delete_tree(subnet_tree);
@@ -175,15 +167,13 @@ void free_subnet_tree(avl_tree_t *subnet_tree)
 
 /* Allocating and freeing space for subnets */
 
-subnet_t *new_subnet(void)
-{
+subnet_t *new_subnet(void) {
        cp();
 
        return xmalloc_and_zero(sizeof(subnet_t));
 }
 
-void free_subnet(subnet_t *subnet)
-{
+void free_subnet(subnet_t *subnet) {
        cp();
 
        free(subnet);
@@ -191,8 +181,7 @@ void free_subnet(subnet_t *subnet)
 
 /* Adding and removing subnets */
 
-void subnet_add(node_t *n, subnet_t *subnet)
-{
+void subnet_add(node_t *n, subnet_t *subnet) {
        cp();
 
        subnet->owner = n;
@@ -203,8 +192,7 @@ void subnet_add(node_t *n, subnet_t *subnet)
        subnet_cache_flush();
 }
 
-void subnet_del(node_t *n, subnet_t *subnet)
-{
+void subnet_del(node_t *n, subnet_t *subnet) {
        cp();
 
        avl_delete(n->subnet_tree, subnet);
@@ -215,8 +203,7 @@ void subnet_del(node_t *n, subnet_t *subnet)
 
 /* Ascii representation of subnets */
 
-bool str2net(subnet_t *subnet, const char *subnetstr)
-{
+bool str2net(subnet_t *subnet, const char *subnetstr) {
        int i, l;
        uint16_t x[8];
        int weight = 10;
@@ -297,8 +284,7 @@ bool str2net(subnet_t *subnet, const char *subnetstr)
        return false;
 }
 
-bool net2str(char *netstr, int len, const subnet_t *subnet)
-{
+bool net2str(char *netstr, int len, const subnet_t *subnet) {
        cp();
 
        if(!netstr || !subnet) {
@@ -355,15 +341,13 @@ bool net2str(char *netstr, int len, const subnet_t *subnet)
 
 /* Subnet lookup routines */
 
-subnet_t *lookup_subnet(const node_t *owner, const subnet_t *subnet)
-{
+subnet_t *lookup_subnet(const node_t *owner, const subnet_t *subnet) {
        cp();
 
        return avl_search(owner->subnet_tree, subnet);
 }
 
-subnet_t *lookup_subnet_mac(const mac_t *address)
-{
+subnet_t *lookup_subnet_mac(const mac_t *address) {
        subnet_t *p, subnet = {0};
 
        cp();
@@ -377,8 +361,7 @@ subnet_t *lookup_subnet_mac(const mac_t *address)
        return p;
 }
 
-subnet_t *lookup_subnet_ipv4(const ipv4_t *address)
-{
+subnet_t *lookup_subnet_ipv4(const ipv4_t *address) {
        subnet_t *p, *r = NULL, subnet = {0};
        avl_node_t *n;
        int i;
@@ -424,8 +407,7 @@ subnet_t *lookup_subnet_ipv4(const ipv4_t *address)
        return r;
 }
 
-subnet_t *lookup_subnet_ipv6(const ipv6_t *address)
-{
+subnet_t *lookup_subnet_ipv6(const ipv6_t *address) {
        subnet_t *p, *r = NULL, subnet = {0};
        avl_node_t *n;
        int i;
@@ -538,8 +520,7 @@ void subnet_update(node_t *owner, subnet_t *subnet, bool up) {
                free(envp[i]);
 }
 
-void dump_subnets(void)
-{
+void dump_subnets(void) {
        char netstr[MAXNETSTR];
        subnet_t *subnet;
        avl_node_t *node;

diff --git a/src/tincd.c b/src/tincd.c
index 1f36442..a01ed58 100644 (file)
--- a/src/tincd.c
+++ b/src/tincd.c
@@ -117,8 +117,7 @@ static struct WSAData wsa_state;
 CRITICAL_SECTION mutex;
 #endif
 
-static void usage(bool status)
-{
+static void usage(bool status) {
        if(status)
                fprintf(stderr, _("Try `%s --help\' for more information.\n"),
                                program_name);
@@ -141,8 +140,7 @@ static void usage(bool status)
        }
 }
 
-static bool parse_options(int argc, char **argv)
-{
+static bool parse_options(int argc, char **argv) {
        int r;
        int option_index = 0;
 
@@ -275,8 +273,7 @@ static bool parse_options(int argc, char **argv)
 
 /* This function prettyprints the key generation process */
 
-static void indicator(int a, int b, void *p)
-{
+static void indicator(int a, int b, void *p) {
        switch (a) {
                case 0:
                        fprintf(stderr, ".");
@@ -314,8 +311,7 @@ static void indicator(int a, int b, void *p)
   Generate a public/private RSA keypair, and ask for a file to store
   them in.
 */
-static bool keygen(int bits)
-{
+static bool keygen(int bits) {
        RSA *rsa_key;
        FILE *f;
        char *name = NULL;
@@ -380,8 +376,7 @@ static bool keygen(int bits)
 /*
   Set all files and paths according to netname
 */
-static void make_names(void)
-{
+static void make_names(void) {
 #ifdef HAVE_MINGW
        HKEY key;
        char installdir[1024] = "";
@@ -493,8 +488,7 @@ static bool drop_privs() {
 # define setpriority(level) nice(level)
 #endif
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
        program_name = argv[0];
 
        setlocale(LC_ALL, "");
@@ -566,8 +560,7 @@ int main(int argc, char **argv)
                return 1;
 }
 
-int main2(int argc, char **argv)
-{
+int main2(int argc, char **argv) {
        InitializeCriticalSection(&mutex);
        EnterCriticalSection(&mutex);
 #endif

diff --git a/src/uml_socket/device.c b/src/uml_socket/device.c
index 81a4c21..fa46f65 100644 (file)
--- a/src/uml_socket/device.c
+++ b/src/uml_socket/device.c
@@ -55,8 +55,7 @@ static struct request {
 
 static struct sockaddr_un data_sun;
 
-bool setup_device(void)
-{
+bool setup_device(void) {
        struct sockaddr_un listen_sun;
        static const int one = 1;
        struct {
@@ -152,8 +151,7 @@ bool setup_device(void)
        return true;
 }
 
-void close_device(void)
-{
+void close_device(void) {
        cp();
 
        if(listen_fd >= 0)
@@ -174,8 +172,7 @@ void close_device(void)
        if(iface) free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet)
-{
+bool read_packet(vpn_packet_t *packet) {
        int lenin;
 
        cp();
@@ -255,8 +252,7 @@ bool read_packet(vpn_packet_t *packet)
        }
 }
 
-bool write_packet(vpn_packet_t *packet)
-{
+bool write_packet(vpn_packet_t *packet) {
        cp();
 
        if(state != 2) {
@@ -282,8 +278,7 @@ bool write_packet(vpn_packet_t *packet)
        return true;
 }
 
-void dump_device_stats(void)
-{
+void dump_device_stats(void) {
        cp();
 
        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);