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