pud: adjust to new nmealib
[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 index 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         if (!startPositionFile()) {
552                 stopPositionFile();
553                 return true;
554         }
555
556         valueLength = strlen(value);
557         if (valueLength > PATH_MAX) {
558                 pudError(false, "Value of parameter %s is too long, maximum length is"
559                                 " %u, current length is %lu", PUD_POSFILE_NAME, PATH_MAX, (unsigned long) valueLength);
560                 return true;
561         }
562
563         strcpy((char *) &positionFile[0], value);
564         positionFileSet = true;
565
566         return false;
567 }
568
569 /*
570  * txNonOlsrIf
571  */
572
573 /** The maximum number of tx non-olsr interfaces */
574 #define PUD_TX_NON_OLSR_IF_MAX 32
575
576 /** Array with tx non-olsr interface names */
577 static unsigned char txNonOlsrInterfaceNames[PUD_TX_NON_OLSR_IF_MAX][IFNAMSIZ + 1];
578
579 /** The number of tx interface names in the array */
580 static unsigned int txNonOlsrInterfaceCount = 0;
581
582 /**
583  Determine whether a give interface name is configured as a transmit non-OLSR
584  interface.
585
586  @param ifName
587  The interface to check
588
589  @return
590  - true when the given interface name is configured as a transmit non-OLSR
591  interface
592  - false otherwise
593  */
594 bool isTxNonOlsrInterface(const char *ifName) {
595         unsigned int i;
596
597         assert (ifName != NULL);
598
599         for (i = 0; i < txNonOlsrInterfaceCount; i++) {
600                 if (strncmp((char *) &txNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ + 1) == 0) {
601                         return true;
602                 }
603         }
604
605         return false;
606 }
607
608 int addTxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
609                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
610         size_t valueLength;
611
612         assert (value != NULL);
613
614         if (txNonOlsrInterfaceCount >= PUD_TX_NON_OLSR_IF_MAX) {
615                 pudError(false, "Can not configure more than %u transmit interfaces", PUD_TX_NON_OLSR_IF_MAX);
616                 return true;
617         }
618
619         valueLength = strlen(value);
620         if (valueLength > IFNAMSIZ) {
621                 pudError(false, "Value of parameter %s (%s) is too long, maximum length is %u, current length is %lu",
622                                 PUD_TX_NON_OLSR_IF_NAME, value, IFNAMSIZ, (long unsigned int)valueLength);
623                 return true;
624         }
625
626         if (!isTxNonOlsrInterface(value)) {
627                 strcpy((char *) &txNonOlsrInterfaceNames[txNonOlsrInterfaceCount][0], value);
628                 txNonOlsrInterfaceCount++;
629         }
630
631         return false;
632 }
633
634 /**
635  * @return the number of configured non-olsr transmit interfaces
636  */
637 unsigned int getTxNonOlsrInterfaceCount(void) {
638         return txNonOlsrInterfaceCount;
639 }
640
641 /**
642  * @param index the index of the configured non-olsr transmit interface
643  * @return the index-th interface name
644  */
645 unsigned char * getTxNonOlsrInterfaceName(unsigned int idx) {
646         return &txNonOlsrInterfaceNames[idx][0];
647 }
648
649 /*
650  * txMcAddr + txMcPort
651  */
652
653 /** The tx multicast address */
654 static union olsr_sockaddr txMcAddr;
655
656 /** True when the tx multicast address is set */
657 static bool txMcAddrSet = false;
658
659 /**
660  @return
661  The transmit multicast address (in network byte order). Sets both the address
662  and the port to their default values when the address was not yet set.
663  */
664 union olsr_sockaddr * getTxMcAddr(void) {
665         if (!txMcAddrSet) {
666                 setTxMcAddr((olsr_cnf->ip_version == AF_INET) ? PUD_TX_MC_ADDR_4_DEFAULT : PUD_TX_MC_ADDR_6_DEFAULT,
667                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
668         }
669         return &txMcAddr;
670 }
671
672 int setTxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
673         static const char * valueName = PUD_TX_MC_ADDR_NAME;
674
675         if (!readIPAddress(valueName, value, PUD_TX_MC_PORT_DEFAULT, &txMcAddr, &txMcAddrSet)) {
676                         return true;
677         }
678
679         if (!isMulticast(&txMcAddr)) {
680                 pudError(false, "Value of parameter %s (%s) is not a multicast address",
681                                 valueName, value);
682                 return true;
683         }
684
685         return false;
686 }
687
688 /**
689  @return
690  The transmit multicast port (in network byte order)
691  */
692 unsigned short getTxMcPort(void) {
693         return getOlsrSockaddrPort(getTxMcAddr(), PUD_TX_MC_PORT_DEFAULT);
694 }
695
696 int setTxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
697         static const char * valueName = PUD_TX_MC_PORT_NAME;
698         unsigned short txMcPortNew;
699
700         if (!readUS(valueName, value, &txMcPortNew)) {
701                 return true;
702         }
703
704         if (txMcPortNew < 1) {
705                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, txMcPortNew);
706                 return true;
707         }
708
709         setOlsrSockaddrPort(getTxMcAddr(), htons((in_port_t) txMcPortNew));
710
711         return false;
712 }
713
714 /*
715  * txTtl
716  */
717
718 /** The tx TTL */
719 static unsigned char txTtl = PUD_TX_TTL_DEFAULT;
720
721 /**
722  @return
723  The transmit multicast IP packet time-to-live
724  */
725 unsigned char getTxTtl(void) {
726         return txTtl;
727 }
728
729 int setTxTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
730         static const char * valueName = PUD_TX_TTL_NAME;
731
732         if (!readUC(valueName, value, &txTtl)) {
733                 return true;
734         }
735
736         if ((txTtl < 1) /* || (txTtl > MAX_TTL) */) {
737                 pudError(false, "Value of parameter %s (%u) is outside of"
738                         " valid range 1-%u", valueName, txTtl, MAX_TTL);
739                 return true;
740         }
741
742         return false;
743 }
744
745 /*
746  * txNmeaMessagePrefix
747  */
748
749 /** The exact length of the tx NMEA message prefix */
750 #define PUD_TXNMEAMESSAGEPREFIXLENGTH 4
751
752 /** The tx NMEA message prefix buffer */
753 static unsigned char txNmeaMessagePrefix[PUD_TXNMEAMESSAGEPREFIXLENGTH + 1];
754
755 /** True when the tx NMEA message prefix is set */
756 static bool txNmeaMessagePrefixSet = false;
757
758 /**
759  @return
760  The transmit multicast NMEA message prefix
761  */
762 unsigned char * getTxNmeaMessagePrefix(void) {
763         if (!txNmeaMessagePrefixSet) {
764                 setTxNmeaMessagePrefix(PUD_TX_NMEAMESSAGEPREFIX_DEFAULT, NULL,
765                                 (set_plugin_parameter_addon) {.pc = NULL});
766         }
767         return &txNmeaMessagePrefix[0];
768 }
769
770 int setTxNmeaMessagePrefix(const char *value, void *data __attribute__ ((unused)),
771                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
772         static const char * valueName = PUD_TX_NMEAMESSAGEPREFIX_NAME;
773         size_t valueLength;
774         char report[256];
775
776         assert (value != NULL);
777
778         valueLength = strlen(value);
779         if (valueLength != PUD_TXNMEAMESSAGEPREFIXLENGTH) {
780                 pudError(false, "Length of parameter %s (%s) must be exactly %u characters",
781                                 valueName, value, PUD_TXNMEAMESSAGEPREFIXLENGTH);
782                 return true;
783         }
784
785         if (nmea_parse_sentence_has_invalid_chars(value, valueLength, valueName, &report[0], sizeof(report))) {
786                 pudError(false, "%s", &report[0]);
787                 return true;
788         }
789
790         if ((strchr(value, ' ') != NULL) || (strchr(value, '\t') != NULL)) {
791                 pudError(false, "Value of parameter %s (%s) can not contain whitespace",
792                                 valueName, value);
793                 return true;
794         }
795
796         strcpy((char *) &txNmeaMessagePrefix[0], value);
797         txNmeaMessagePrefixSet = true;
798         return false;
799 }
800
801 /*
802  * uplinkAddr + uplinkPort
803  */
804
805 /** The uplink address */
806 static union olsr_sockaddr uplinkAddr;
807
808 /** True when the uplink address is set */
809 static bool uplinkAddrSet = false;
810
811 /**
812  @return
813  - true when the uplink address is set
814  - false otherwise
815  */
816 bool isUplinkAddrSet(void) {
817         return uplinkAddrSet;
818 }
819
820 /**
821  @return
822  The uplink address (in network byte order). Sets both the address
823  and the port to their default values when the address was not yet set.
824  */
825 union olsr_sockaddr * getUplinkAddr(void) {
826         if (!uplinkAddrSet) {
827                 setUplinkAddr((olsr_cnf->ip_version == AF_INET) ? PUD_UPLINK_ADDR_4_DEFAULT : PUD_UPLINK_ADDR_6_DEFAULT,
828                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
829         }
830         return &uplinkAddr;
831 }
832
833 int setUplinkAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
834         return !readIPAddress(PUD_UPLINK_ADDR_NAME, value, PUD_UPLINK_PORT_DEFAULT, &uplinkAddr, &uplinkAddrSet);
835 }
836
837 /**
838  @return
839  The uplink port (in network byte order)
840  */
841 unsigned short getUplinkPort(void) {
842         return getOlsrSockaddrPort(getUplinkAddr(), PUD_UPLINK_PORT_DEFAULT);
843 }
844
845 int setUplinkPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
846         static const char * valueName = PUD_UPLINK_PORT_NAME;
847         unsigned short uplinkPortNew;
848
849         if (!readUS(valueName, value, &uplinkPortNew)) {
850                 return true;
851         }
852
853         if (uplinkPortNew < 1) {
854                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, uplinkPortNew);
855                 return true;
856         }
857
858         setOlsrSockaddrPort(getUplinkAddr(), htons((in_port_t) uplinkPortNew));
859
860         return false;
861 }
862
863 /*
864  * downlinkPort
865  */
866
867 /** the downlink port */
868 unsigned short downlinkPort = 0;
869
870 /** true when the downlinkPort is set */
871 bool downlinkPortSet = false;
872
873 /**
874  @return
875  The downlink port (in network byte order)
876  */
877 unsigned short getDownlinkPort(void) {
878         if (!downlinkPortSet) {
879                 downlinkPort = htons(PUD_DOWNLINK_PORT_DEFAULT);
880                 downlinkPortSet = true;
881         }
882
883         return downlinkPort;
884 }
885
886 int setDownlinkPort(const char *value, void *data __attribute__ ((unused)),
887                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
888         static const char * valueName = PUD_DOWNLINK_PORT_NAME;
889         unsigned short downlinkPortNew;
890
891         if (!readUS(valueName, value, &downlinkPortNew)) {
892                 return true;
893         }
894
895         if (downlinkPortNew < 1) {
896                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, downlinkPortNew);
897                 return true;
898         }
899
900         downlinkPort = htons(downlinkPortNew);
901         downlinkPortSet = true;
902
903         return false;
904 }
905
906 /*
907  * olsrTtl
908  */
909
910 /** The OLSR TTL */
911 static unsigned char olsrTtl = PUD_OLSR_TTL_DEFAULT;
912
913 /**
914  @return
915  The OLSR multicast IP packet time-to-live
916  */
917 unsigned char getOlsrTtl(void) {
918         return olsrTtl;
919 }
920
921 int setOlsrTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
922         static const char * valueName = PUD_OLSR_TTL_NAME;
923
924         if (!readUC(valueName, value, &olsrTtl)) {
925                 return true;
926         }
927
928         if ((olsrTtl < 1) /* || (olsrTtl > MAX_TTL) */) {
929                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-%u",
930                                 valueName, olsrTtl, MAX_TTL);
931                 return true;
932         }
933
934         return false;
935 }
936
937 /*
938  * updateIntervalStationary
939  */
940
941 /** The stationary interval update plugin parameter (in seconds) */
942 static unsigned long long updateIntervalStationary = PUD_UPDATE_INTERVAL_STATIONARY_DEFAULT;
943
944 /**
945  @return
946  The stationary interval update plugin parameter (in seconds)
947  */
948 unsigned long long getUpdateIntervalStationary(void) {
949         return updateIntervalStationary;
950 }
951
952 int setUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
953                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
954         static const char * valueName = PUD_UPDATE_INTERVAL_STATIONARY_NAME;
955
956         if (!readULL(valueName, value, &updateIntervalStationary)) {
957                 return true;
958         }
959
960         if (updateIntervalStationary < 1) {
961                 pudError(false, "Value of parameter %s must be at least 1", valueName);
962                 return true;
963         }
964
965         return false;
966 }
967
968 /*
969  * updateIntervalMoving
970  */
971
972 /** The moving interval update plugin parameter (in seconds) */
973 static unsigned long long updateIntervalMoving = PUD_UPDATE_INTERVAL_MOVING_DEFAULT;
974
975 /**
976  @return
977  The moving interval update plugin parameter (in seconds)
978  */
979 unsigned long long getUpdateIntervalMoving(void) {
980         return updateIntervalMoving;
981 }
982
983 int setUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
984                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
985         static const char * valueName = PUD_UPDATE_INTERVAL_MOVING_NAME;
986
987         if (!readULL(valueName, value, &updateIntervalMoving)) {
988                 return true;
989         }
990
991         if (updateIntervalMoving < 1) {
992                 pudError(false, "Value of parameter %s must be at least 1", valueName);
993                 return true;
994         }
995
996         return false;
997 }
998
999 /*
1000  * uplinkUpdateIntervalStationary
1001  */
1002
1003 /** The uplink stationary interval update plugin parameter (in seconds) */
1004 static unsigned long long uplinkUpdateIntervalStationary = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_DEFAULT;
1005
1006 /**
1007  @return
1008  The uplink stationary interval update plugin parameter (in seconds)
1009  */
1010 unsigned long long getUplinkUpdateIntervalStationary(void) {
1011         return uplinkUpdateIntervalStationary;
1012 }
1013
1014 int setUplinkUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
1015                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1016         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_NAME;
1017
1018         if (!readULL(valueName, value, &uplinkUpdateIntervalStationary)) {
1019                 return true;
1020         }
1021
1022         if (uplinkUpdateIntervalStationary < 1) {
1023                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1024                 return true;
1025         }
1026
1027         return false;
1028 }
1029
1030 /*
1031  * uplinkUpdateIntervalMoving
1032  */
1033
1034 /** The uplink moving interval update plugin parameter (in seconds) */
1035 static unsigned long long uplinkUpdateIntervalMoving = PUD_UPLINK_UPDATE_INTERVAL_MOVING_DEFAULT;
1036
1037 /**
1038  @return
1039  The uplink moving interval update plugin parameter (in seconds)
1040  */
1041 unsigned long long getUplinkUpdateIntervalMoving(void) {
1042         return uplinkUpdateIntervalMoving;
1043 }
1044
1045 int setUplinkUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
1046                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1047         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_MOVING_NAME;
1048
1049         if (!readULL(valueName, value, &uplinkUpdateIntervalMoving)) {
1050                 return true;
1051         }
1052
1053         if (uplinkUpdateIntervalMoving < 1) {
1054                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1055                 return true;
1056         }
1057
1058         return false;
1059 }
1060
1061 /*
1062  * gatewayDeterminationInterval
1063  */
1064
1065 /** The gateway determination interval plugin parameter (in seconds) */
1066 static unsigned long long gatewayDeterminationInterval = PUD_GATEWAY_DETERMINATION_INTERVAL_DEFAULT;
1067
1068 /**
1069  @return
1070  The gateway determination interval plugin parameter (in seconds)
1071  */
1072 unsigned long long getGatewayDeterminationInterval(void) {
1073         return gatewayDeterminationInterval;
1074 }
1075
1076 int setGatewayDeterminationInterval(const char *value, void *data __attribute__ ((unused)),
1077                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1078         static const char * valueName = PUD_GATEWAY_DETERMINATION_INTERVAL_NAME;
1079
1080         if (!readULL(valueName, value, &gatewayDeterminationInterval)) {
1081                 return true;
1082         }
1083
1084         if (gatewayDeterminationInterval < 1) {
1085                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1086                 return true;
1087         }
1088
1089         return false;
1090 }
1091
1092 /*
1093  * movingSpeedThreshold
1094  */
1095
1096 /** The moving speed threshold plugin parameter (in kph) */
1097 static unsigned long long movingSpeedThreshold = PUD_MOVING_SPEED_THRESHOLD_DEFAULT;
1098
1099 /**
1100  @return
1101  The moving speed threshold plugin parameter (in kph)
1102  */
1103 unsigned long long getMovingSpeedThreshold(void) {
1104         return movingSpeedThreshold;
1105 }
1106
1107 int setMovingSpeedThreshold(const char *value, void *data __attribute__ ((unused)),
1108                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1109         return !readULL(PUD_MOVING_SPEED_THRESHOLD_NAME, value, &movingSpeedThreshold);
1110 }
1111
1112 /*
1113  * movingDistanceThreshold
1114  */
1115
1116 /** The moving distance threshold plugin parameter (in meters) */
1117 static unsigned long long movingDistanceThreshold = PUD_MOVING_DISTANCE_THRESHOLD_DEFAULT;
1118
1119 /**
1120  @return
1121  The moving distance threshold plugin parameter (in meters)
1122  */
1123 unsigned long long getMovingDistanceThreshold(void) {
1124         return movingDistanceThreshold;
1125 }
1126
1127 int setMovingDistanceThreshold(const char *value, void *data __attribute__ ((unused)),
1128                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1129         return !readULL(PUD_MOVING_DISTANCE_THRESHOLD_NAME, value, &movingDistanceThreshold);
1130 }
1131
1132 /*
1133  * dopMultiplier
1134  */
1135
1136 /** The DOP multiplier plugin parameter */
1137 static double dopMultiplier = PUD_DOP_MULTIPLIER_DEFAULT;
1138
1139 /**
1140  @return
1141  The DOP multiplier plugin parameter
1142  */
1143 double getDopMultiplier(void) {
1144         return dopMultiplier;
1145 }
1146
1147 int setDopMultiplier(const char *value, void *data __attribute__ ((unused)),
1148                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1149         return !readDouble(PUD_DOP_MULTIPLIER_NAME, value, &dopMultiplier);
1150 }
1151
1152 /*
1153  * defaultHdop
1154  */
1155
1156 /** The default HDOP plugin parameter (in meters) */
1157 static unsigned long long defaultHdop = PUD_DEFAULT_HDOP_DEFAULT;
1158
1159 /**
1160  @return
1161  The default HDOP plugin parameter (in meters)
1162  */
1163 unsigned long long getDefaultHdop(void) {
1164         return defaultHdop;
1165 }
1166
1167 int setDefaultHdop(const char *value, void *data __attribute__ ((unused)),
1168                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1169         return !readULL(PUD_DEFAULT_HDOP_NAME, value, &defaultHdop);
1170 }
1171
1172 /*
1173  * defaultVdop
1174  */
1175
1176 /** The default VDOP plugin parameter (in meters) */
1177 static unsigned long long defaultVdop = PUD_DEFAULT_VDOP_DEFAULT;
1178
1179 /**
1180  @return
1181  The default VDOP plugin parameter (in meters)
1182  */
1183 unsigned long long getDefaultVdop(void) {
1184         return defaultVdop;
1185 }
1186
1187 int setDefaultVdop(const char *value, void *data __attribute__ ((unused)),
1188                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1189         return !readULL(PUD_DEFAULT_VDOP_NAME, value, &defaultVdop);
1190 }
1191
1192 /*
1193  * averageDepth
1194  */
1195
1196 /** The depth of the average list */
1197 static unsigned long long averageDepth = PUD_AVERAGE_DEPTH_DEFAULT;
1198
1199 /**
1200  @return
1201  The depth of the average list
1202  */
1203 unsigned long long getAverageDepth(void) {
1204         return averageDepth;
1205 }
1206
1207 int setAverageDepth(const char *value, void *data __attribute__ ((unused)),
1208                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1209         static const char * valueName = PUD_AVERAGE_DEPTH_NAME;
1210
1211         if (!readULL(valueName, value, &averageDepth)) {
1212                 return true;
1213         }
1214
1215         if (averageDepth < 1) {
1216                 pudError(false, "Value of parameter %s must be at least 1", valueName);
1217                 return true;
1218         }
1219
1220         return false;
1221 }
1222
1223 /*
1224  * hysteresisCountToStationary
1225  */
1226
1227 /** The hysteresis count for changing state from moving to stationary */
1228 static unsigned long long hysteresisCountToStationary = PUD_HYSTERESIS_COUNT_2STAT_DEFAULT;
1229
1230 /**
1231  @return
1232  The hysteresis count for changing state from moving to stationary
1233  */
1234 unsigned long long getHysteresisCountToStationary(void) {
1235         return hysteresisCountToStationary;
1236 }
1237
1238 int setHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1239                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1240         return !readULL(PUD_HYSTERESIS_COUNT_2STAT_NAME, value, &hysteresisCountToStationary);
1241 }
1242
1243 /*
1244  * hysteresisCountToMoving
1245  */
1246
1247 /** The hysteresis count for changing state from stationary to moving */
1248 static unsigned long long hysteresisCountToMoving = PUD_HYSTERESIS_COUNT_2MOV_DEFAULT;
1249
1250 /**
1251  @return
1252  The hysteresis count for changing state from stationary to moving
1253  */
1254 unsigned long long getHysteresisCountToMoving(void) {
1255         return hysteresisCountToMoving;
1256 }
1257
1258 int setHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1259                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1260         return !readULL(PUD_HYSTERESIS_COUNT_2MOV_NAME, value, &hysteresisCountToMoving);
1261 }
1262
1263 /*
1264  * gatewayHysteresisCountToStationary
1265  */
1266
1267 /** The hysteresis count for changing state from moving to stationary */
1268 static unsigned long long gatewayHysteresisCountToStationary = PUD_GAT_HYSTERESIS_COUNT_2STAT_DEFAULT;
1269
1270 /**
1271  @return
1272  The hysteresis count for changing state from moving to stationary
1273  */
1274 unsigned long long getGatewayHysteresisCountToStationary(void) {
1275         return gatewayHysteresisCountToStationary;
1276 }
1277
1278 int setGatewayHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1279                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1280         return !readULL(PUD_GAT_HYSTERESIS_COUNT_2STAT_NAME, value, &gatewayHysteresisCountToStationary);
1281 }
1282
1283 /*
1284  * gatewayHysteresisCountToMoving
1285  */
1286
1287 /** The hysteresis count for changing state from stationary to moving */
1288 static unsigned long long gatewayHysteresisCountToMoving = PUD_GAT_HYSTERESIS_COUNT_2MOV_DEFAULT;
1289
1290 /**
1291  @return
1292  The hysteresis count for changing state from stationary to moving
1293  */
1294 unsigned long long getGatewayHysteresisCountToMoving(void) {
1295         return gatewayHysteresisCountToMoving;
1296 }
1297
1298 int setGatewayHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1299                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1300         return !readULL(PUD_GAT_HYSTERESIS_COUNT_2MOV_NAME, value, &gatewayHysteresisCountToMoving);
1301 }
1302
1303 /*
1304  * useDeDup
1305  */
1306
1307 /** when true then duplicate message detection is performed */
1308 static bool useDeDup = PUD_USE_DEDUP_DEFAULT;
1309
1310 /**
1311  @return
1312  The duplicate message detection setting
1313  */
1314 bool getUseDeDup(void) {
1315         return useDeDup;
1316 }
1317
1318 int setUseDeDup(const char *value, void *data __attribute__ ((unused)),
1319                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1320         return !readBool(PUD_USE_DEDUP_NAME, value, &useDeDup);
1321 }
1322
1323 /*
1324  * deDupDepth
1325  */
1326
1327 /** The deduplication depth */
1328 static unsigned long long deDupDepth = PUD_DEDUP_DEPTH_DEFAULT;
1329
1330 /**
1331  @return
1332  The deduplication depth
1333  */
1334 unsigned long long getDeDupDepth(void) {
1335         return deDupDepth;
1336 }
1337
1338 int setDeDupDepth(const char *value, void *data __attribute__ ((unused)),
1339                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1340         return !readULL(PUD_DEDUP_DEPTH_NAME, value, &deDupDepth);
1341 }
1342
1343 /*
1344  * useLoopback
1345  */
1346
1347 /** when true then loopback is performed */
1348 static bool useLoopback = PUD_USE_LOOPBACK_DEFAULT;
1349
1350 /**
1351  @return
1352  The loopback usage setting
1353  */
1354 bool getUseLoopback(void) {
1355         return useLoopback;
1356 }
1357
1358 int setUseLoopback(const char *value, void *data __attribute__ ((unused)),
1359                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1360         return !readBool(PUD_USE_LOOPBACK_NAME, value, &useLoopback);
1361 }
1362
1363 /*
1364  * Check Functions
1365  */
1366
1367 /**
1368  Check the configuration for consistency and validity.
1369
1370  @return
1371  - true when the configuration is consistent and valid
1372  - false otherwise
1373  */
1374 unsigned int checkConfig(void) {
1375         int retval = true;
1376
1377         if (!olsr_cnf->smart_gw_active) {
1378                 pudError(false, "Smart Gateway must be active");
1379                 retval = false;
1380         }
1381
1382         if (rxNonOlsrInterfaceCount == 0) {
1383                 pudError(false, "No receive non-OLSR interfaces configured");
1384                 retval = false;
1385         }
1386
1387         if (txNonOlsrInterfaceCount == 0) {
1388                 pudError(false, "No transmit non-OLSR interfaces configured");
1389                 retval = false;
1390         }
1391
1392         if (!nodeIdSet) {
1393                 if (nodeIdType == PUD_NODEIDTYPE_DNS) {
1394                         char name[PUD_TX_NODEID_BUFFERSIZE];
1395
1396                         errno = 0;
1397                         if (gethostname(&name[0], sizeof(name)) < 0) {
1398                                 pudError(true, "Could not get the host name");
1399                                 retval = false;
1400                         } else {
1401                                 setNodeId(&name[0], NULL,
1402                                                 (set_plugin_parameter_addon) {.pc = NULL});
1403                         }
1404                         name[PUD_TX_NODEID_BUFFERSIZE - 1] = '\0';
1405                 } else if ((nodeIdType != PUD_NODEIDTYPE_MAC) && (nodeIdType
1406                                 != PUD_NODEIDTYPE_IPV4) && (nodeIdType != PUD_NODEIDTYPE_IPV6)) {
1407                         pudError(false, "No node ID set while one is required for"
1408                                 " node type %u", nodeIdType);
1409                         retval = false;
1410                 }
1411         }
1412
1413         if (!setupNodeIdBinaryAndValidate(nodeIdType)) {
1414                 retval = false;
1415         }
1416
1417         if (updateIntervalMoving > updateIntervalStationary) {
1418                 pudError(false,"The update interval for moving situations must not be"
1419                 " larger than that for stationary situations");
1420                 retval = false;
1421         }
1422
1423         if (uplinkUpdateIntervalMoving > uplinkUpdateIntervalStationary) {
1424                 pudError(false,"The uplink update interval for moving situations must not be"
1425                 " larger than that for stationary situations");
1426                 retval = false;
1427         }
1428
1429         if (isUplinkAddrSet() && (getUplinkPort() == getDownlinkPort())) {
1430                 pudError(false, "The uplink port and the downlink port must not be the same");
1431                 retval = false;
1432         }
1433
1434         return retval;
1435 }
1436
1437 /**
1438  Check the configuration for consistency and validity after everything has been
1439  setup.
1440
1441  @return
1442  - true when the configuration is consistent and valid
1443  - false otherwise
1444  */
1445 unsigned int checkRunSetup(void) {
1446         return true;
1447 }