]> git.meshlink.io Git - meshlink/blob - src/edge.c
da1cdb45fe79209089d03a9a91204991d86f2905
[meshlink] / src / edge.c
1 /*
2     edge.c -- edge tree management
3     Copyright (C) 2000-2002 Guus Sliepen <guus@sliepen.warande.net>,
4                   2000-2002 Ivo Timmermans <itimmermans@bigfoot.com>
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: edge.c,v 1.1.2.9 2002/03/22 13:31:18 guus Exp $
21 */
22
23 #include "config.h"
24
25 #include <stdio.h>
26 #include <syslog.h>
27 #include <string.h>
28
29 #include <avl_tree.h>
30 #include <list.h>
31
32 #include "net.h"        /* Don't ask. */
33 #include "netutl.h"
34 #include "config.h"
35 #include "conf.h"
36 #include <utils.h>
37 #include "subnet.h"
38
39 #include "xalloc.h"
40 #include "system.h"
41
42 avl_tree_t *edge_tree;        /* Tree with all known edges (replaces active_tree) */
43 avl_tree_t *edge_weight_tree; /* Tree with all edges, sorted on weight */
44
45 int edge_compare(edge_t *a, edge_t *b)
46 {
47   int result;
48
49   result = strcmp(a->from.node->name, b->from.node->name);
50
51   if(result)
52     return result;
53   else
54     return strcmp(a->to.node->name, b->to.node->name);
55 }
56
57 /* Evil edge_compare() from a parallel universe ;)
58
59 int edge_compare(edge_t *a, edge_t *b)
60 {
61   int result;
62
63   return (result = strcmp(a->from.node->name, b->from.node->name)) || (result = strcmp(a->to.node->name, b->to.node->name)), result;
64 }
65
66 */
67
68 int edge_name_compare(edge_t *a, edge_t *b)
69 {
70   int result;
71   char *name_a1, *name_a2, *name_b1, *name_b2;
72
73   if(strcmp(a->from.node->name, a->to.node->name) < 0)
74     name_a1 = a->from.node->name, name_a2 = a->to.node->name;
75   else
76     name_a1 = a->to.node->name, name_a2 = a->from.node->name;
77
78   if(strcmp(b->from.node->name, b->to.node->name) < 0)
79     name_b1 = b->from.node->name, name_b2 = b->to.node->name;
80   else
81     name_b1 = b->to.node->name, name_b2 = b->from.node->name;
82
83   result = strcmp(name_a1, name_b1);
84
85   if(result)
86     return result;
87   else
88     return strcmp(name_a2, name_b2);
89 }
90
91 int edge_weight_compare(edge_t *a, edge_t *b)
92 {
93   int result;
94
95   result = a->weight - b->weight;
96
97   if(result)
98     return result;
99   else
100     return edge_name_compare(a, b);
101 }
102
103 void init_edges(void)
104 {
105 cp
106   edge_tree = avl_alloc_tree((avl_compare_t)edge_compare, NULL);
107   edge_weight_tree = avl_alloc_tree((avl_compare_t)edge_weight_compare, NULL);
108 cp
109 }
110
111 avl_tree_t *new_edge_tree(void)
112 {
113 cp
114   return avl_alloc_tree((avl_compare_t)edge_name_compare, NULL);
115 cp
116 }
117
118 void free_edge_tree(avl_tree_t *edge_tree)
119 {
120 cp
121   avl_delete_tree(edge_tree);
122 cp
123 }
124
125 void exit_edges(void)
126 {
127 cp
128   avl_delete_tree(edge_tree);
129 cp
130 }
131
132 /* Creation and deletion of connection elements */
133
134 edge_t *new_edge(void)
135 {
136   edge_t *e;
137 cp
138   e = (edge_t *)xmalloc_and_zero(sizeof(*e));
139 cp
140   return e;
141 }
142
143 void free_edge(edge_t *e)
144 {
145 cp
146   free(e);
147 cp
148 }
149
150 void edge_add(edge_t *e)
151 {
152 cp
153   avl_insert(edge_tree, e);
154   avl_insert(edge_weight_tree, e);
155   avl_insert(e->from.node->edge_tree, e);
156   avl_insert(e->to.node->edge_tree, e);
157 cp
158 }
159
160 void edge_del(edge_t *e)
161 {
162 cp
163   avl_delete(edge_tree, e);
164   avl_delete(edge_weight_tree, e);
165   avl_delete(e->from.node->edge_tree, e);
166   avl_delete(e->to.node->edge_tree, e);
167 cp
168 }
169
170 edge_t *lookup_edge(node_t *from, node_t *to)
171 {
172   edge_t v, *result;
173 cp
174   v.from.node = from;
175   v.to.node = to;
176
177   result = avl_search(edge_tree, &v);
178
179   if(result)
180     return result;
181 cp
182   v.from.node = to;
183   v.to.node = from;
184
185   return avl_search(edge_tree, &v);
186 }
187
188 void dump_edges(void)
189 {
190   avl_node_t *node;
191   edge_t *e;
192   char *from_tcp, *from_udp;
193   char *to_tcp, *to_udp;
194 cp
195   syslog(LOG_DEBUG, _("Edges:"));
196
197   for(node = edge_tree->head; node; node = node->next)
198     {
199       e = (edge_t *)node->data;
200 //      from_tcp = sockaddr2hostname(&e->from.tcpaddress);
201       from_udp = sockaddr2hostname(&e->from.udpaddress);
202 //      to_tcp = sockaddr2hostname(&e->to.tcpaddress);
203       to_udp = sockaddr2hostname(&e->to.udpaddress);
204       syslog(LOG_DEBUG, _(" %s at %s - %s at %s options %lx weight %d"),
205              e->from.node->name, from_udp,
206              e->to.node->name, to_udp,
207              e->options, e->weight);
208 //      free(from_tcp);
209       free(from_udp);
210 //      free(to_tcp);   
211       free(to_udp);     
212     }
213
214   syslog(LOG_DEBUG, _("End of edges."));
215 cp
216 }