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