Keep statistics of logged warnings
[oonf.git] / src-plugins / nhdp / nhdp / nhdp_domain.h
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon version 2 (olsrd2)
4  * Copyright (c) 2004-2015, the olsr.org team - see HISTORY file
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright
14  *   notice, this list of conditions and the following disclaimer in
15  *   the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of olsr.org, olsrd nor the names of its
18  *   contributors may be used to endorse or promote products derived
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Visit http://www.olsr.org for more information.
35  *
36  * If you find this software useful feel free to make a donation
37  * to the project. For more information see the website or contact
38  * the copyright holders.
39  *
40  */
41
42 /**
43  * @file
44  */
45
46 #ifndef NHDP_DOMAIN_H_
47 #define NHDP_DOMAIN_H_
48
49 #include "common/common_types.h"
50 #include "common/list.h"
51 #include "subsystems/oonf_rfc5444.h"
52
53 #include "nhdp/nhdp_interfaces.h"
54 #include "nhdp/nhdp_db.h"
55
56 /*! memory class for nhdp domain */
57 #define NHDP_CLASS_DOMAIN             "nhdp_domain"
58
59 /**
60  * NHDP domain constants
61  */
62 enum {
63   /*! maximum length of metric name */
64   NHDP_DOMAIN_METRIC_MAXLEN = 16,
65
66   /*! maximum length of mpr name */
67   NHDP_DOMAIN_MPR_MAXLEN = 16,
68 };
69
70 /**
71  * Buffer for string representation of a linkmetric value
72  */
73 struct nhdp_metric_str {
74   /*! buffer for maximum sized text link metric */
75   char buf[128];
76 };
77
78 /**
79  *  Metric handler for a NHDP domain.
80  */
81 struct nhdp_domain_metric {
82   /*! name of linkmetric */
83   const char *name;
84
85   /*! minimum metric value*/
86   uint32_t metric_minimum;
87
88   /*! maximum metric value */
89   uint32_t metric_maximum;
90
91   /*! default incoming link metric for "no default handling" metrics */
92   uint32_t incoming_link_start;
93
94   /*! default outgoing link metric for "no default handling" metrics */
95   uint32_t outgoing_link_start;
96
97   /*! default incoming 2-hop link metric for "no default handling" metrics */
98   uint32_t incoming_2hop_start;
99
100   /*! default outgoing 2-hop link metric for "no default handling" metrics */
101   uint32_t outgoing_2hop_start;
102
103   /*! true if metrics should not be handled by nhdp reader/writer */
104   bool no_default_handling;
105
106   /**
107    * callback to convert link metric into string representation
108    * @param buf buffer to put string into
109    * @param cost link metric
110    * @return pointer to buffer
111    */
112   const char *(*link_to_string)(struct nhdp_metric_str *buf, uint32_t cost);
113
114   /**
115    * callback to convert path metric into string representation
116    * @param buf buffer to put string into
117    * @param cost path metric
118    * @param hopcount hopcount of path
119    * @return pointer to buffer
120    */
121   const char *(*path_to_string)(struct nhdp_metric_str *buf,
122       uint32_t cost,  uint8_t hopcount);
123
124   /*! conversion of internal metric data into string */
125   /**
126    * callback to convert internal metric state into string
127    * @param buf buffer to put internal state into
128    * @param lnk nhdp link
129    * @return pointer to buffer
130    */
131   const char *(*internal_link_to_string)(
132       struct nhdp_metric_str *buf, struct nhdp_link *lnk);
133
134   /**
135    * callback to enable metric
136    */
137   void (*enable)(void);
138
139   /**
140    * callback to disable metric
141    */
142   void (*disable)(void);
143
144   /*! reference count */
145   int _refcount;
146
147   /*! node for tree of metrics */
148   struct avl_node _node;
149 };
150
151 /**
152  * MPR handler for a NHDP domain
153  */
154 struct nhdp_domain_mpr {
155   /*! name of handler */
156   const char *name;
157
158   /**
159    * callback to calculate MPR set
160    */
161   void (*update_mpr)(void);
162
163   /**
164    * callback to enable mpr
165    */
166   void (*enable)(void);
167
168   /**
169    * callback to disable mpr
170    */
171   void (*disable)(void);
172
173   /*! reference count */
174   int _refcount;
175
176   /*! node for tree of MPR algorithms */
177   struct avl_node _node;
178 };
179
180 /**
181  * NHDP domain
182  *
183  * A domain is a topology on the mesh, including its own
184  * metric and routing MPR set. Both is transmitted over a
185  * specified TLV extension value on MPR and LQ TLVs.
186  */
187 struct nhdp_domain {
188   /*! name of metric */
189   char metric_name[NHDP_DOMAIN_METRIC_MAXLEN];
190
191   /*! name of MPR algorithm */
192   char mpr_name[NHDP_DOMAIN_MPR_MAXLEN];
193
194   /*! pointer to metric definition */
195   struct nhdp_domain_metric *metric;
196
197   /*! pointer to mpr definition */
198   struct nhdp_domain_mpr *mpr;
199
200   /*! flooding willingness */
201   uint8_t local_willingness;
202
203   /**
204    * true if a neighbor metric of this domain has changed
205    * since the last reset of this variable
206    */
207   bool neighbor_metric_changed;
208
209   /*! metric tlv extension */
210   uint8_t ext;
211
212   /*! index in the domain array */
213   int index;
214
215   /*! temporary storage for willingness processing */
216   uint8_t _tmp_willingness;
217
218   /*! storage for the up to four additional link metrics */
219   struct rfc5444_writer_tlvtype _metric_addrtlvs[4];
220
221   /*! list of nhdp domains */
222   struct list_entity _node;
223 };
224
225 /**
226  * listener for NHDP domain updates
227  */
228 struct nhdp_domain_listener {
229   /**
230    * Callback to inform about a NHDP neighbor update
231    * @param neigh neighbor that changed, NULL if multiple neighbors changed
232    */
233   void (*update)(struct nhdp_neighbor *neigh);
234
235   /*! hook into global domain updater list */
236   struct list_entity _node;
237 };
238
239 /**
240  * Postprocessor for NHDP metric changes
241  */
242 struct nhdp_domain_metric_postprocessor {
243   /**
244    * Callback getting informed about a incoming metric change.
245    * @param domain domain the metric changed happened
246    * @param lnk nhdp link the metric change happened
247    * @param new_metric new metric value
248    * @return processed new metric value
249    */
250   uint32_t (*process_in_metric)(struct nhdp_domain *domain,
251       struct nhdp_link *lnk, uint32_t new_metric);
252
253   /*! hook into global domain metric postprocessor list */
254   struct list_entity _node;
255 };
256
257 void nhdp_domain_init(struct oonf_rfc5444_protocol *);
258 void nhdp_domain_cleanup(void);
259
260 EXPORT size_t nhdp_domain_get_count(void);
261 EXPORT struct nhdp_domain *nhdp_domain_add(uint8_t ext);
262 EXPORT struct nhdp_domain *nhdp_domain_configure(uint8_t ext,
263     const char *metric_name, const char *mpr_name, uint8_t willingness);
264
265 EXPORT int nhdp_domain_metric_add(struct nhdp_domain_metric *);
266 EXPORT void nhdp_domain_metric_remove(struct nhdp_domain_metric *);
267
268 EXPORT int nhdp_domain_mpr_add(struct nhdp_domain_mpr *);
269 EXPORT void nhdp_domain_mpr_remove(struct nhdp_domain_mpr *);
270
271 EXPORT void nhdp_domain_listener_add(struct nhdp_domain_listener *);
272 EXPORT void nhdp_domain_listener_remove(struct nhdp_domain_listener *);
273
274 EXPORT void nhdp_domain_metric_postprocessor_add(
275     struct nhdp_domain_metric_postprocessor *);
276 EXPORT void nhdp_domain_metric_postprocessor_remove(
277     struct nhdp_domain_metric_postprocessor *);
278 EXPORT struct nhdp_domain *nhdp_domain_get_by_ext(uint8_t);
279
280 EXPORT void nhdp_domain_init_link(struct nhdp_link *);
281 EXPORT void nhdp_domain_init_l2hop(struct nhdp_l2hop *);
282 EXPORT void nhdp_domain_init_neighbor(struct nhdp_neighbor *);
283
284 EXPORT void nhdp_domain_process_metric_linktlv(struct nhdp_domain *,
285     struct nhdp_link *lnk, const uint8_t *value);
286 EXPORT void nhdp_domain_process_metric_2hoptlv(struct nhdp_domain *d,
287     struct nhdp_l2hop *l2hop, const uint8_t *value);
288
289 EXPORT void nhdp_domain_recalculate_mpr(void);
290 EXPORT void nhdp_domain_neighborhood_changed(void);
291 EXPORT void nhdp_domain_neighbor_changed(struct nhdp_neighbor *neigh);
292 EXPORT bool nhdp_domain_node_is_mpr(void);
293
294 EXPORT size_t nhdp_domain_process_mprtypes_tlv(
295     uint8_t *mprtypes, size_t mprtypes_size,
296     struct rfc5444_reader_tlvblock_entry *tlv);
297 EXPORT void nhdp_domain_process_mpr_tlv(uint8_t *mprtypes, size_t mprtypes_size,
298     struct nhdp_neighbor *, struct rfc5444_reader_tlvblock_entry *tlv);
299 EXPORT void nhdp_domain_process_willingness_tlv(
300     uint8_t *mpr_types, size_t mprtypes_size,
301     struct rfc5444_reader_tlvblock_entry *tlv);
302 EXPORT void nhdp_domain_store_willingness(struct nhdp_neighbor *);
303 EXPORT size_t nhdp_domain_encode_mprtypes_tlvvalue(
304     uint8_t *mprtypes, size_t mprtypes_size);
305 EXPORT size_t nhdp_domain_encode_mpr_tlvvalue(
306     uint8_t *tlvvalue, size_t tlvsize, struct nhdp_neighbor *);
307 EXPORT size_t nhdp_domain_encode_willingness_tlvvalue(
308     uint8_t *tlvvalue, size_t tlvsize);
309
310 EXPORT bool nhdp_domain_set_incoming_metric(
311     struct nhdp_domain_metric *metric, struct nhdp_link *lnk, uint32_t metric_in);
312
313 EXPORT struct list_entity *nhdp_domain_get_list(void);
314 EXPORT struct list_entity *nhdp_domain_get_listener_list(void);
315 EXPORT const struct nhdp_domain *nhdp_domain_get_flooding(void);
316 EXPORT void nhdp_domain_set_flooding_mpr(const char *mpr_name, uint8_t willingness);
317
318 /**
319  * @param domain NHDP domain
320  * @param lnk NHDP link
321  * @return domain data of specified link
322  */
323 static INLINE struct nhdp_link_domaindata *
324 nhdp_domain_get_linkdata(const struct nhdp_domain *domain, struct nhdp_link *lnk) {
325   return &lnk->_domaindata[domain->index];
326 }
327
328 /**
329  * @param domain NHDP domain
330  * @param neigh NHDP neighbor
331  * @return domain data of specified neighbor
332  */
333 static INLINE struct nhdp_neighbor_domaindata *
334 nhdp_domain_get_neighbordata(
335     const struct nhdp_domain *domain, struct nhdp_neighbor *neigh) {
336   return &neigh->_domaindata[domain->index];
337 }
338
339 /**
340  * @param domain NHDP domain
341  * @param l2hop NHDP twohop neighbor
342  * @return domain data of specified twohop neighbor
343  */
344 static INLINE struct nhdp_l2hop_domaindata *
345 nhdp_domain_get_l2hopdata(
346     const struct nhdp_domain *domain, struct nhdp_l2hop *l2hop) {
347   return &l2hop->_domaindata[domain->index];
348 }
349
350
351 /**
352  * @param buf pointer to metric output buffer
353  * @param domain pointer to metric domain
354  * @param metric raw metric value
355  * @return pointer to string representation of metric
356  */
357 static INLINE const char *
358 nhdp_domain_get_link_metric_value(struct nhdp_metric_str *buf,
359     const struct nhdp_domain *domain, uint32_t metric) {
360   return domain->metric->link_to_string(buf, metric);
361 }
362
363 /**
364  * @param buf pointer to metric output buffer
365  * @param domain pointer to metric domain
366  * @param metric raw path metric value
367  * @param hopcount path hopcount
368  * @return pointer to string representation of metric
369  */
370 static INLINE const char *
371 nhdp_domain_get_path_metric_value(struct nhdp_metric_str *buf,
372     const struct nhdp_domain *domain, uint32_t metric, uint8_t hopcount) {
373   return domain->metric->path_to_string(buf, metric, hopcount);
374 }
375
376 /**
377  * @param buf pointer to metric output buffer
378  * @param metric pointer to metric
379  * @param lnk nhdp link
380  * @return pointer to string internal representation of metric
381  */
382 static INLINE const char *
383 nhdp_domain_get_internal_link_metric_value(struct nhdp_metric_str *buf,
384     const struct nhdp_domain_metric *metric, struct nhdp_link *lnk) {
385   return metric->internal_link_to_string(buf, lnk);
386 }
387
388 #endif /* NHDP_DOMAIN_H_ */