282965fff39bafaa07ca384c106c71ba32f7f5e2
[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/util.h>
16 #include <OlsrdPudWireFormat/nodeIdConversion.h>
17 #include <limits.h>
18
19 /*
20  * nodeIdType
21  */
22
23 /** The nodeIdType */
24 static NodeIdType nodeIdType = PUD_NODE_ID_TYPE_DEFAULT;
25
26 /**
27  @return
28  The node ID type
29  */
30 NodeIdType getNodeIdTypeNumber(void) {
31         return nodeIdType;
32 }
33
34 /**
35  Set the node ID type.
36
37  @param value
38  The value of the node ID type to set (a number in string representation)
39  @param data
40  Unused
41  @param addon
42  Unused
43
44  @return
45  - true when an error is detected
46  - false otherwise
47  */
48 int setNodeIdType(const char *value, void *data __attribute__ ((unused)),
49                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
50         static const char * valueName = PUD_NODE_ID_TYPE_NAME;
51         unsigned long long nodeIdTypeNew;
52
53         assert (value != NULL);
54
55         if (!readULL(valueName, value, &nodeIdTypeNew)) {
56                 return true;
57         }
58
59         if (!isValidNodeIdType(nodeIdTypeNew)) {
60                 pudError(false, "Configured %s (%llu) is reserved", valueName,
61                                 nodeIdTypeNew);
62                 return true;
63         }
64
65         nodeIdType = nodeIdTypeNew;
66
67         return false;
68 }
69
70 /*
71  * nodeId
72  */
73
74 /** The nodeId buffer */
75 static unsigned char nodeId[PUD_TX_NODEID_BUFFERSIZE + 1];
76
77 /** The length of the string in the nodeId buffer */
78 static size_t nodeIdLength = 0;
79
80 /** True when the nodeId is set */
81 static bool nodeIdSet = false;
82
83 /** The nodeId as a binary representation, with status */
84 static nodeIdBinaryType nodeIdBinary;
85
86 /**
87  @return
88  The node ID
89  */
90 unsigned char * getNodeId(void) {
91         return getNodeIdWithLength(NULL);
92 }
93
94 /**
95  Get the nodeId and its length
96
97  @param length
98  a pointer to the variable in which to store the nodeId length (allowed to be
99  NULL, in which case the length is not stored)
100
101  @return
102  The node ID
103  */
104 unsigned char * getNodeIdWithLength(size_t *length) {
105         if (!nodeIdSet) {
106                 setNodeId("", NULL, (set_plugin_parameter_addon) {.pc = NULL});
107         }
108
109         if (length != NULL) {
110                 *length = nodeIdLength;
111         }
112
113         return &nodeId[0];
114 }
115
116 /**
117  Get the nodeIdBinary
118
119  @return
120  The node ID in binary representation
121  */
122 nodeIdBinaryType * getNodeIdBinary(void) {
123         if (!nodeIdBinary.set) {
124                 setNodeId("", NULL, (set_plugin_parameter_addon) {.pc = NULL});
125         }
126
127         return &nodeIdBinary;
128 }
129
130 /**
131  Set the node ID.
132
133  @param value
134  The value of the node ID to set (in string representation)
135  @param data
136  Unused
137  @param addon
138  Unused
139
140  @return
141  - true when an error is detected
142  - false otherwise
143  */
144 int setNodeId(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
145         static const char * valueName = PUD_NODE_ID_NAME;
146         size_t valueLength;
147
148         assert (value != NULL);
149
150         valueLength = strlen(value);
151         if (valueLength > PUD_TX_NODEID_BUFFERSIZE) {
152                 pudError(false, "Configured %s is too long, maximum length is"
153                         " %u, current length is %lu", valueName, PUD_TX_NODEID_BUFFERSIZE,
154                                 (unsigned long) valueLength);
155                 return true;
156         }
157
158         strcpy((char *) &nodeId[0], value);
159         nodeIdLength = valueLength;
160         nodeIdSet = true;
161
162         return false;
163 }
164
165 /*
166  * nodeId Validation
167  */
168
169 /**
170  Validate whether the configured nodeId is valid w.r.t. the configured
171  nodeIdType, for types that are MAC addresses
172
173  @return
174  - true when ok
175  - false on failure
176  */
177 static bool intSetupNodeIdBinaryMAC(void) {
178         unsigned char * mac = getMainIpMacAddress();
179         if (!mac) {
180                 return false;
181         }
182
183         return setupNodeIdBinaryMAC(&nodeIdBinary, mac);
184 }
185
186 /**
187  Validate whether the configured nodeId is valid w.r.t. the configured
188  nodeIdType, for types that fit in an unsigned long long (64 bits)
189
190  @param min
191  the minimum value
192  @param max
193  the maximum value
194  @param bytes
195  the number of bytes in the buffer
196
197  @return
198  - true when ok
199  - false on failure
200  */
201 static bool intSetupNodeIdBinaryLongLong(unsigned long long min,
202                 unsigned long long max, unsigned int bytes) {
203         unsigned long long longValue = 0;
204         if (!readULL(PUD_NODE_ID_NAME, (char *) getNodeId(), &longValue)) {
205                 return false;
206         }
207
208         if ((longValue < min) || (longValue > max)) {
209                 pudError(false, "%s value %llu is out of range [%llu,%llu]",
210                                 PUD_NODE_ID_NAME, longValue, min, max);
211                 return false;
212         }
213
214         return setupNodeIdBinaryLongLong(&nodeIdBinary, longValue, bytes);
215 }
216
217 /**
218  Validate whether the configured nodeId is valid w.r.t. the configured
219  nodeIdType, for types that are strings
220
221  @return
222  - true when ok
223  - false on failure
224  */
225 static bool intSetupNodeIdBinaryString(void) {
226         bool invalidChars;
227         char report[256];
228         size_t nodeidlength;
229         char * nodeid = (char *)getNodeIdWithLength(&nodeidlength);
230
231         invalidChars = nmea_string_has_invalid_chars(nodeid,
232                         PUD_NODE_ID_NAME, &report[0], sizeof(report));
233         if (invalidChars) {
234                 pudError(false, "%s", &report[0]);
235                 return false;
236         }
237
238         if (nodeidlength > PUD_TX_NODEID_BUFFERSIZE) {
239                 pudError(false, "%s value \"%s\" is too long", PUD_NODE_ID_NAME, &nodeid[0]);
240                 return false;
241         }
242
243         return setupNodeIdBinaryString(&nodeIdBinary, nodeid, nodeidlength);
244 }
245
246 /**
247  Validate whether the configured nodeId is valid w.r.t. the configured
248  nodeIdType, for types that are IP addresses
249
250  @return
251  - true when ok
252  - false on failure
253  */
254 static bool intSetupNodeIdBinaryIp(void) {
255         void * src;
256         size_t length;
257         if (olsr_cnf->ip_version == AF_INET) {
258                 src = &olsr_cnf->main_addr.v4;
259                 length = sizeof(struct in_addr);
260         } else {
261                 src = &olsr_cnf->main_addr.v6;
262                 length = sizeof(struct in6_addr);
263         }
264
265         return setupNodeIdBinaryIp(&nodeIdBinary, src, length);
266 }
267
268 /**
269  Validate whether the configured nodeId is valid w.r.t. the configured
270  nodeIdType
271
272  @return
273  - true when ok
274  - false on failure
275  */
276 static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber) {
277         switch (nodeIdTypeNumber) {
278                 case PUD_NODEIDTYPE_MAC: /* hardware address */
279                         return intSetupNodeIdBinaryMAC();
280
281                 case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
282                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_MSISDN_MIN,
283                                 PUD_NODEIDTYPE_MSISDN_MAX, PUD_NODEIDTYPE_MSISDN_BYTES);
284
285                 case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
286                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_TETRA_MIN,
287                                 PUD_NODEIDTYPE_TETRA_MAX, PUD_NODEIDTYPE_TETRA_BYTES);
288
289                 case PUD_NODEIDTYPE_DNS: /* DNS name */
290                         return intSetupNodeIdBinaryString();
291
292                 case PUD_NODEIDTYPE_MMSI: /* an AIS MMSI number */
293                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_MMSI_MIN,
294                                 PUD_NODEIDTYPE_MMSI_MAX, PUD_NODEIDTYPE_MMSI_BYTES);
295
296                 case PUD_NODEIDTYPE_URN: /* a URN number */
297                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_URN_MIN,
298                                 PUD_NODEIDTYPE_URN_MAX, PUD_NODEIDTYPE_URN_BYTES);
299
300                 case PUD_NODEIDTYPE_192:
301                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_192_MIN,
302                                 PUD_NODEIDTYPE_192_MAX, PUD_NODEIDTYPE_192_BYTES);
303
304                 case PUD_NODEIDTYPE_193:
305                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_193_MIN,
306                                 PUD_NODEIDTYPE_193_MAX, PUD_NODEIDTYPE_193_BYTES);
307
308                 case PUD_NODEIDTYPE_194:
309                         return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_194_MIN,
310                                 PUD_NODEIDTYPE_194_MAX, PUD_NODEIDTYPE_194_BYTES);
311
312                 case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
313                 case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
314                 default: /* unsupported */
315                         return intSetupNodeIdBinaryIp();
316         }
317
318         return false;
319 }
320
321 /*
322  * rxNonOlsrIf
323  */
324
325 /** The maximum number of RX non-OLSR interfaces */
326 #define PUD_RX_NON_OLSR_IF_MAX 32
327
328 /** Array with RX non-OLSR interface names */
329 static unsigned char rxNonOlsrInterfaceNames[PUD_RX_NON_OLSR_IF_MAX][IFNAMSIZ + 1];
330
331 /** The number of RX non-OLSR interface names in the array */
332 static unsigned int rxNonOlsrInterfaceCount = 0;
333
334 /**
335  Determine whether a give interface name is configured as a receive non-OLSR
336  interface.
337
338  @param ifName
339  The interface name to check
340
341  @return
342  - true when the given interface name is configured as a receive non-OLSR
343  interface
344  - false otherwise
345  */
346 bool isRxNonOlsrInterface(const char *ifName) {
347         unsigned int i;
348
349         assert (ifName != NULL);
350
351         for (i = 0; i < rxNonOlsrInterfaceCount; i++) {
352                 if (strncmp((char *) &rxNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ
353                                 + 1) == 0) {
354                         return true;
355                 }
356         }
357
358         return false;
359 }
360
361 /**
362  Add a receive non-OLSR interface
363
364  @param value
365  The name of the non-OLSR interface to add
366  @param data
367  Unused
368  @param addon
369  Unused
370
371  @return
372  - true when an error is detected
373  - false otherwise
374  */
375 int addRxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
376                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
377         unsigned long valueLength;
378
379         assert (value != NULL);
380
381         valueLength = strlen(value);
382         if (valueLength > IFNAMSIZ) {
383                 pudError(false, "Configured %s (%s) is too long,"
384                         " maximum length is %u, current length is %lu",
385                                 PUD_RX_NON_OLSR_IF_NAME, value, IFNAMSIZ, valueLength);
386                 return true;
387         }
388
389         if (!isRxNonOlsrInterface(value)) {
390                 if (rxNonOlsrInterfaceCount >= PUD_RX_NON_OLSR_IF_MAX) {
391                         pudError(false, "Can't configure more than %u receive interfaces",
392                                         PUD_RX_NON_OLSR_IF_MAX);
393                         return true;
394                 }
395
396                 strcpy((char *) &rxNonOlsrInterfaceNames[rxNonOlsrInterfaceCount][0],
397                                 value);
398                 rxNonOlsrInterfaceCount++;
399         }
400
401         return false;
402 }
403
404 /*
405  * rxAllowedSourceIpAddress
406  */
407
408 /** The maximum number of RX allowed source IP addresses */
409 #define PUD_RX_ALLOWED_SOURCE_IP_MAX 32
410
411 /** Array with RX allowed source IP addresses */
412 static union olsr_sockaddr rxAllowedSourceIpAddresses[PUD_RX_ALLOWED_SOURCE_IP_MAX];
413
414 /** The number of RX allowed source IP addresses in the array */
415 static unsigned int rxAllowedSourceIpAddressesCount = 0;
416
417 /**
418  Determine whether a give IP address is configured as an allowed source IP
419  address.
420
421  @param sender
422  The IP address to check
423
424  @return
425  - true when the given IP address is configured as an allowed source IP
426  address
427  - false otherwise
428  */
429 bool isRxAllowedSourceIpAddress(union olsr_sockaddr * sender) {
430         unsigned int i;
431
432         if (rxAllowedSourceIpAddressesCount == 0) {
433                 return true;
434         }
435
436         if (sender == NULL) {
437                 return false;
438         }
439
440         for (i = 0; i < rxAllowedSourceIpAddressesCount; i++) {
441                 if (sender->in.sa_family != rxAllowedSourceIpAddresses[i].in.sa_family) {
442                         continue;
443                 }
444
445                 if (sender->in.sa_family == AF_INET) {
446                         if (memcmp(&rxAllowedSourceIpAddresses[i].in4.sin_addr, &sender->in4.sin_addr, sizeof(struct in_addr))
447                                         == 0) {
448                                 return true;
449                         }
450                 } else {
451                         if (memcmp(&rxAllowedSourceIpAddresses[i].in6.sin6_addr, &sender->in6.sin6_addr, sizeof(struct in6_addr))
452                                         == 0) {
453                                 return true;
454                         }
455                 }
456         }
457
458         return false;
459 }
460
461 /**
462  Set the RX allowed source IP addresses.
463
464  @param value
465  The RX allowed source IP address (in string representation)
466  @param data
467  Unused
468  @param addon
469  Unused
470
471  @return
472  - true when an error is detected
473  - false otherwise
474  */
475 int addRxAllowedSourceIpAddress(const char *value, void *data __attribute__ ((unused)),
476                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
477         static const char * valueName = PUD_RX_ALLOWED_SOURCE_IP_NAME;
478         union olsr_sockaddr addr;
479         bool addrSet = false;
480
481         assert (value != NULL);
482
483         if (rxAllowedSourceIpAddressesCount >= PUD_RX_ALLOWED_SOURCE_IP_MAX) {
484                 pudError(false, "Can't configure more than %u allowed source IP"
485                         " addresses", PUD_RX_ALLOWED_SOURCE_IP_MAX);
486                 return true;
487         }
488
489         if (!readIPAddress(valueName, value, 0, &addr, &addrSet)) {
490                 return true;
491         }
492
493         if (!isRxAllowedSourceIpAddress(&addr)) {
494                 rxAllowedSourceIpAddresses[rxAllowedSourceIpAddressesCount] = addr;
495                 rxAllowedSourceIpAddressesCount++;
496         }
497
498         return false;
499 }
500
501 /*
502  * rxMcAddr
503  */
504
505 /** The rx multicast address */
506 static union olsr_sockaddr rxMcAddr;
507
508 /** True when the rx multicast address is set */
509 static bool rxMcAddrSet = false;
510
511 /**
512  @return
513  The receive multicast address (in network byte order). Sets both the address
514  and the port to their default values when the address was not yet set.
515  */
516 union olsr_sockaddr * getRxMcAddr(void) {
517         if (!rxMcAddrSet) {
518                 setRxMcAddr((olsr_cnf->ip_version == AF_INET) ? PUD_RX_MC_ADDR_4_DEFAULT : PUD_RX_MC_ADDR_6_DEFAULT,
519                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
520         }
521         return &rxMcAddr;
522 }
523
524 /**
525  Set the receive multicast address. Sets the address to its default value when
526  the value is NULL. Also sets the port to its default value when the address
527  was not yet set.
528
529  @param value
530  The receive multicast address (in string representation)
531  @param data
532  Unused
533  @param addon
534  Unused
535
536  @return
537  - true when an error is detected
538  - false otherwise
539  */
540 int setRxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
541         static const char * valueName = PUD_RX_MC_ADDR_NAME;
542
543         assert(value != NULL);
544
545         if (!readIPAddress(valueName, value, PUD_RX_MC_PORT_DEFAULT, &rxMcAddr, &rxMcAddrSet)) {
546                         return true;
547         }
548
549         if (!isMulticast(&rxMcAddr)) {
550                 pudError(false, "Value of parameter %s (%s) is not a multicast address",
551                                 valueName, value);
552                 return true;
553         }
554
555         return false;
556 }
557
558 /*
559  * rxMcPort
560  */
561
562 /**
563  @return
564  The receive multicast port (in network byte order)
565  */
566 unsigned short getRxMcPort(void) {
567         in_port_t * port;
568         union olsr_sockaddr * sock = getRxMcAddr();
569         getOlsrSockaddrPortAddress(sock, &port);
570         return *port;
571 }
572
573 /**
574  Set the receive multicast port
575
576  @param value
577  The receive multicast port (a number in string representation)
578  @param data
579  Unused
580  @param addon
581  Unused
582
583  @return
584  - true when an error is detected
585  - false otherwise
586  */
587 int setRxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
588         static const char * valueName = PUD_RX_MC_PORT_NAME;
589         unsigned short rxMcPortNew;
590         in_port_t * port;
591         union olsr_sockaddr * addr = getRxMcAddr();
592
593         assert (value != NULL);
594
595         if (!readUS(valueName, value, &rxMcPortNew)) {
596                 return true;
597         }
598
599         if (rxMcPortNew < 1) {
600                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, rxMcPortNew);
601                 return true;
602         }
603
604         getOlsrSockaddrPortAddress(addr, &port);
605         *port = htons((uint16_t) rxMcPortNew);
606
607         return false;
608 }
609
610 /*
611  * positionFile
612  */
613
614 /** The positionFile buffer */
615 static char positionFile[PATH_MAX + 1];
616
617 /** True when the positionFile is set */
618 static bool positionFileSet = false;
619
620 /**
621  @return
622  The positionFile (NULL when not set)
623  */
624 char * getPositionFile(void) {
625         if (!positionFileSet) {
626                 return NULL;
627         }
628
629         return &positionFile[0];
630 }
631
632 /**
633  Set the positionFile.
634
635  @param value
636  The value of the positionFile to set (in string representation)
637  @param data
638  Unused
639  @param addon
640  Unused
641
642  @return
643  - true when an error is detected
644  - false otherwise
645  */
646 int setPositionFile(const char *value, void *data __attribute__ ((unused)),
647                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
648         static const char * valueName = PUD_POSFILE_NAME;
649         size_t valueLength;
650
651         assert(value != NULL);
652
653         if (!startPositionFile()) {
654                 stopPositionFile();
655                 return true;
656         }
657
658         valueLength = strlen(value);
659         if (valueLength > PATH_MAX) {
660                 pudError(false, "Configured %s is too long, maximum length is"
661                                 " %u, current length is %lu", valueName, PATH_MAX, (unsigned long) valueLength);
662                 return true;
663         }
664
665         strcpy((char *) &positionFile[0], value);
666         positionFileSet = true;
667
668         return false;
669 }
670
671 /*
672  * txNonOlsrIf
673  */
674
675 /** The maximum number of rx non-olsr interfaces */
676 #define PUD_TX_NON_OLSR_IF_MAX 32
677
678 /** Array with tx non-olsr interface names */
679 static unsigned char txNonOlsrInterfaceNames[PUD_TX_NON_OLSR_IF_MAX][IFNAMSIZ + 1];
680
681 /** The number of tx interface names in the array */
682 static unsigned int txNonOlsrInterfaceCount = 0;
683
684 /**
685  Determine whether a give interface name is configured as a transmit non-OLSR
686  interface.
687
688  @param ifName
689  The interface to check
690
691  @return
692  - true when the given interface name is configured as a transmit non-OLSR
693  interface
694  - false otherwise
695  */
696 bool isTxNonOlsrInterface(const char *ifName) {
697         unsigned int i;
698
699         assert (ifName != NULL);
700
701         for (i = 0; i < txNonOlsrInterfaceCount; i++) {
702                 if (strncmp((char *) &txNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ
703                                 + 1) == 0) {
704                         return true;
705                 }
706         }
707
708         return false;
709 }
710
711 /**
712  Add a transmit non-OLSR interface
713
714  @param value
715  The name of the non-OLSR interface to add
716  @param data
717  Unused
718  @param addon
719  Unused
720
721  @return
722  - true when an error is detected
723  - false otherwise
724  */
725 int addTxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
726                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
727         unsigned long valueLength;
728
729         assert (value != NULL);
730
731         valueLength = strlen(value);
732         if (valueLength > IFNAMSIZ) {
733                 pudError(false, "Configured %s (%s) is too long,"
734                         " maximum length is %u, current length is %lu",
735                                 PUD_TX_NON_OLSR_IF_NAME, value, IFNAMSIZ, valueLength);
736                 return true;
737         }
738
739         if (!isTxNonOlsrInterface(value)) {
740                 if (txNonOlsrInterfaceCount >= PUD_TX_NON_OLSR_IF_MAX) {
741                         pudError(false, "Can not configure more than %u transmit"
742                                 " interfaces", PUD_TX_NON_OLSR_IF_MAX);
743                         return true;
744                 }
745
746                 strcpy((char *) &txNonOlsrInterfaceNames[txNonOlsrInterfaceCount][0],
747                                 value);
748                 txNonOlsrInterfaceCount++;
749         }
750
751         return false;
752 }
753
754 /*
755  * txMcAddr
756  */
757
758 /** The tx multicast address */
759 static union olsr_sockaddr txMcAddr;
760
761 /** True when the tx multicast address is set */
762 static bool txMcAddrSet = false;
763
764 /**
765  @return
766  The transmit multicast address (in network byte order). Sets both the address
767  and the port to their default values when the address was not yet set.
768  */
769 union olsr_sockaddr * getTxMcAddr(void) {
770         if (!txMcAddrSet) {
771                 setTxMcAddr((olsr_cnf->ip_version == AF_INET) ? PUD_TX_MC_ADDR_4_DEFAULT : PUD_TX_MC_ADDR_6_DEFAULT,
772                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
773         }
774         return &txMcAddr;
775 }
776
777 /**
778  Set the transmit multicast address. Sets the address to its default value when
779  the value is NULL. Also sets the port to its default value when the address
780  was not yet set.
781
782  @param value
783  The transmit multicast address (in string representation)
784  @param data
785  Unused
786  @param addon
787  Unused
788
789  @return
790  - true when an error is detected
791  - false otherwise
792  */
793 int setTxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
794         static const char * valueName = PUD_TX_MC_ADDR_NAME;
795
796         assert (value != NULL);
797
798         if (!readIPAddress(valueName, value, PUD_TX_MC_PORT_DEFAULT, &txMcAddr, &txMcAddrSet)) {
799                         return true;
800         }
801
802         if (!isMulticast(&txMcAddr)) {
803                 pudError(false, "Value of parameter %s (%s) is not a multicast address",
804                                 valueName, value);
805                 return true;
806         }
807
808         return false;
809 }
810
811 /*
812  * txMcPort
813  */
814
815 /**
816  @return
817  The transmit multicast port (in network byte order)
818  */
819 unsigned short getTxMcPort(void) {
820         in_port_t * port;
821         union olsr_sockaddr * sock = getTxMcAddr();
822         getOlsrSockaddrPortAddress(sock, &port);
823         return *port;
824 }
825
826 /**
827  Set the transmit multicast port
828
829  @param value
830  The transmit multicast port (a number in string representation)
831  @param data
832  Unused
833  @param addon
834  Unused
835
836  @return
837  - true when an error is detected
838  - false otherwise
839  */
840 int setTxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
841         static const char * valueName = PUD_TX_MC_PORT_NAME;
842         unsigned short txMcPortNew;
843         in_port_t * port;
844         union olsr_sockaddr * addr = getTxMcAddr();
845
846         assert (value != NULL);
847
848         if (!readUS(valueName, value, &txMcPortNew)) {
849                 return true;
850         }
851
852         if (txMcPortNew < 1) {
853                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, txMcPortNew);
854                 return true;
855         }
856
857         getOlsrSockaddrPortAddress(addr, &port);
858         *port = htons((uint16_t) txMcPortNew);
859
860         return false;
861 }
862
863 /*
864  * uplinkAddr
865  */
866
867 /** The uplink address */
868 static union olsr_sockaddr uplinkAddr;
869
870 /** True when the uplink address is set */
871 static bool uplinkAddrSet = false;
872
873 /**
874  @return
875  - true when the uplink address is set
876  - false otherwise
877  */
878 bool isUplinkAddrSet(void) {
879         return uplinkAddrSet;
880 }
881
882 /**
883  @return
884  The uplink address (in network byte order). Sets both the address
885  and the port to their default values when the address was not yet set.
886  */
887 union olsr_sockaddr * getUplinkAddr(void) {
888         if (!uplinkAddrSet) {
889                 setUplinkAddr((olsr_cnf->ip_version == AF_INET) ? PUD_UPLINK_ADDR_4_DEFAULT : PUD_UPLINK_ADDR_6_DEFAULT,
890                                 NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
891         }
892         return &uplinkAddr;
893 }
894
895 /**
896  Set the uplink address. Sets the address to its default value when
897  the value is NULL. Also sets the port to its default value when the address
898  was not yet set.
899
900  @param value
901  The uplink address (in string representation)
902  @param data
903  Unused
904  @param addon
905  Unused
906
907  @return
908  - true when an error is detected
909  - false otherwise
910  */
911 int setUplinkAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
912         static const char * valueName = PUD_UPLINK_ADDR_NAME;
913
914         assert (value != NULL);
915
916         if (!readIPAddress(valueName, value, PUD_UPLINK_PORT_DEFAULT, &uplinkAddr, &uplinkAddrSet)) {
917                         return true;
918         }
919
920         return false;
921 }
922
923 /*
924  * uplinkPort
925  */
926
927 /**
928  @return
929  The uplink port (in network byte order)
930  */
931 unsigned short getUplinkPort(void) {
932         in_port_t * port;
933         union olsr_sockaddr * addr = getUplinkAddr();
934         getOlsrSockaddrPortAddress(addr, &port);
935         return *port;
936 }
937
938 /**
939  Set the uplink port
940
941  @param value
942  The uplink port (a number in string representation)
943  @param data
944  Unused
945  @param addon
946  Unused
947
948  @return
949  - true when an error is detected
950  - false otherwise
951  */
952 int setUplinkPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
953         static const char * valueName = PUD_UPLINK_PORT_NAME;
954         unsigned short uplinkPortNew;
955         in_port_t * port;
956         union olsr_sockaddr * addr = getUplinkAddr();
957
958         assert (value != NULL);
959
960         if (!readUS(valueName, value, &uplinkPortNew)) {
961                 return true;
962         }
963
964         if (uplinkPortNew < 1) {
965                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, uplinkPortNew);
966                 return true;
967         }
968
969         getOlsrSockaddrPortAddress(addr, &port);
970         *port = htons((uint16_t) uplinkPortNew);
971
972         return false;
973 }
974
975
976 /*
977  * downlinkPort
978  */
979
980 /** the downlink port */
981 unsigned short downlinkPort = 0;
982
983 /** true when the downlinkPort is set */
984 bool downlinkPortSet = false;
985
986 /**
987  @return
988  The downlink port (in network byte order)
989  */
990 unsigned short getDownlinkPort(void) {
991         if (!downlinkPortSet) {
992                 downlinkPort = htons(PUD_DOWNLINK_PORT_DEFAULT);
993                 downlinkPortSet = true;
994         }
995
996         return downlinkPort;
997 }
998
999 /**
1000  Set the downlink port
1001
1002  @param value
1003  The downlink port (a number in string representation)
1004  @param data
1005  Unused
1006  @param addon
1007  Unused
1008
1009  @return
1010  - true when an error is detected
1011  - false otherwise
1012  */
1013 int setDownlinkPort(const char *value, void *data __attribute__ ((unused)),
1014                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1015         static const char * valueName = PUD_DOWNLINK_PORT_NAME;
1016         unsigned short downlinkPortNew;
1017
1018         assert(value != NULL);
1019
1020         if (!readUS(valueName, value, &downlinkPortNew)) {
1021                 return true;
1022         }
1023
1024         if (downlinkPortNew < 1) {
1025                 pudError(false, "Value of parameter %s (%u) is outside of valid range 1-65535", valueName, downlinkPortNew);
1026                 return true;
1027         }
1028
1029         downlinkPort = htons(downlinkPortNew);
1030         downlinkPortSet = true;
1031
1032         return false;
1033 }
1034
1035 /*
1036  * txTtl
1037  */
1038
1039 /** The tx TTL */
1040 static unsigned char txTtl = PUD_TX_TTL_DEFAULT;
1041
1042 /**
1043  @return
1044  The transmit multicast IP packet time-to-live
1045  */
1046 unsigned char getTxTtl(void) {
1047         return txTtl;
1048 }
1049
1050 /**
1051  Set the transmit multicast IP packet time-to-live
1052
1053  @param value
1054  The transmit multicast IP packet time-to-live (a number in string representation)
1055  @param data
1056  Unused
1057  @param addon
1058  Unused
1059
1060  @return
1061  - true when an error is detected
1062  - false otherwise
1063  */
1064 int setTxTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
1065         static const char * valueName = PUD_TX_TTL_NAME;
1066         unsigned long long txTtlNew;
1067
1068         assert (value != NULL);
1069
1070         if (!readULL(valueName, value, &txTtlNew)) {
1071                 return true;
1072         }
1073
1074         if ((txTtlNew < 1) || (txTtlNew > MAX_TTL)) {
1075                 pudError(false, "Configured %s (%llu) is outside of"
1076                         " valid range 1-%u", valueName, txTtlNew, MAX_TTL);
1077                 return true;
1078         }
1079
1080         txTtl = txTtlNew;
1081
1082         return false;
1083 }
1084
1085 /*
1086  * txNmeaMessagePrefix
1087  */
1088
1089 /** The exact length of the tx NMEA message prefix */
1090 #define PUD_TXNMEAMESSAGEPREFIXLENGTH 4
1091
1092 /** The tx NMEA message prefix buffer */
1093 static unsigned char txNmeaMessagePrefix[PUD_TXNMEAMESSAGEPREFIXLENGTH + 1];
1094
1095 /** True when the tx NMEA message prefix is set */
1096 static bool txNmeaMessagePrefixSet = false;
1097
1098 /**
1099  @return
1100  The transmit multicast NMEA message prefix
1101  */
1102 unsigned char * getTxNmeaMessagePrefix(void) {
1103         if (!txNmeaMessagePrefixSet) {
1104                 setTxNmeaMessagePrefix(PUD_TX_NMEAMESSAGEPREFIX_DEFAULT, NULL,
1105                                 (set_plugin_parameter_addon) {.pc = NULL});
1106         }
1107         return &txNmeaMessagePrefix[0];
1108 }
1109
1110 /**
1111  Set the transmit multicast NMEA message prefix
1112
1113  @param value
1114  The transmit multicast NMEA message prefix (in string representation)
1115  @param data
1116  Unused
1117  @param addon
1118  Unused
1119
1120  @return
1121  - true when an error is detected
1122  - false otherwise
1123  */
1124 int setTxNmeaMessagePrefix(const char *value, void *data __attribute__ ((unused)),
1125                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1126         static const char * valueName = PUD_TX_NMEAMESSAGEPREFIX_NAME;
1127         size_t valueLength;
1128         bool invalidChars;
1129         char report[256];
1130
1131         assert (value != NULL);
1132
1133         valueLength = strlen(value);
1134         if (valueLength != PUD_TXNMEAMESSAGEPREFIXLENGTH) {
1135                 pudError(false, "Configured %s (%s) must be %u exactly characters",
1136                                 valueName, value, PUD_TXNMEAMESSAGEPREFIXLENGTH);
1137                 return true;
1138         }
1139
1140         invalidChars = nmea_string_has_invalid_chars(value, valueName, &report[0],
1141                         sizeof(report));
1142         if (invalidChars) {
1143                 pudError(false, "%s", &report[0]);
1144                 return true;
1145         }
1146
1147         if ((strchr(value, ' ') != NULL) || (strchr(value, '\t') != NULL)) {
1148                 pudError(false, "Configured %s (%s) can not contain whitespace",
1149                                 valueName, value);
1150                 return true;
1151         }
1152
1153         strcpy((char *) &txNmeaMessagePrefix[0], value);
1154         txNmeaMessagePrefixSet = true;
1155         return false;
1156 }
1157
1158 /*
1159  * olsrTtl
1160  */
1161
1162 /** The OLSR TTL */
1163 static unsigned char olsrTtl = PUD_OLSR_TTL_DEFAULT;
1164
1165 /**
1166  @return
1167  The OLSR multicast IP packet time-to-live
1168  */
1169 unsigned char getOlsrTtl(void) {
1170         return olsrTtl;
1171 }
1172
1173 /**
1174  Set the OLSR multicast IP packet time-to-live
1175
1176  @param value
1177  The OLSR multicast IP packet time-to-live (a number in string representation)
1178  @param data
1179  Unused
1180  @param addon
1181  Unused
1182
1183  @return
1184  - true when an error is detected
1185  - false otherwise
1186  */
1187 int setOlsrTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
1188         static const char * valueName = PUD_OLSR_TTL_NAME;
1189         unsigned long long olsrTtlNew;
1190
1191         assert (value != NULL);
1192
1193         if (!readULL(valueName, value, &olsrTtlNew)) {
1194                 return true;
1195         }
1196
1197         if ((olsrTtlNew < 1) || (olsrTtlNew > MAX_TTL)) {
1198                 pudError(false, "Configured %s (%llu) is outside of valid range 1-%u",
1199                                 valueName, olsrTtlNew, MAX_TTL);
1200                 return true;
1201         }
1202
1203         olsrTtl = olsrTtlNew;
1204
1205         return false;
1206 }
1207
1208 /*
1209  * updateIntervalStationary
1210  */
1211
1212 /** The stationary interval update plugin parameter (in seconds) */
1213 static unsigned long long updateIntervalStationary = PUD_UPDATE_INTERVAL_STATIONARY_DEFAULT;
1214
1215 /**
1216  @return
1217  The stationary interval update plugin parameter (in seconds)
1218  */
1219 unsigned long long getUpdateIntervalStationary(void) {
1220         return updateIntervalStationary;
1221 }
1222
1223 /**
1224  Set stationary interval update plugin parameter
1225
1226  @param value
1227  The stationary interval update plugin parameter (in seconds)
1228  @param data
1229  Unused
1230  @param addon
1231  Unused
1232
1233  @return
1234  - true when an error is detected
1235  - false otherwise
1236  */
1237 int setUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
1238                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1239         static const char * valueName = PUD_UPDATE_INTERVAL_STATIONARY_NAME;
1240         unsigned long long updateIntervalStationaryNew;
1241
1242         assert (value != NULL);
1243
1244         if (!readULL(valueName, value, &updateIntervalStationaryNew)) {
1245                 return true;
1246         }
1247
1248         if (updateIntervalStationaryNew < 1) {
1249                 pudError(false, "Configured %s must be at least 1", valueName);
1250                 return true;
1251         }
1252
1253         updateIntervalStationary = updateIntervalStationaryNew;
1254
1255         return false;
1256 }
1257
1258 /*
1259  * updateIntervalMoving
1260  */
1261
1262 /** The moving interval update plugin parameter (in seconds) */
1263 static unsigned long long updateIntervalMoving = PUD_UPDATE_INTERVAL_MOVING_DEFAULT;
1264
1265 /**
1266  @return
1267  The moving interval update plugin parameter (in seconds)
1268  */
1269 unsigned long long getUpdateIntervalMoving(void) {
1270         return updateIntervalMoving;
1271 }
1272
1273 /**
1274  Set moving interval update plugin parameter
1275
1276  @param value
1277  The moving interval update plugin parameter (in seconds)
1278  @param data
1279  Unused
1280  @param addon
1281  Unused
1282
1283  @return
1284  - true when an error is detected
1285  - false otherwise
1286  */
1287 int setUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
1288                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1289         static const char * valueName = PUD_UPDATE_INTERVAL_MOVING_NAME;
1290         unsigned long long updateIntervalMovingNew;
1291
1292         assert (value != NULL);
1293
1294         if (!readULL(valueName, value, &updateIntervalMovingNew)) {
1295                 return true;
1296         }
1297
1298         if (updateIntervalMovingNew < 1) {
1299                 pudError(false, "Configured %s must be at least 1", valueName);
1300                 return true;
1301         }
1302
1303         updateIntervalMoving = updateIntervalMovingNew;
1304
1305         return false;
1306 }
1307
1308 /*
1309  * uplinkUpdateIntervalStationary
1310  */
1311
1312 /** The uplink stationary interval update plugin parameter (in seconds) */
1313 static unsigned long long uplinkUpdateIntervalStationary = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_DEFAULT;
1314
1315 /**
1316  @return
1317  The uplink stationary interval update plugin parameter (in seconds)
1318  */
1319 unsigned long long getUplinkUpdateIntervalStationary(void) {
1320         return uplinkUpdateIntervalStationary;
1321 }
1322
1323 /**
1324  Set uplink stationary interval update plugin parameter
1325
1326  @param value
1327  The uplink stationary interval update plugin parameter (in seconds)
1328  @param data
1329  Unused
1330  @param addon
1331  Unused
1332
1333  @return
1334  - true when an error is detected
1335  - false otherwise
1336  */
1337 int setUplinkUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
1338                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1339         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_NAME;
1340         unsigned long long uplinkUpdateIntervalStationaryNew;
1341
1342         assert (value != NULL);
1343
1344         if (!readULL(valueName, value, &uplinkUpdateIntervalStationaryNew)) {
1345                 return true;
1346         }
1347
1348         if (uplinkUpdateIntervalStationaryNew < 1) {
1349                 pudError(false, "Configured %s must be at least 1", valueName);
1350                 return true;
1351         }
1352
1353         uplinkUpdateIntervalStationary = uplinkUpdateIntervalStationaryNew;
1354
1355         return false;
1356 }
1357
1358 /*
1359  * uplinkUpdateIntervalMoving
1360  */
1361
1362 /** The uplink moving interval update plugin parameter (in seconds) */
1363 static unsigned long long uplinkUpdateIntervalMoving = PUD_UPLINK_UPDATE_INTERVAL_MOVING_DEFAULT;
1364
1365 /**
1366  @return
1367  The uplink moving interval update plugin parameter (in seconds)
1368  */
1369 unsigned long long getUplinkUpdateIntervalMoving(void) {
1370         return uplinkUpdateIntervalMoving;
1371 }
1372
1373 /**
1374  Set uplink moving interval update plugin parameter
1375
1376  @param value
1377  The uplink moving interval update plugin parameter (in seconds)
1378  @param data
1379  Unused
1380  @param addon
1381  Unused
1382
1383  @return
1384  - true when an error is detected
1385  - false otherwise
1386  */
1387 int setUplinkUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
1388                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1389         static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_MOVING_NAME;
1390         unsigned long long uplinkUpdateIntervalMovingNew;
1391
1392         assert (value != NULL);
1393
1394         if (!readULL(valueName, value, &uplinkUpdateIntervalMovingNew)) {
1395                 return true;
1396         }
1397
1398         if (uplinkUpdateIntervalMovingNew < 1) {
1399                 pudError(false, "Configured %s must be at least 1", valueName);
1400                 return true;
1401         }
1402
1403         uplinkUpdateIntervalMoving = uplinkUpdateIntervalMovingNew;
1404
1405         return false;
1406 }
1407
1408 /*
1409  * gatewayDeterminationInterval
1410  */
1411
1412 /** The gateway determination interval plugin parameter (in seconds) */
1413 static unsigned long long gatewayDeterminationInterval = PUD_GATEWAY_DETERMINATION_INTERVAL_DEFAULT;
1414
1415 /**
1416  @return
1417  The gateway determination interval plugin parameter (in seconds)
1418  */
1419 unsigned long long getGatewayDeterminationInterval(void) {
1420         return gatewayDeterminationInterval;
1421 }
1422
1423 /**
1424  Set gateway determination interval plugin parameter
1425
1426  @param value
1427  The gateway determination interval plugin parameter (in seconds)
1428  @param data
1429  Unused
1430  @param addon
1431  Unused
1432
1433  @return
1434  - true when an error is detected
1435  - false otherwise
1436  */
1437 int setGatewayDeterminationInterval(const char *value, void *data __attribute__ ((unused)),
1438                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1439         static const char * valueName = PUD_GATEWAY_DETERMINATION_INTERVAL_NAME;
1440         unsigned long long gatewayDeterminationIntervalNew;
1441
1442         assert (value != NULL);
1443
1444         if (!readULL(valueName, value, &gatewayDeterminationIntervalNew)) {
1445                 return true;
1446         }
1447
1448         if (gatewayDeterminationIntervalNew < 1) {
1449                 pudError(false, "Configured %s must be at least 1", valueName);
1450                 return true;
1451         }
1452
1453         gatewayDeterminationInterval = gatewayDeterminationIntervalNew;
1454
1455         return false;
1456 }
1457
1458 /*
1459  * movingSpeedThreshold
1460  */
1461
1462 /** The moving speed threshold plugin parameter (in kph) */
1463 static unsigned long long movingSpeedThreshold = PUD_MOVING_SPEED_THRESHOLD_DEFAULT;
1464
1465 /**
1466  @return
1467  The moving speed threshold plugin parameter (in kph)
1468  */
1469 unsigned long long getMovingSpeedThreshold(void) {
1470         return movingSpeedThreshold;
1471 }
1472
1473 /**
1474  Set moving speed threshold plugin parameter
1475
1476  @param value
1477  The moving speed threshold plugin parameter (in kph)
1478  @param data
1479  Unused
1480  @param addon
1481  Unused
1482
1483  @return
1484  - true when an error is detected
1485  - false otherwise
1486  */
1487 int setMovingSpeedThreshold(const char *value, void *data __attribute__ ((unused)),
1488                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1489         static const char * valueName = PUD_MOVING_SPEED_THRESHOLD_NAME;
1490         unsigned long long movingSpeedThresholdNew;
1491
1492         assert (value != NULL);
1493
1494         if (!readULL(valueName, value, &movingSpeedThresholdNew)) {
1495                 return true;
1496         }
1497
1498         movingSpeedThreshold = movingSpeedThresholdNew;
1499
1500         return false;
1501 }
1502
1503 /*
1504  * movingDistanceThreshold
1505  */
1506
1507 /** The moving distance threshold plugin parameter (in meters) */
1508 static unsigned long long movingDistanceThreshold = PUD_MOVING_DISTANCE_THRESHOLD_DEFAULT;
1509
1510 /**
1511  @return
1512  The moving distance threshold plugin parameter (in meters)
1513  */
1514 unsigned long long getMovingDistanceThreshold(void) {
1515         return movingDistanceThreshold;
1516 }
1517
1518 /**
1519  Set moving distance threshold plugin parameter
1520
1521  @param value
1522  The moving distance threshold plugin parameter (in meter)
1523  @param data
1524  Unused
1525  @param addon
1526  Unused
1527
1528  @return
1529  - true when an error is detected
1530  - false otherwise
1531  */
1532 int setMovingDistanceThreshold(const char *value, void *data __attribute__ ((unused)),
1533                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1534         static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
1535         unsigned long long movingDistanceThresholdNew;
1536
1537         assert (value != NULL);
1538
1539         if (!readULL(valueName, value, &movingDistanceThresholdNew)) {
1540                 return true;
1541         }
1542
1543         movingDistanceThreshold = movingDistanceThresholdNew;
1544
1545         return false;
1546 }
1547
1548 /*
1549  * dopMultiplier
1550  */
1551
1552 /* The DOP multiplier plugin parameter */
1553 static double dopMultiplier = PUD_DOP_MULTIPLIER_DEFAULT;
1554
1555 /**
1556  @return
1557  The DOP multiplier plugin parameter
1558  */
1559 double getDopMultiplier(void) {
1560         return dopMultiplier;
1561 }
1562
1563 /**
1564  Set DOP multiplier plugin parameter
1565
1566  @param value
1567  The DOP multiplier plugin parameter
1568  @param data
1569  Unused
1570  @param addon
1571  Unused
1572
1573  @return
1574  - true when an error is detected
1575  - false otherwise
1576  */
1577 int setDopMultiplier(const char *value, void *data __attribute__ ((unused)),
1578                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1579         static const char * valueName = PUD_DOP_MULTIPLIER_NAME;
1580         double dopMultiplierNew;
1581
1582         assert (value != NULL);
1583
1584         if (!readDouble(valueName, value, &dopMultiplierNew)) {
1585                 return true;
1586         }
1587
1588         dopMultiplier = dopMultiplierNew;
1589
1590         return false;
1591 }
1592
1593 /*
1594  * defaultHdop
1595  */
1596
1597 /** The default HDOP plugin parameter (in meters) */
1598 static unsigned long long defaultHdop = PUD_DEFAULT_HDOP_DEFAULT;
1599
1600 /**
1601  @return
1602  The default HDOP plugin parameter (in meters)
1603  */
1604 unsigned long long getDefaultHdop(void) {
1605         return defaultHdop;
1606 }
1607
1608 /**
1609  Set default HDOP plugin parameter
1610
1611  @param value
1612  The default HDOP plugin parameter (in meters)
1613  @param data
1614  Unused
1615  @param addon
1616  Unused
1617
1618  @return
1619  - true when an error is detected
1620  - false otherwise
1621  */
1622 int setDefaultHdop(const char *value, void *data __attribute__ ((unused)),
1623                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1624         static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
1625         unsigned long long defaultHdopNew;
1626
1627         assert (value != NULL);
1628
1629         if (!readULL(valueName, value, &defaultHdopNew)) {
1630                 return true;
1631         }
1632
1633         defaultHdop = defaultHdopNew;
1634
1635         return false;
1636 }
1637
1638 /*
1639  * defaultVdop
1640  */
1641
1642 /** The default VDOP plugin parameter (in meters) */
1643 static unsigned long long defaultVdop = PUD_DEFAULT_VDOP_DEFAULT;
1644
1645 /**
1646  @return
1647  The default VDOP plugin parameter (in meters)
1648  */
1649 unsigned long long getDefaultVdop(void) {
1650         return defaultVdop;
1651 }
1652
1653 /**
1654  Set default VDOP plugin parameter
1655
1656  @param value
1657  The default VDOP plugin parameter (in meters)
1658  @param data
1659  Unused
1660  @param addon
1661  Unused
1662
1663  @return
1664  - true when an error is detected
1665  - false otherwise
1666  */
1667 int setDefaultVdop(const char *value, void *data __attribute__ ((unused)),
1668                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1669         static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
1670         unsigned long long defaultVdopNew;
1671
1672         assert (value != NULL);
1673
1674         if (!readULL(valueName, value, &defaultVdopNew)) {
1675                 return true;
1676         }
1677
1678         defaultVdop = defaultVdopNew;
1679
1680         return false;
1681 }
1682
1683 /*
1684  * averageDepth
1685  */
1686
1687 /** The depth of the average list */
1688 static unsigned long long averageDepth = PUD_AVERAGE_DEPTH_DEFAULT;
1689
1690 /**
1691  @return
1692  The depth of the average list
1693  */
1694 unsigned long long getAverageDepth(void) {
1695         return averageDepth;
1696 }
1697
1698 /**
1699  Set average depth plugin parameter
1700
1701  @param value
1702  The average depth plugin parameter
1703  @param data
1704  Unused
1705  @param addon
1706  Unused
1707
1708  @return
1709  - true when an error is detected
1710  - false otherwise
1711  */
1712 int setAverageDepth(const char *value, void *data __attribute__ ((unused)),
1713                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1714         static const char * valueName = PUD_AVERAGE_DEPTH_NAME;
1715         unsigned long long averageDepthNew;
1716
1717         assert (value != NULL);
1718
1719         if (!readULL(valueName, value, &averageDepthNew)) {
1720                 return true;
1721         }
1722
1723         if (averageDepthNew < 1) {
1724                 pudError(false, "Configured %s must be at least 1", valueName);
1725                 return true;
1726         }
1727
1728         averageDepth = averageDepthNew;
1729
1730         return false;
1731 }
1732
1733 /*
1734  * hysteresisCountToStationary
1735  */
1736
1737 /** The hysteresis count for changing state from moving to stationary */
1738 static unsigned long long hysteresisCountToStationary = PUD_HYSTERESIS_COUNT_2STAT_DEFAULT;
1739
1740 /**
1741  @return
1742  The hysteresis count for changing state from moving to stationary
1743  */
1744 unsigned long long getHysteresisCountToStationary(void) {
1745         return hysteresisCountToStationary;
1746 }
1747
1748 /**
1749  Set hysteresis count plugin parameter
1750
1751  @param value
1752  The hysteresis count plugin parameter
1753  @param data
1754  Unused
1755  @param addon
1756  Unused
1757
1758  @return
1759  - true when an error is detected
1760  - false otherwise
1761  */
1762 int setHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1763                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1764         static const char * valueName = PUD_HYSTERESIS_COUNT_2STAT_NAME;
1765         unsigned long long hysteresisCountNew;
1766
1767         assert (value != NULL);
1768
1769         if (!readULL(valueName, value, &hysteresisCountNew)) {
1770                 return true;
1771         }
1772
1773         hysteresisCountToStationary = hysteresisCountNew;
1774
1775         return false;
1776 }
1777
1778 /*
1779  * hysteresisCountToMoving
1780  */
1781
1782 /** The hysteresis count for changing state from stationary to moving */
1783 static unsigned long long hysteresisCountToMoving = PUD_HYSTERESIS_COUNT_2MOV_DEFAULT;
1784
1785 /**
1786  @return
1787  The hysteresis count for changing state from stationary to moving
1788  */
1789 unsigned long long getHysteresisCountToMoving(void) {
1790         return hysteresisCountToMoving;
1791 }
1792
1793 /**
1794  Set hysteresis count plugin parameter
1795
1796  @param value
1797  The hysteresis count plugin parameter
1798  @param data
1799  Unused
1800  @param addon
1801  Unused
1802
1803  @return
1804  - true when an error is detected
1805  - false otherwise
1806  */
1807 int setHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1808                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1809         static const char * valueName = PUD_HYSTERESIS_COUNT_2MOV_NAME;
1810         unsigned long long hysteresisCountNew;
1811
1812         assert (value != NULL);
1813
1814         if (!readULL(valueName, value, &hysteresisCountNew)) {
1815                 return true;
1816         }
1817
1818         hysteresisCountToMoving = hysteresisCountNew;
1819
1820         return false;
1821 }
1822
1823 /*
1824  * gatewayHysteresisCountToStationary
1825  */
1826
1827 /** The hysteresis count for changing state from moving to stationary */
1828 static unsigned long long gatewayHysteresisCountToStationary = PUD_GAT_HYSTERESIS_COUNT_2STAT_DEFAULT;
1829
1830 /**
1831  @return
1832  The hysteresis count for changing state from moving to stationary
1833  */
1834 unsigned long long getGatewayHysteresisCountToStationary(void) {
1835         return gatewayHysteresisCountToStationary;
1836 }
1837
1838 /**
1839  Set hysteresis count plugin parameter
1840
1841  @param value
1842  The hysteresis count plugin parameter
1843  @param data
1844  Unused
1845  @param addon
1846  Unused
1847
1848  @return
1849  - true when an error is detected
1850  - false otherwise
1851  */
1852 int setGatewayHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
1853                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1854         static const char * valueName = PUD_GAT_HYSTERESIS_COUNT_2STAT_NAME;
1855         unsigned long long hysteresisCountNew;
1856
1857         assert (value != NULL);
1858
1859         if (!readULL(valueName, value, &hysteresisCountNew)) {
1860                 return true;
1861         }
1862
1863         gatewayHysteresisCountToStationary = hysteresisCountNew;
1864
1865         return false;
1866 }
1867
1868 /*
1869  * gatewayHysteresisCountToMoving
1870  */
1871
1872 /** The hysteresis count for changing state from stationary to moving */
1873 static unsigned long long gatewayHysteresisCountToMoving = PUD_GAT_HYSTERESIS_COUNT_2MOV_DEFAULT;
1874
1875 /**
1876  @return
1877  The hysteresis count for changing state from stationary to moving
1878  */
1879 unsigned long long getGatewayHysteresisCountToMoving(void) {
1880         return gatewayHysteresisCountToMoving;
1881 }
1882
1883 /**
1884  Set hysteresis count plugin parameter
1885
1886  @param value
1887  The hysteresis count plugin parameter
1888  @param data
1889  Unused
1890  @param addon
1891  Unused
1892
1893  @return
1894  - true when an error is detected
1895  - false otherwise
1896  */
1897 int setGatewayHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
1898                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1899         static const char * valueName = PUD_GAT_HYSTERESIS_COUNT_2MOV_NAME;
1900         unsigned long long hysteresisCountNew;
1901
1902         assert (value != NULL);
1903
1904         if (!readULL(valueName, value, &hysteresisCountNew)) {
1905                 return true;
1906         }
1907
1908         gatewayHysteresisCountToMoving = hysteresisCountNew;
1909
1910         return false;
1911 }
1912
1913 /*
1914  * useDeDup
1915  */
1916
1917 /* when true then duplicate message detection is performed */
1918 static bool useDeDup = PUD_USE_DEDUP_DEFAULT;
1919
1920 /**
1921  @return
1922  The duplicate message detection setting
1923  */
1924 bool getUseDeDup(void) {
1925         return useDeDup;
1926 }
1927
1928 /**
1929  Set duplicate message detection setting plugin parameter
1930
1931  @param value
1932  The duplicate message detection setting plugin parameter
1933  @param data
1934  Unused
1935  @param addon
1936  Unused
1937
1938  @return
1939  - true when an error is detected
1940  - false otherwise
1941  */
1942 int setUseDeDup(const char *value, void *data __attribute__ ((unused)),
1943                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1944         return !readBool(PUD_USE_DEDUP_NAME, value, &useDeDup);
1945 }
1946
1947 /*
1948  * deDupDepth
1949  */
1950
1951 /** The hysteresis count for changing state from stationary to moving */
1952 static unsigned long long deDupDepth = PUD_DEDUP_DEPTH_DEFAULT;
1953
1954 /**
1955  @return
1956  The hysteresis count for changing state from stationary to moving
1957  */
1958 unsigned long long getDeDupDepth(void) {
1959         return deDupDepth;
1960 }
1961
1962 /**
1963  Set de-duplication depth plugin parameter
1964
1965  @param value
1966  The de-duplication depth plugin parameter
1967  @param data
1968  Unused
1969  @param addon
1970  Unused
1971
1972  @return
1973  - true when an error is detected
1974  - false otherwise
1975  */
1976 int setDeDupDepth(const char *value, void *data __attribute__ ((unused)),
1977                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
1978         static const char * valueName = PUD_DEDUP_DEPTH_NAME;
1979         unsigned long long deDupDepthNew;
1980
1981         assert (value != NULL);
1982
1983         if (!readULL(valueName, value, &deDupDepthNew)) {
1984                 return true;
1985         }
1986
1987         deDupDepth = deDupDepthNew;
1988
1989         return false;
1990 }
1991
1992 /*
1993  * useLoopback
1994  */
1995
1996 /* when true then loopback is performed */
1997 static bool useLoopback = PUD_USE_LOOPBACK_DEFAULT;
1998
1999 /**
2000  @return
2001  The loopback usage setting
2002  */
2003 bool getUseLoopback(void) {
2004         return useLoopback;
2005 }
2006
2007 /**
2008  Set loopback usage plugin parameter
2009
2010  @param value
2011  The loopback usage plugin parameter
2012  @param data
2013  Unused
2014  @param addon
2015  Unused
2016
2017  @return
2018  - true when an error is detected
2019  - false otherwise
2020  */
2021 int setUseLoopback(const char *value, void *data __attribute__ ((unused)),
2022                 set_plugin_parameter_addon addon __attribute__ ((unused))) {
2023         return !readBool(PUD_USE_LOOPBACK_NAME, value, &useLoopback);
2024 }
2025
2026 /*
2027  * Check Functions
2028  */
2029
2030 /**
2031  Check the configuration for consistency and validity.
2032
2033  @return
2034  - true when the configuration is consistent and valid
2035  - false otherwise
2036  */
2037 unsigned int checkConfig(void) {
2038         int retval = true;
2039
2040         if (!olsr_cnf->smart_gw_active) {
2041                 pudError(false, "Smart Gateway must be active");
2042                 retval = false;
2043         }
2044
2045         if (rxNonOlsrInterfaceCount == 0) {
2046                 pudError(false, "No receive non-OLSR interfaces configured");
2047                 retval = false;
2048         }
2049
2050         if (txNonOlsrInterfaceCount == 0) {
2051                 pudError(false, "No transmit non-OLSR interfaces configured");
2052                 retval = false;
2053         }
2054
2055         if (!nodeIdSet) {
2056                 if (nodeIdType == PUD_NODEIDTYPE_DNS) {
2057                         char name[PUD_TX_NODEID_BUFFERSIZE + 1];
2058
2059                         errno = 0;
2060                         if (gethostname(&name[0], sizeof(name)) < 0) {
2061                                 pudError(true, "Could not get the host name");
2062                                 retval = false;
2063                         } else {
2064                                 setNodeId(&name[0], NULL,
2065                                                 (set_plugin_parameter_addon) {.pc = NULL});
2066                         }
2067                 } else if ((nodeIdType != PUD_NODEIDTYPE_MAC) && (nodeIdType
2068                                 != PUD_NODEIDTYPE_IPV4) && (nodeIdType != PUD_NODEIDTYPE_IPV6)) {
2069                         pudError(false, "No node ID set while one is required for"
2070                                 " node type %u", nodeIdType);
2071                         retval = false;
2072                 }
2073         }
2074
2075         if (!setupNodeIdBinaryAndValidate(nodeIdType)) {
2076                 retval = false;
2077         }
2078
2079         if (updateIntervalMoving > updateIntervalStationary) {
2080                 pudError(false,"The update interval for moving situations must not be"
2081                 " larger than that for stationary situations");
2082                 retval = false;
2083         }
2084
2085         if (uplinkUpdateIntervalMoving > uplinkUpdateIntervalStationary) {
2086                 pudError(false,"The uplink update interval for moving situations must not be"
2087                 " larger than that for stationary situations");
2088                 retval = false;
2089         }
2090
2091         if (getUplinkPort() == getDownlinkPort()) {
2092                 pudError(false, "The uplink port and the downlink port must not be the same");
2093                 retval = false;
2094         }
2095
2096         return retval;
2097 }
2098
2099 /**
2100  Check the configuration for consistency and validity after everything has been
2101  setup.
2102
2103  @return
2104  - true when the configuration is consistent and valid
2105  - false otherwise
2106  */
2107 unsigned int checkRunSetup(void) {
2108         int retval = true;
2109         unsigned int i;
2110
2111         /* any receive interface name that is configured but is not the name of an
2112          * actual receive interface is not a valid interface name */
2113         for (i = 0; i < rxNonOlsrInterfaceCount; i++) {
2114                 unsigned char * nonOlsrInterfaceName = &rxNonOlsrInterfaceNames[i][0];
2115
2116                 TRxTxNetworkInterface * interfaceObject = getRxNetworkInterfaces();
2117                 bool found = false;
2118                 while (interfaceObject != NULL) {
2119                         if (strncmp((char *) nonOlsrInterfaceName,
2120                                         (char *) &interfaceObject->name[0], IFNAMSIZ + 1) == 0) {
2121                                 found = true;
2122                                 break;
2123                         }
2124                         interfaceObject = interfaceObject->next;
2125                 }
2126                 if (!found) {
2127                         pudError(false, "Configured receive non-OLSR interface %s is not"
2128                                 " a known interface name", nonOlsrInterfaceName);
2129                         retval = false;
2130                 }
2131         }
2132
2133         /* any transmit interface name that is configured but is not the name of an
2134          * actual transmit interface is not a valid interface name */
2135         for (i = 0; i < txNonOlsrInterfaceCount; i++) {
2136                 unsigned char * nonOlsrInterfaceName = &txNonOlsrInterfaceNames[i][0];
2137
2138                 TRxTxNetworkInterface * interfaceObject = getTxNetworkInterfaces();
2139                 bool found = false;
2140                 while (interfaceObject != NULL) {
2141                         if (strncmp((char *) nonOlsrInterfaceName,
2142                                         (char *) &interfaceObject->name[0], IFNAMSIZ + 1) == 0) {
2143                                 found = true;
2144                                 break;
2145                         }
2146                         interfaceObject = interfaceObject->next;
2147                 }
2148                 if (!found) {
2149                         pudError(false, "Configured transmit non-OLSR interface %s is not"
2150                                 " a known interface name", nonOlsrInterfaceName);
2151                         retval = false;
2152                 }
2153         }
2154
2155         return retval;
2156 }