netjson: fix NetworkGraph output
[olsrd.git] / lib / netjson / src / olsrd_netjson_helpers.c
1 /*
2  * The olsr.org Optimized Link-State Routing daemon (olsrd)
3  *
4  * (c) by the OLSR project
5  *
6  * See our Git repository to find out who worked on this file
7  * and thus is a copyright holder on it.
8  *
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  *
15  * * Redistributions of source code must retain the above copyright
16  *   notice, this list of conditions and the following disclaimer.
17  * * Redistributions in binary form must reproduce the above copyright
18  *   notice, this list of conditions and the following disclaimer in
19  *   the documentation and/or other materials provided with the
20  *   distribution.
21  * * Neither the name of olsr.org, olsrd nor the names of its
22  *   contributors may be used to endorse or promote products derived
23  *   from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
28  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
29  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
31  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
32  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
33  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36  * POSSIBILITY OF SUCH DAMAGE.
37  *
38  * Visit http://www.olsr.org for more information.
39  *
40  * If you find this software useful feel free to make a donation
41  * to the project. For more information see the website or contact
42  * the copyright holders.
43  *
44  */
45
46 #include "olsrd_netjson_helpers.h"
47
48 #include "olsr.h"
49 #include <stddef.h>
50
51 struct node_entry * netjson_constructMidSelf(struct mid_entry *mid) {
52   struct node_entry *node_self;
53   struct olsr_if *ifs;
54
55   memset(mid, 0, sizeof(*mid));
56   mid->main_addr = olsr_cnf->main_addr;
57
58   node_self = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - self");
59   memset(node_self, 0, sizeof(*node_self));
60   node_self->avl.key = &olsr_cnf->main_addr;
61   node_self->isAlias = false;
62   node_self->mid = mid;
63
64   for (ifs = olsr_cnf->interfaces; ifs != NULL ; ifs = ifs->next) {
65     union olsr_ip_addr *addr = NULL;
66     bool is_self_main;
67
68     if (!ifs->configured) {
69       continue;
70     }
71
72     if (ifs->host_emul) {
73       addr = &ifs->hemu_ip;
74     } else {
75       struct interface_olsr *iface = ifs->interf;
76
77       if (!iface) {
78         continue;
79       }
80
81       addr = (olsr_cnf->ip_version == AF_INET) //
82           ? (union olsr_ip_addr *) &iface->int_addr.sin_addr //
83           : (union olsr_ip_addr *) &iface->int6_addr.sin6_addr;
84     }
85
86     is_self_main = (olsr_cnf->ip_version == AF_INET) //
87         ? ip4equal(&mid->main_addr.v4, &addr->v4) //
88         : ip6equal(&mid->main_addr.v6, &addr->v6);
89
90     if (!is_self_main) {
91       struct node_entry *node_self_alias;
92       struct mid_address *alias;
93
94       node_self_alias = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - self alias");
95       memset(node_self_alias, 0, sizeof(*node_self_alias));
96       node_self_alias->avl.key = addr;
97       node_self_alias->isAlias = true;
98       node_self_alias->mid = mid;
99
100       alias = olsr_malloc(sizeof(struct mid_address), "netjson NetworkGraph node - MID - self alias");
101       memset(alias, 0, sizeof(*alias));
102       alias->alias = *addr;
103       alias->main_entry = mid;
104       alias->next_alias = mid->aliases;
105       alias->vtime = 0;
106
107       mid->aliases = alias;
108     }
109   }
110
111   return node_self;
112 }
113
114 void netjson_cleanup_mid_self(struct node_entry *node_entry) {
115   if (node_entry->avl.key != &olsr_cnf->main_addr) {
116     return;
117   }
118
119   while (node_entry->mid->aliases) {
120     struct mid_address *alias = node_entry->mid->aliases;
121     node_entry->mid->aliases = node_entry->mid->aliases->next_alias;
122     free(alias);
123   }
124 }
125
126 void netjson_midIntoNodesTree(struct avl_tree *nodes, struct mid_entry *mid) {
127   struct avl_node *avlnode;
128   struct node_entry *node;
129   struct mid_address *alias;
130
131   avlnode = avl_find(nodes, &mid->main_addr);
132   if (!avlnode) {
133     /* the IP address is not yet known */
134
135     node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - main");
136     memset(node, 0, sizeof(*node));
137     node->avl.key = &mid->main_addr;
138     node->isAlias = false;
139     node->mid = mid;
140     if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
141       /* duplicate */
142       free(node);
143     }
144   }
145
146   alias = mid->aliases;
147   while (alias) {
148     avlnode = avl_find(nodes, &alias->alias);
149     if (!avlnode) {
150       /* the IP address is not yet known */
151
152       node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - MID - alias");
153       memset(node, 0, sizeof(*node));
154       node->avl.key = &alias->alias;
155       node->isAlias = true;
156       node->mid = mid;
157       if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
158         /* duplicate */
159         free(node);
160       }
161     }
162
163     alias = alias->next_alias;
164   }
165 }
166
167 void netjson_tcIntoNodesTree(struct avl_tree *nodes, struct tc_entry *tc) {
168   struct avl_node *avlnode;
169   struct node_entry *node;
170
171   avlnode = avl_find(nodes, &tc->addr);
172   if (avlnode) {
173     /* the IP address is already known */
174     return;
175   }
176
177   /* the IP address is not yet known */
178
179   node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - TC - main");
180   memset(node, 0, sizeof(*node));
181   node->avl.key = &tc->addr;
182   node->isAlias = false;
183   node->tc = tc;
184   if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
185     /* duplicate */
186     free(node);
187   }
188 }
189
190 void netjson_tcEdgeIntoNodesTree(struct avl_tree *nodes, struct tc_edge_entry *tc_edge) {
191   struct avl_node *avlnode;
192   struct node_entry *node;
193
194   avlnode = avl_find(nodes, &tc_edge->T_dest_addr);
195   if (avlnode) {
196     /* the IP address is already known */
197     return;
198   }
199
200   /* the IP address is not yet known */
201
202   node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - TC - main");
203   memset(node, 0, sizeof(*node));
204   node->avl.key = &tc_edge->T_dest_addr;
205   node->isAlias = false;
206   node->tc_edge = tc_edge;
207   if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
208     /* duplicate */
209     free(node);
210   }
211 }
212
213 void netjson_linkIntoNodesTree(struct avl_tree *nodes, struct link_entry *link, union olsr_ip_addr *addr) {
214   struct avl_node *avlnode;
215   struct node_entry *node;
216
217   avlnode = avl_find(nodes, addr);
218   if (avlnode) {
219     /* the IP address is already known */
220     return;
221   }
222
223   /* the IP address is not yet known */
224
225   node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - link");
226   memset(node, 0, sizeof(*node));
227   node->avl.key = addr;
228   node->isAlias = false;
229   node->link = link;
230   if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
231     /* duplicate */
232     free(node);
233   }
234 }
235
236 void netjson_neighborIntoNodesTree(struct avl_tree *nodes, struct neighbor_entry *neighbor) {
237   struct avl_node *avlnode;
238   struct node_entry *node;
239
240   avlnode = avl_find(nodes, &neighbor->neighbor_main_addr);
241   if (avlnode) {
242     /* the IP address is already known */
243     return;
244   }
245
246   /* the IP address is not yet known */
247
248   node = olsr_malloc(sizeof(struct node_entry), "netjson NetworkGraph node - neighbor");
249   memset(node, 0, sizeof(*node));
250   node->avl.key = &neighbor->neighbor_main_addr;
251   node->isAlias = false;
252   node->neighbor = neighbor;
253   if (avl_insert(nodes, &node->avl, AVL_DUP_NO) == -1) {
254     /* duplicate */
255     free(node);
256   }
257 }