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