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