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