pud: merge nodeIdType and nodeId parameters into nodeId parameter
[olsrd.git] / lib / pud / src / configuration.c
1 #include "configuration.h"
2
3 /* Plugin includes */
4 #include "pud.h"
5 #include "networkInterfaces.h"
6 #include "netTools.h"
7 #include "posFile.h"
8 #include "configTools.h"
9
10 /* OLSR includes */
11 #include <olsr_protocol.h>
12 #include <olsr.h>
13
14 /* System includes */
15 #include <unistd.h>
16 #include <nmea/parse.h>
17 #include <OlsrdPudWireFormat/nodeIdConversion.h>
18 #include <limits.h>
19
20 /* forward declarations */
21 static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber);
22
23 /*
24  * Note:
25  * Setters must return true when an error is detected, false otherwise
26  */
27
28 /*
29  * nodeIdType
30  */
31
32 /** The nodeIdType */
33 static NodeIdType nodeIdType = PUD_NODE_ID_TYPE_DEFAULT;
34
35 /**
36  @return
37  The node ID type
38  */
39 NodeIdType getNodeIdTypeNumber(void) {
40         return nodeIdType;
41 }
42
43 static int setNodeIdType(const char *value, const char * valueName) {
44         unsigned long long nodeIdTypeNew;
45
46         if (!readULL(valueName, value, &nodeIdTypeNew)) {
47                 return true;
48         }
49
50         if (!isValidNodeIdType(nodeIdTypeNew)) {
51                 pudError(false, "Value in parameter %s (%llu) is reserved", valueName,
52                                 nodeIdTypeNew);
53                 return true;
54         }
55
56         nodeIdType = nodeIdTypeNew;
57
58         return false;
59 }
60
61 /*
62  * nodeId
63  */
64
65 /** The nodeId buffer */
66 static unsigned char nodeId[PUD_TX_NODEID_BUFFERSIZE];
67
68 /** The length of the string in the nodeId buffer */
69 static size_t nodeIdLength = 0;
70
71 /** True when the nodeId is set */
72 static bool nodeIdSet = false;
73
74 /** The nodeId as a binary representation, with status */
75 static nodeIdBinaryType nodeIdBinary;
76
77 /**
78  Get the nodeId and its length
79
80  @param length
81  a pointer to the variable in which to store the nodeId length (allowed to be
82  NULL, in which case the length is not stored)
83
84  @return
85  The node ID
86  */
87 unsigned char * getNodeId(size_t *length) {
88         if (!nodeIdSet) {
89                 setNodeId("", NULL, (set_plugin_parameter_addon) {.pc = NULL});
90         }
91
92         if (length != NULL) {
93                 *length = nodeIdLength;
94         }
95
96         return &nodeId[0];
97 }
98
99 /**
100  Get the nodeIdBinary
101
102  @return
103  The node ID in binary representation
104  */
105 nodeIdBinaryType * getNodeIdBinary(void) {
106         if (!nodeIdBinary.set) {
107                 setNodeId("", NULL, (set_plugin_parameter_addon) {.pc = NULL});
108         }
109
110         return &nodeIdBinary;
111 }
112
113 int setNodeId(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
114         size_t valueLength;
115         char * number;
116         char * identification;
117
118         assert (value != NULL);
119
120   nodeId[0] = '\0';
121   nodeIdLength = 0;
122   nodeIdSet = false;
123   nodeIdBinary.set = false;
124
125         valueLength = strlen(value);
126   number = olsr_malloc(valueLength + 1, "setNodeId");
127   strcpy(number, value);
128
129   /* split "number,identification" */
130   identification = strchr(number, ',');
131   if (identification) {
132     *identification = '\0';
133     identification++;
134   }
135
136   /* parse number into nodeIdType (if present) */
137   valueLength = strlen(number);
138   if (valueLength && setNodeIdType(number, PUD_NODE_ID_NAME)) {
139     free(number);
140     return true;
141   }
142
143   /* copy identification into nodeId (if present) */
144   if (identification) {
145     valueLength = strlen(identification);
146     if (valueLength > (PUD_TX_NODEID_BUFFERSIZE - 1)) {
147       pudError(false, "Value in parameter %s is too long, maximum length is"
148         " %u, current length is %lu", PUD_NODE_ID_NAME, (PUD_TX_NODEID_BUFFERSIZE - 1),
149           (unsigned long) valueLength);
150       free(number);
151       return true;
152     }
153
154     if (valueLength) {
155       strcpy((char *) &nodeId[0], identification);
156       nodeIdLength = valueLength;
157       nodeIdSet = true;
158     }
159   }
160
161   free(number);
162
163   /* fill in automatic values */
164   if (!nodeIdSet) {
165     if (nodeIdType == PUD_NODEIDTYPE_DNS) {
166       memset(nodeId, 0, sizeof(nodeId));
167       errno = 0;
168       if (gethostname((char *)&nodeId[0], sizeof(nodeId) - 1) < 0) {
169         pudError(true, "Could not get the host name");
170         return true;
171       }
172
173       nodeIdLength = strlen((char *)nodeId);
174       nodeIdSet = true;
175     } else if ((nodeIdType != PUD_NODEIDTYPE_MAC) && (nodeIdType != PUD_NODEIDTYPE_IPV4)
176         && (nodeIdType != PUD_NODEIDTYPE_IPV6)) {
177       pudError(false, "No node ID set while one is required for nodeId type %u", nodeIdType);
178       return true;
179     }
180   }
181
182   if (!setupNodeIdBinaryAndValidate(nodeIdType)) {
183     pudError(false, "nodeId (type %u) is incorrectly configured", nodeIdType);
184     return true;
185   }
186
187   return false;
188 }
189
190 /*
191  * nodeId Validation
192  */
193
194 /**
195  Validate whether the configured nodeId is valid w.r.t. the configured
196  nodeIdType, for types that are MAC addresses
197
198  @return
199  - true when ok
200  - false on failure
201  */
202 static bool intSetupNodeIdBinaryMAC(void) {
203         unsigned char * mac = getMainIpMacAddress();
204         if (!mac) {
205                 return false;
206         }
207
208         return setupNodeIdBinaryMAC(&nodeIdBinary, mac);
209 }
210
211 /**
212  Validate whether the configured nodeId is valid w.r.t. the configured
213  nodeIdType, for types that fit in an unsigned long long (64 bits)
214
215  @param min
216  the minimum value
217  @param max
218  the maximum value
219  @param bytes
220  the number of bytes in the buffer
221
222  @return
223  - true when ok
224  - false on failure
225  */
226 static bool intSetupNodeIdBinaryLongLong(unsigned long long min,
227                 unsigned long long max, unsigned int bytes) {
228         unsigned long long longValue = 0;
229         if (!readULL(PUD_NODE_ID_NAME, (char *) getNodeId(NULL), &longValue)) {
230                 return false;
231         }
232
233         if ((longValue < min) || (longValue > max)) {
234                 pudError(false, "%s value %llu is out of range [%llu,%llu]",
235                                 PUD_NODE_ID_NAME, longValue, min, max);
236                 return false;
237         }
238
239         return setupNodeIdBinaryLongLong(&nodeIdBinary, longValue, bytes);
240 }
241
242 /**
243  Validate whether the configured nodeId is valid w.r.t. the configured
244  nodeIdType, for types that are strings
245
246  @return
247  - true when ok
248  - false on failure
249  */
250 static bool intSetupNodeIdBinaryString(void) {
251         char report[256];
252         size_t nodeidlength;
253         char * nodeid = (char *)getNodeId(&nodeidlength);
254
255         if (nmea_parse_sentence_has_invalid_chars(nodeid, nodeidlength, PUD_NODE_ID_NAME, &report[0], sizeof(report))) {
256                 pudError(false, "%s", &report[0]);
257                 return false;
258         }
259
260         if (nodeidlength > (PUD_TX_NODEID_BUFFERSIZE - 1)) {
261                 pudError(false, "Length of parameter %s (%s) is too great", PUD_NODE_ID_NAME, &nodeid[0]);
262                 return false;
263         }
264
265         return setupNodeIdBinaryString(&nodeIdBinary, nodeid, nodeidlength);
266 }
267
268 /**
269  Validate whether the configured nodeId is valid w.r.t. the configured
270  nodeIdType, for types that are IP addresses
271
272  @return
273  - true when ok
274  - false on failure
275  */
276 static bool intSetupNodeIdBinaryIp(void) {
277         void * src;
278         size_t length;
279         if (olsr_cnf->ip_version == AF_INET) {
280                 src = &olsr_cnf->main_addr.v4;
281                 length = sizeof(struct in_addr);
282         } else {
283                 src = &olsr_cnf->main_addr.v6;
284                 length = sizeof(struct in6_addr);
285         }
286
287         return setupNodeIdBinaryIp(&nodeIdBinary, src, length);
288 }
289
290 /**
291  Validate whether the configured nodeId is valid w.r.t. the configured
292  nodeIdType and setup the binary value
293
294  @return
295  - true when ok
296  - false on failure
297  */
298 static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber) {
299         switch (nodeIdTypeNumber) {
300                 case PUD_NODEIDTYPE_MAC: /* hardware address */
301                         return intSetupNodeIdBinaryMAC();
302
303                 case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
304                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_MSISDN_MIN,
305                                 PUD_NODEIDTYPE_MSISDN_MAX, PUD_NODEIDTYPE_MSISDN_BYTES);
306
307                 case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
308                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_TETRA_MIN,
309                                 PUD_NODEIDTYPE_TETRA_MAX, PUD_NODEIDTYPE_TETRA_BYTES);
310
311                 case PUD_NODEIDTYPE_DNS: /* DNS name */
312                         return intSetupNodeIdBinaryString();
313
314                 case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
315                 case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
316                         return intSetupNodeIdBinaryIp();
317
318                 case PUD_NODEIDTYPE_MMSI: /* an AIS MMSI number */
319                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_MMSI_MIN,
320                                 PUD_NODEIDTYPE_MMSI_MAX, PUD_NODEIDTYPE_MMSI_BYTES);
321
322                 case PUD_NODEIDTYPE_URN: /* a URN number */
323                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_URN_MIN,
324                                 PUD_NODEIDTYPE_URN_MAX, PUD_NODEIDTYPE_URN_BYTES);
325
326                 case PUD_NODEIDTYPE_192:
327                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_192_MIN,
328                                 PUD_NODEIDTYPE_192_MAX, PUD_NODEIDTYPE_192_BYTES);
329
330                 case PUD_NODEIDTYPE_193:
331                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_193_MIN,
332                                 PUD_NODEIDTYPE_193_MAX, PUD_NODEIDTYPE_193_BYTES);
333
334                 case PUD_NODEIDTYPE_194:
335                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_194_MIN,
336                                 PUD_NODEIDTYPE_194_MAX, PUD_NODEIDTYPE_194_BYTES);
337
338                 default:
339                   pudError(false, "nodeId type %u is not supported", nodeIdTypeNumber);
340                   return false;
341         }
342
343         return false;
344 }
345
346 /*
347  * rxNonOlsrIf
348  */
349
350 /** The maximum number of RX non-OLSR interfaces */
351 #define PUD_RX_NON_OLSR_IF_MAX 32
352
353 /** Array with RX non-OLSR interface names */
354 static unsigned char rxNonOlsrInterfaceNames[PUD_RX_NON_OLSR_IF_MAX][IFNAMSIZ + 1];
355
356 /** The number of RX non-OLSR interface names in the array */
357 static unsigned int rxNonOlsrInterfaceCount = 0;
358
359 /**
360  Determine whether a give interface name is configured as a receive non-OLSR
361  interface.
362
363  @param ifName
364  The interface name to check
365
366  @return
367  - true when the given interface name is configured as a receive non-OLSR
368  interface
369  - false otherwise
370  */
371 bool isRxNonOlsrInterface(const char *ifName) {
372         unsigned int i;
373
374         assert (ifName != NULL);
375
376         for (i = 0; i < rxNonOlsrInterfaceCount; i++) {
377                 if (strncmp((char *) &rxNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ
378                                 + 1) == 0) {
379                         return true;
380                 }
381         }
382
383         return false;
384 }
385
386 int addRxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
387                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
388         size_t valueLength;
389
390         if (rxNonOlsrInterfaceCount >= PUD_RX_NON_OLSR_IF_MAX) {
391                 pudError(false, "Can't configure more than %u receive interfaces",
392                                 PUD_RX_NON_OLSR_IF_MAX);
393                 return true;
394         }
395
396         assert (value != NULL);
397
398         valueLength = strlen(value);
399         if (valueLength > IFNAMSIZ) {
400                 pudError(false, "Value of parameter %s (%s) is too long,"
401                         " maximum length is %u, current length is %lu",
402                                 PUD_RX_NON_OLSR_IF_NAME, value, IFNAMSIZ, (long unsigned int)valueLength);
403                 return true;
404         }
405
406         if (!isRxNonOlsrInterface(value)) {
407                 strcpy((char *) &rxNonOlsrInterfaceNames[rxNonOlsrInterfaceCount][0],
408                                 value);
409                 rxNonOlsrInterfaceCount++;
410         }
411
412         return false;
413 }
414
415 /**
416  * @return the number of configured non-olsr receive interfaces
417  */
418 unsigned int getRxNonOlsrInterfaceCount(void) {
419         return rxNonOlsrInterfaceCount;
420 }
421
422 /**
423  * @param idx the index of the configured non-olsr receive interface
424  * @return the index-th interface name
425  */
426 unsigned char * getRxNonOlsrInterfaceName(unsigned int idx) {
427         return &rxNonOlsrInterfaceNames[idx][0];
428 }
429
430 /*
431  * rxAllowedSourceIpAddress
432  */
433
434 /** The maximum number of RX allowed source IP addresses */
435 #define PUD_RX_ALLOWED_SOURCE_IP_MAX 32
436
437 /** Array with RX allowed source IP addresses */
438 static union olsr_sockaddr rxAllowedSourceIpAddresses[PUD_RX_ALLOWED_SOURCE_IP_MAX];
439
440 /** The number of RX allowed source IP addresses in the array */
441 static unsigned int rxAllowedSourceIpAddressesCount = 0;
442
443 /**
444  Determine whether a give IP address is configured as an allowed source IP
445  address.
446
447  @param sender
448  The IP address to check
449
450  @return
451  - true when the given IP address is configured as an allowed source IP
452  address
453  - false otherwise
454  */
455 bool isRxAllowedSourceIpAddress(union olsr_sockaddr * sender) {
456         unsigned int i;
457
458         if (rxAllowedSourceIpAddressesCount == 0) {
459                 return true;
460         }
461
462         if (sender == NULL) {
463                 return false;
464         }
465
466         for (i = 0; i < rxAllowedSourceIpAddressesCount; i++) {
467                 if (sender->in.sa_family != rxAllowedSourceIpAddresses[i].in.sa_family) {
468                         continue;
469                 }
470
471                 if (sender->in.sa_family == AF_INET) {
472                         if (memcmp(&rxAllowedSourceIpAddresses[i].in4.sin_addr, &sender->in4.sin_addr, sizeof(struct in_addr))
473                                         == 0) {
474                                 return true;
475                         }
476                 } else {
477                         if (memcmp(&rxAllowedSourceIpAddresses[i].in6.sin6_addr, &sender->in6.sin6_addr, sizeof(struct in6_addr))
478                                         == 0) {
479                                 return true;
480                         }
481                 }
482         }
483
484         return false;
485 }
486
487 int addRxAllowedSourceIpAddress(const char *value, void *data __attribute__ ((unused)),
488                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
489         static const char * valueName = PUD_RX_ALLOWED_SOURCE_IP_NAME;
490         union olsr_sockaddr addr;
491         bool addrSet = false;
492
493         if (rxAllowedSourceIpAddressesCount >= PUD_RX_ALLOWED_SOURCE_IP_MAX) {
494                 pudError(false, "Can't configure more than %u allowed source IP"
495                         " addresses", PUD_RX_ALLOWED_SOURCE_IP_MAX);
496                 return true;
497         }
498
499         if (!readIPAddress(valueName, value, 0, &addr, &addrSet)) {
500                 return true;
501         }
502
503         if (!isRxAllowedSourceIpAddress(&addr)) {
504                 rxAllowedSourceIpAddresses[rxAllowedSourceIpAddressesCount] = addr;
505                 rxAllowedSourceIpAddressesCount++;
506         }
507
508         return false;
509 }
510
511 /*
512  * rxMcAddr + rxMcPort
513  */
514
515 /** The rx multicast address */
516 static union olsr_sockaddr rxMcAddr;
517
518 /** True when the rx multicast address is set */
519 static bool rxMcAddrSet = false;
520
521 /**
522  @return
523  The receive multicast address (in network byte order). Sets both the address
524  and the port to their default values when the address was not yet set.
525  */
526 union olsr_sockaddr * getRxMcAddr(void) {
527         if (!rxMcAddrSet) {
528                 setRxMcAddr((olsr_cnf->ip_version == AF_INET) ? PUD_RX_MC_ADDR_4_DEFAULT : PUD_RX_MC_ADDR_6_DEFAULT,
529                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
530         }
531         return &rxMcAddr;
532 }
533
534 int setRxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
535         static const char * valueName = PUD_RX_MC_ADDR_NAME;
536
537         if (!readIPAddress(valueName, value, PUD_RX_MC_PORT_DEFAULT, &rxMcAddr, &rxMcAddrSet)) {
538                         return true;
539         }
540
541         if (!isMulticast(&rxMcAddr)) {
542                 pudError(false, "Value of parameter %s (%s) is not a multicast address",
543                                 valueName, value);
544                 return true;
545         }
546
547         return false;
548 }
549
550 /**
551  @return
552  The receive multicast port (in network byte order)
553  */
554 unsigned short getRxMcPort(void) {
555         return getOlsrSockaddrPort(getRxMcAddr(), PUD_RX_MC_PORT_DEFAULT);
556 }
557
558 int setRxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
559         static const char * valueName = PUD_RX_MC_PORT_NAME;
560         unsigned short rxMcPortNew;
561
562         if (!readUS(valueName, value, &rxMcPortNew)) {
563                 return true;
564         }
565
566         if (rxMcPortNew < 1) {
567                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, rxMcPortNew);
568                 return true;
569         }
570
571         setOlsrSockaddrPort(getRxMcAddr(), htons((in_port_t) rxMcPortNew));
572
573         return false;
574 }
575
576 /*
577  * positionFile
578  */
579
580 /** The positionFile buffer */
581 static char positionFile[PATH_MAX + 1];
582
583 /** True when the positionFile is set */
584 static bool positionFileSet = false;
585
586 /**
587  @return
588  The positionFile (NULL when not set)
589  */
590 char * getPositionFile(void) {
591         if (!positionFileSet) {
592                 return NULL;
593         }
594
595         return &positionFile[0];
596 }
597
598 int setPositionFile(const char *value, void *data __attribute__ ((unused)),
599                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
600         size_t valueLength;
601
602         assert(value != NULL);
603
604         valueLength = strlen(value);
605         if (valueLength > PATH_MAX) {
606                 pudError(false, "Value of parameter %s is too long, maximum length is"
607                                 " %u, current length is %lu", PUD_POSFILE_NAME, PATH_MAX, (unsigned long) valueLength);
608                 return true;
609         }
610
611         strcpy((char *) &positionFile[0], value);
612         positionFileSet = true;
613
614         return false;
615 }
616
617 /*
618  * positionFilePeriod
619  */
620
621 /** The positionFilePeriod value (milliseconds) */
622 unsigned long long positionFilePeriod = PUD_POSFILEPERIOD_DEFAULT;
623
624 /**
625  @return
626  The positionFilePeriod (in milliseconds)
627  */
628 unsigned long long getPositionFilePeriod(void) {
629         return positionFilePeriod;
630 }
631
632 /**
633  Set the positionFilePeriod
634
635  @param value
636  The positionFilePeriod (a number in string representation)
637  @param data
638  Unused
639  @param addon
640  Unused
641
642  @return
643  - true when an error is detected
644  - false otherwise
645  */
646 int setPositionFilePeriod(const char *value, void *data __attribute__ ((unused)),
647                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
648         static const char * valueName = PUD_POSFILEPERIOD_NAME;
649         unsigned long long positionFilePeriodNew;
650
651         assert(value != NULL);
652
653         if (!readULL(valueName, value, &positionFilePeriodNew)) {
654                 return true;
655         }
656
657         if ((positionFilePeriodNew != 0)
658                         && ((positionFilePeriodNew < PUD_POSFILEPERIOD_MIN) || (positionFilePeriodNew > PUD_POSFILEPERIOD_MAX))) {
659                 pudError(false, "Configured %s (%llu) is outside of"
660                                 " valid range %llu-%llu", valueName, positionFilePeriodNew, PUD_POSFILEPERIOD_MIN, PUD_POSFILEPERIOD_MAX);
661                 return true;
662         }
663
664         positionFilePeriod = positionFilePeriodNew;
665
666         return false;
667 }
668
669 /*
670  * txNonOlsrIf
671  */
672
673 /** The maximum number of tx non-olsr interfaces */
674 #define PUD_TX_NON_OLSR_IF_MAX 32
675
676 /** Array with tx non-olsr interface names */
677 static unsigned char txNonOlsrInterfaceNames[PUD_TX_NON_OLSR_IF_MAX][IFNAMSIZ + 1];
678
679 /** The number of tx interface names in the array */
680 static unsigned int txNonOlsrInterfaceCount = 0;
681
682 /**
683  Determine whether a give interface name is configured as a transmit non-OLSR
684  interface.
685
686  @param ifName
687  The interface to check
688
689  @return
690  - true when the given interface name is configured as a transmit non-OLSR
691  interface
692  - false otherwise
693  */
694 bool isTxNonOlsrInterface(const char *ifName) {
695         unsigned int i;
696
697         assert (ifName != NULL);
698
699         for (i = 0; i < txNonOlsrInterfaceCount; i++) {
700                 if (strncmp((char *) &txNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ + 1) == 0) {
701                         return true;
702                 }
703         }
704
705         return false;
706 }
707
708 int addTxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
709                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
710         size_t valueLength;
711
712         assert (value != NULL);
713
714         if (txNonOlsrInterfaceCount >= PUD_TX_NON_OLSR_IF_MAX) {
715                 pudError(false, "Can not configure more than %u transmit interfaces", PUD_TX_NON_OLSR_IF_MAX);
716                 return true;
717         }
718
719         valueLength = strlen(value);
720         if (valueLength > IFNAMSIZ) {
721                 pudError(false, "Value of parameter %s (%s) is too long, maximum length is %u, current length is %lu",
722                                 PUD_TX_NON_OLSR_IF_NAME, value, IFNAMSIZ, (long unsigned int)valueLength);
723                 return true;
724         }
725
726         if (!isTxNonOlsrInterface(value)) {
727                 strcpy((char *) &txNonOlsrInterfaceNames[txNonOlsrInterfaceCount][0], value);
728                 txNonOlsrInterfaceCount++;
729         }
730
731         return false;
732 }
733
734 /**
735  * @return the number of configured non-olsr transmit interfaces
736  */
737 unsigned int getTxNonOlsrInterfaceCount(void) {
738         return txNonOlsrInterfaceCount;
739 }
740
741 /**
742  * @param idx the index of the configured non-olsr transmit interface
743  * @return the index-th interface name
744  */
745 unsigned char * getTxNonOlsrInterfaceName(unsigned int idx) {
746         return &txNonOlsrInterfaceNames[idx][0];
747 }
748
749 /*
750  * txMcAddr + txMcPort
751  */
752
753 /** The tx multicast address */
754 static union olsr_sockaddr txMcAddr;
755
756 /** True when the tx multicast address is set */
757 static bool txMcAddrSet = false;
758
759 /**
760  @return
761  The transmit multicast address (in network byte order). Sets both the address
762  and the port to their default values when the address was not yet set.
763  */
764 union olsr_sockaddr * getTxMcAddr(void) {
765         if (!txMcAddrSet) {
766                 setTxMcAddr((olsr_cnf->ip_version == AF_INET) ? PUD_TX_MC_ADDR_4_DEFAULT : PUD_TX_MC_ADDR_6_DEFAULT,
767                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
768         }
769         return &txMcAddr;
770 }
771
772 int setTxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
773         static const char * valueName = PUD_TX_MC_ADDR_NAME;
774
775         if (!readIPAddress(valueName, value, PUD_TX_MC_PORT_DEFAULT, &txMcAddr, &txMcAddrSet)) {
776                         return true;
777         }
778
779         if (!isMulticast(&txMcAddr)) {
780                 pudError(false, "Value of parameter %s (%s) is not a multicast address",
781                                 valueName, value);
782                 return true;
783         }
784
785         return false;
786 }
787
788 /**
789  @return
790  The transmit multicast port (in network byte order)
791  */
792 unsigned short getTxMcPort(void) {
793         return getOlsrSockaddrPort(getTxMcAddr(), PUD_TX_MC_PORT_DEFAULT);
794 }
795
796 int setTxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
797         static const char * valueName = PUD_TX_MC_PORT_NAME;
798         unsigned short txMcPortNew;
799
800         if (!readUS(valueName, value, &txMcPortNew)) {
801                 return true;
802         }
803
804         if (txMcPortNew < 1) {
805                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, txMcPortNew);
806                 return true;
807         }
808
809         setOlsrSockaddrPort(getTxMcAddr(), htons((in_port_t) txMcPortNew));
810
811         return false;
812 }
813
814 /*
815  * txTtl
816  */
817
818 /** The tx TTL */
819 static unsigned char txTtl = PUD_TX_TTL_DEFAULT;
820
821 /**
822  @return
823  The transmit multicast IP packet time-to-live
824  */
825 unsigned char getTxTtl(void) {
826         return txTtl;
827 }
828
829 int setTxTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
830         static const char * valueName = PUD_TX_TTL_NAME;
831
832         if (!readUC(valueName, value, &txTtl)) {
833                 return true;
834         }
835
836         if ((txTtl < 1) /* || (txTtl > MAX_TTL) */) {
837                 pudError(false, "Value of parameter %s (%u) is outside of"
838                         " valid range 1-%u", valueName, txTtl, MAX_TTL);
839                 return true;
840         }
841
842         return false;
843 }
844
845 /*
846  * txNmeaMessagePrefix
847  */
848
849 /** The exact length of the tx NMEA message prefix */
850 #define PUD_TXNMEAMESSAGEPREFIXLENGTH 4
851
852 /** The tx NMEA message prefix buffer */
853 static unsigned char txNmeaMessagePrefix[PUD_TXNMEAMESSAGEPREFIXLENGTH + 1];
854
855 /** True when the tx NMEA message prefix is set */
856 static bool txNmeaMessagePrefixSet = false;
857
858 /**
859  @return
860  The transmit multicast NMEA message prefix
861  */
862 unsigned char * getTxNmeaMessagePrefix(void) {
863         if (!txNmeaMessagePrefixSet) {
864                 setTxNmeaMessagePrefix(PUD_TX_NMEAMESSAGEPREFIX_DEFAULT, NULL,
865                                 (set_plugin_parameter_addon) {.pc = NULL});
866         }
867         return &txNmeaMessagePrefix[0];
868 }
869
870 int setTxNmeaMessagePrefix(const char *value, void *data __attribute__ ((unused)),
871                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
872         static const char * valueName = PUD_TX_NMEAMESSAGEPREFIX_NAME;
873         size_t valueLength;
874         char report[256];
875
876         assert (value != NULL);
877
878         valueLength = strlen(value);
879         if (valueLength != PUD_TXNMEAMESSAGEPREFIXLENGTH) {
880                 pudError(false, "Length of parameter %s (%s) must be exactly %u characters",
881                                 valueName, value, PUD_TXNMEAMESSAGEPREFIXLENGTH);
882                 return true;
883         }
884
885         if (nmea_parse_sentence_has_invalid_chars(value, valueLength, valueName, &report[0], sizeof(report))) {
886                 pudError(false, "%s", &report[0]);
887                 return true;
888         }
889
890         if ((strchr(value, ' ') != NULL) || (strchr(value, '\t') != NULL)) {
891                 pudError(false, "Value of parameter %s (%s) can not contain whitespace",
892                                 valueName, value);
893                 return true;
894         }
895
896         strcpy((char *) &txNmeaMessagePrefix[0], value);
897         txNmeaMessagePrefixSet = true;
898         return false;
899 }
900
901 /*
902  * uplinkAddr + uplinkPort
903  */
904
905 /** The uplink address */
906 static union olsr_sockaddr uplinkAddr;
907
908 /** True when the uplink address is set */
909 static bool uplinkAddrSet = false;
910
911 /**
912  @return
913  - true when the uplink address is set
914  - false otherwise
915  */
916 bool isUplinkAddrSet(void) {
917         return uplinkAddrSet;
918 }
919
920 /**
921  @return
922  The uplink address (in network byte order). Sets both the address
923  and the port to their default values when the address was not yet set.
924  */
925 union olsr_sockaddr * getUplinkAddr(void) {
926         if (!uplinkAddrSet) {
927                 setUplinkAddr((olsr_cnf->ip_version == AF_INET) ? PUD_UPLINK_ADDR_4_DEFAULT : PUD_UPLINK_ADDR_6_DEFAULT,
928                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
929         }
930         return &uplinkAddr;
931 }
932
933 int setUplinkAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
934         return !readIPAddress(PUD_UPLINK_ADDR_NAME, value, PUD_UPLINK_PORT_DEFAULT, &uplinkAddr, &uplinkAddrSet);
935 }
936
937 /**
938  @return
939  The uplink port (in network byte order)
940  */
941 unsigned short getUplinkPort(void) {
942         return getOlsrSockaddrPort(getUplinkAddr(), PUD_UPLINK_PORT_DEFAULT);
943 }
944
945 int setUplinkPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
946         static const char * valueName = PUD_UPLINK_PORT_NAME;
947         unsigned short uplinkPortNew;
948
949         if (!readUS(valueName, value, &uplinkPortNew)) {
950                 return true;
951         }
952
953         if (uplinkPortNew < 1) {
954                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, uplinkPortNew);
955                 return true;
956         }
957
958         setOlsrSockaddrPort(getUplinkAddr(), htons((in_port_t) uplinkPortNew));
959
960         return false;
961 }
962
963 /*
964  * downlinkPort
965  */
966
967 /** the downlink port */
968 unsigned short downlinkPort = 0;
969
970 /** true when the downlinkPort is set */
971 bool downlinkPortSet = false;
972
973 /**
974  @return
975  The downlink port (in network byte order)
976  */
977 unsigned short getDownlinkPort(void) {
978         if (!downlinkPortSet) {
979                 downlinkPort = htons(PUD_DOWNLINK_PORT_DEFAULT);
980                 downlinkPortSet = true;
981         }
982
983         return downlinkPort;
984 }
985
986 int setDownlinkPort(const char *value, void *data __attribute__ ((unused)),
987                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
988         static const char * valueName = PUD_DOWNLINK_PORT_NAME;
989         unsigned short downlinkPortNew;
990
991         if (!readUS(valueName, value, &downlinkPortNew)) {
992                 return true;
993         }
994
995         if (downlinkPortNew < 1) {
996                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, downlinkPortNew);
997                 return true;
998         }
999
1000         downlinkPort = htons(downlinkPortNew);
1001         downlinkPortSet = true;
1002
1003         return false;
1004 }
1005
1006 /*
1007  * olsrTtl
1008  */
1009
1010 /** The OLSR TTL */
1011 static unsigned char olsrTtl = PUD_OLSR_TTL_DEFAULT;
1012
1013 /**
1014  @return
1015  The OLSR multicast IP packet time-to-live
1016  */
1017 unsigned char getOlsrTtl(void) {
1018         return olsrTtl;
1019 }
1020
1021 int setOlsrTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
1022         static const char * valueName = PUD_OLSR_TTL_NAME;
1023
1024         if (!readUC(valueName, value, &olsrTtl)) {
1025                 return true;
1026         }
1027
1028         if ((olsrTtl < 1) /* || (olsrTtl > MAX_TTL) */) {
1029                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-%u",
1030                                 valueName, olsrTtl, MAX_TTL);
1031                 return true;
1032         }
1033
1034         return false;
1035 }
1036
1037 /*
1038  * updateIntervalStationary
1039  */
1040
1041 /** The stationary interval update plugin parameter (in seconds) */
1042 static unsigned long long updateIntervalStationary = PUD_UPDATE_INTERVAL_STATIONARY_DEFAULT;
1043
1044 /**
1045  @return
1046  The stationary interval update plugin parameter (in seconds)
1047  */
1048 unsigned long long getUpdateIntervalStationary(void) {
1049         return updateIntervalStationary;
1050 }
1051
1052 int setUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
1053                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1054         static const char * valueName = PUD_UPDATE_INTERVAL_STATIONARY_NAME;
1055
1056         if (!readULL(valueName, value, &updateIntervalStationary)) {
1057                 return true;
1058         }
1059
1060         if (updateIntervalStationary < 1) {
1061                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1062                 return true;
1063         }
1064
1065         return false;
1066 }
1067
1068 /*
1069  * updateIntervalMoving
1070  */
1071
1072 /** The moving interval update plugin parameter (in seconds) */
1073 static unsigned long long updateIntervalMoving = PUD_UPDATE_INTERVAL_MOVING_DEFAULT;
1074
1075 /**
1076  @return
1077  The moving interval update plugin parameter (in seconds)
1078  */
1079 unsigned long long getUpdateIntervalMoving(void) {
1080         return updateIntervalMoving;
1081 }
1082
1083 int setUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
1084                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1085         static const char * valueName = PUD_UPDATE_INTERVAL_MOVING_NAME;
1086
1087         if (!readULL(valueName, value, &updateIntervalMoving)) {
1088                 return true;
1089         }
1090
1091         if (updateIntervalMoving < 1) {
1092                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1093                 return true;
1094         }
1095
1096         return false;
1097 }
1098
1099 /*
1100  * uplinkUpdateIntervalStationary
1101  */
1102
1103 /** The uplink stationary interval update plugin parameter (in seconds) */
1104 static unsigned long long uplinkUpdateIntervalStationary = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_DEFAULT;
1105
1106 /**
1107  @return
1108  The uplink stationary interval update plugin parameter (in seconds)
1109  */
1110 unsigned long long getUplinkUpdateIntervalStationary(void) {
1111         return uplinkUpdateIntervalStationary;
1112 }
1113
1114 int setUplinkUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
1115                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1116         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_NAME;
1117
1118         if (!readULL(valueName, value, &uplinkUpdateIntervalStationary)) {
1119                 return true;
1120         }
1121
1122         if (uplinkUpdateIntervalStationary < 1) {
1123                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1124                 return true;
1125         }
1126
1127         return false;
1128 }
1129
1130 /*
1131  * uplinkUpdateIntervalMoving
1132  */
1133
1134 /** The uplink moving interval update plugin parameter (in seconds) */
1135 static unsigned long long uplinkUpdateIntervalMoving = PUD_UPLINK_UPDATE_INTERVAL_MOVING_DEFAULT;
1136
1137 /**
1138  @return
1139  The uplink moving interval update plugin parameter (in seconds)
1140  */
1141 unsigned long long getUplinkUpdateIntervalMoving(void) {
1142         return uplinkUpdateIntervalMoving;
1143 }
1144
1145 int setUplinkUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
1146                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1147         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_MOVING_NAME;
1148
1149         if (!readULL(valueName, value, &uplinkUpdateIntervalMoving)) {
1150                 return true;
1151         }
1152
1153         if (uplinkUpdateIntervalMoving < 1) {
1154                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1155                 return true;
1156         }
1157
1158         return false;
1159 }
1160
1161 /*
1162  * gatewayDeterminationInterval
1163  */
1164
1165 /** The gateway determination interval plugin parameter (in seconds) */
1166 static unsigned long long gatewayDeterminationInterval = PUD_GATEWAY_DETERMINATION_INTERVAL_DEFAULT;
1167
1168 /**
1169  @return
1170  The gateway determination interval plugin parameter (in seconds)
1171  */
1172 unsigned long long getGatewayDeterminationInterval(void) {
1173         return gatewayDeterminationInterval;
1174 }
1175
1176 int setGatewayDeterminationInterval(const char *value, void *data __attribute__ ((unused)),
1177                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1178         static const char * valueName = PUD_GATEWAY_DETERMINATION_INTERVAL_NAME;
1179
1180         if (!readULL(valueName, value, &gatewayDeterminationInterval)) {
1181                 return true;
1182         }
1183
1184         if (gatewayDeterminationInterval < 1) {
1185                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1186                 return true;
1187         }
1188
1189         return false;
1190 }
1191
1192 /*
1193  * movingSpeedThreshold
1194  */
1195
1196 /** The moving speed threshold plugin parameter (in kph) */
1197 static unsigned long long movingSpeedThreshold = PUD_MOVING_SPEED_THRESHOLD_DEFAULT;
1198
1199 /**
1200  @return
1201  The moving speed threshold plugin parameter (in kph)
1202  */
1203 unsigned long long getMovingSpeedThreshold(void) {
1204         return movingSpeedThreshold;
1205 }
1206
1207 int setMovingSpeedThreshold(const char *value, void *data __attribute__ ((unused)),
1208                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1209         return !readULL(PUD_MOVING_SPEED_THRESHOLD_NAME, value, &movingSpeedThreshold);
1210 }
1211
1212 /*
1213  * movingDistanceThreshold
1214  */
1215
1216 /** The moving distance threshold plugin parameter (in meters) */
1217 static unsigned long long movingDistanceThreshold = PUD_MOVING_DISTANCE_THRESHOLD_DEFAULT;
1218
1219 /**
1220  @return
1221  The moving distance threshold plugin parameter (in meters)
1222  */
1223 unsigned long long getMovingDistanceThreshold(void) {
1224         return movingDistanceThreshold;
1225 }
1226
1227 int setMovingDistanceThreshold(const char *value, void *data __attribute__ ((unused)),
1228                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1229         return !readULL(PUD_MOVING_DISTANCE_THRESHOLD_NAME, value, &movingDistanceThreshold);
1230 }
1231
1232 /*
1233  * dopMultiplier
1234  */
1235
1236 /** The DOP multiplier plugin parameter */
1237 static double dopMultiplier = PUD_DOP_MULTIPLIER_DEFAULT;
1238
1239 /**
1240  @return
1241  The DOP multiplier plugin parameter
1242  */
1243 double getDopMultiplier(void) {
1244         return dopMultiplier;
1245 }
1246
1247 int setDopMultiplier(const char *value, void *data __attribute__ ((unused)),
1248                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1249         return !readDouble(PUD_DOP_MULTIPLIER_NAME, value, &dopMultiplier);
1250 }
1251
1252 /*
1253  * defaultHdop
1254  */
1255
1256 /** The default HDOP plugin parameter (in meters) */
1257 static unsigned long long defaultHdop = PUD_DEFAULT_HDOP_DEFAULT;
1258
1259 /**
1260  @return
1261  The default HDOP plugin parameter (in meters)
1262  */
1263 unsigned long long getDefaultHdop(void) {
1264         return defaultHdop;
1265 }
1266
1267 int setDefaultHdop(const char *value, void *data __attribute__ ((unused)),
1268                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1269         return !readULL(PUD_DEFAULT_HDOP_NAME, value, &defaultHdop);
1270 }
1271
1272 /*
1273  * defaultVdop
1274  */
1275
1276 /** The default VDOP plugin parameter (in meters) */
1277 static unsigned long long defaultVdop = PUD_DEFAULT_VDOP_DEFAULT;
1278
1279 /**
1280  @return
1281  The default VDOP plugin parameter (in meters)
1282  */
1283 unsigned long long getDefaultVdop(void) {
1284         return defaultVdop;
1285 }
1286
1287 int setDefaultVdop(const char *value, void *data __attribute__ ((unused)),
1288                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1289         return !readULL(PUD_DEFAULT_VDOP_NAME, value, &defaultVdop);
1290 }
1291
1292 /*
1293  * averageDepth
1294  */
1295
1296 /** The depth of the average list */
1297 static unsigned long long averageDepth = PUD_AVERAGE_DEPTH_DEFAULT;
1298
1299 /**
1300  @return
1301  The depth of the average list
1302  */
1303 unsigned long long getAverageDepth(void) {
1304         return averageDepth;
1305 }
1306
1307 int setAverageDepth(const char *value, void *data __attribute__ ((unused)),
1308                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1309         static const char * valueName = PUD_AVERAGE_DEPTH_NAME;
1310
1311         if (!readULL(valueName, value, &averageDepth)) {
1312                 return true;
1313         }
1314
1315         if (averageDepth < 1) {
1316                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1317                 return true;
1318         }
1319
1320         return false;
1321 }
1322
1323 /*
1324  * hysteresisCountToStationary
1325  */
1326
1327 /** The hysteresis count for changing state from moving to stationary */
1328 static unsigned long long hysteresisCountToStationary = PUD_HYSTERESIS_COUNT_2STAT_DEFAULT;
1329
1330 /**
1331  @return
1332  The hysteresis count for changing state from moving to stationary
1333  */
1334 unsigned long long getHysteresisCountToStationary(void) {
1335         return hysteresisCountToStationary;
1336 }
1337
1338 int setHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1339                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1340         return !readULL(PUD_HYSTERESIS_COUNT_2STAT_NAME, value, &hysteresisCountToStationary);
1341 }
1342
1343 /*
1344  * hysteresisCountToMoving
1345  */
1346
1347 /** The hysteresis count for changing state from stationary to moving */
1348 static unsigned long long hysteresisCountToMoving = PUD_HYSTERESIS_COUNT_2MOV_DEFAULT;
1349
1350 /**
1351  @return
1352  The hysteresis count for changing state from stationary to moving
1353  */
1354 unsigned long long getHysteresisCountToMoving(void) {
1355         return hysteresisCountToMoving;
1356 }
1357
1358 int setHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1359                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1360         return !readULL(PUD_HYSTERESIS_COUNT_2MOV_NAME, value, &hysteresisCountToMoving);
1361 }
1362
1363 /*
1364  * gatewayHysteresisCountToStationary
1365  */
1366
1367 /** The hysteresis count for changing state from moving to stationary */
1368 static unsigned long long gatewayHysteresisCountToStationary = PUD_GAT_HYSTERESIS_COUNT_2STAT_DEFAULT;
1369
1370 /**
1371  @return
1372  The hysteresis count for changing state from moving to stationary
1373  */
1374 unsigned long long getGatewayHysteresisCountToStationary(void) {
1375         return gatewayHysteresisCountToStationary;
1376 }
1377
1378 int setGatewayHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1379                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1380         return !readULL(PUD_GAT_HYSTERESIS_COUNT_2STAT_NAME, value, &gatewayHysteresisCountToStationary);
1381 }
1382
1383 /*
1384  * gatewayHysteresisCountToMoving
1385  */
1386
1387 /** The hysteresis count for changing state from stationary to moving */
1388 static unsigned long long gatewayHysteresisCountToMoving = PUD_GAT_HYSTERESIS_COUNT_2MOV_DEFAULT;
1389
1390 /**
1391  @return
1392  The hysteresis count for changing state from stationary to moving
1393  */
1394 unsigned long long getGatewayHysteresisCountToMoving(void) {
1395         return gatewayHysteresisCountToMoving;
1396 }
1397
1398 int setGatewayHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1399                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1400         return !readULL(PUD_GAT_HYSTERESIS_COUNT_2MOV_NAME, value, &gatewayHysteresisCountToMoving);
1401 }
1402
1403 /*
1404  * useDeDup
1405  */
1406
1407 /** when true then duplicate message detection is performed */
1408 static bool useDeDup = PUD_USE_DEDUP_DEFAULT;
1409
1410 /**
1411  @return
1412  The duplicate message detection setting
1413  */
1414 bool getUseDeDup(void) {
1415         return useDeDup;
1416 }
1417
1418 int setUseDeDup(const char *value, void *data __attribute__ ((unused)),
1419                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1420         return !readBool(PUD_USE_DEDUP_NAME, value, &useDeDup);
1421 }
1422
1423 /*
1424  * deDupDepth
1425  */
1426
1427 /** The deduplication depth */
1428 static unsigned long long deDupDepth = PUD_DEDUP_DEPTH_DEFAULT;
1429
1430 /**
1431  @return
1432  The deduplication depth
1433  */
1434 unsigned long long getDeDupDepth(void) {
1435         return deDupDepth;
1436 }
1437
1438 int setDeDupDepth(const char *value, void *data __attribute__ ((unused)),
1439                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1440         return !readULL(PUD_DEDUP_DEPTH_NAME, value, &deDupDepth);
1441 }
1442
1443 /*
1444  * useLoopback
1445  */
1446
1447 /** when true then loopback is performed */
1448 static bool useLoopback = PUD_USE_LOOPBACK_DEFAULT;
1449
1450 /**
1451  @return
1452  The loopback usage setting
1453  */
1454 bool getUseLoopback(void) {
1455         return useLoopback;
1456 }
1457
1458 int setUseLoopback(const char *value, void *data __attribute__ ((unused)),
1459                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1460         return !readBool(PUD_USE_LOOPBACK_NAME, value, &useLoopback);
1461 }
1462
1463 /*
1464  * Check Functions
1465  */
1466
1467 /**
1468  Check the configuration for consistency and validity.
1469
1470  @return
1471  - true when the configuration is consistent and valid
1472  - false otherwise
1473  */
1474 unsigned int checkConfig(void) {
1475         int retval = true;
1476
1477         if (rxNonOlsrInterfaceCount == 0) {
1478                 pudError(false, "No receive non-OLSR interfaces configured");
1479                 retval = false;
1480         }
1481
1482         if (txNonOlsrInterfaceCount == 0) {
1483                 pudError(false, "No transmit non-OLSR interfaces configured");
1484                 retval = false;
1485         }
1486
1487         if (updateIntervalMoving > updateIntervalStationary) {
1488                 pudError(false,"The update interval for moving situations must not be"
1489                 " larger than that for stationary situations");
1490                 retval = false;
1491         }
1492
1493         if (uplinkUpdateIntervalMoving > uplinkUpdateIntervalStationary) {
1494                 pudError(false,"The uplink update interval for moving situations must not be"
1495                 " larger than that for stationary situations");
1496                 retval = false;
1497         }
1498
1499         if (isUplinkAddrSet() && (getUplinkPort() == getDownlinkPort())) {
1500                 pudError(false, "The uplink port and the downlink port must not be the same");
1501                 retval = false;
1502         }
1503
1504         return retval;
1505 }
1506
1507 /**
1508  Check the configuration for consistency and validity after everything has been
1509  setup.
1510
1511  @return
1512  - true when the configuration is consistent and valid
1513  - false otherwise
1514  */
1515 unsigned int checkRunSetup(void) {
1516         return true;
1517 }