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