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 setupNodeIdBinaryString(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 setupNodeIdBinaryString();
 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 }