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