pud: update nmealib to 2.0.0
[olsrd.git] / lib / pud / src / configuration.c
index 5dee933..4d07bf6 100644 (file)
@@ -9,13 +9,22 @@
 
 /* OLSR includes */
 #include <olsr_protocol.h>
+#include <olsr.h>
 
 /* System includes */
 #include <unistd.h>
-#include <nmea/util.h>
+#include <nmea/parse.h>
 #include <OlsrdPudWireFormat/nodeIdConversion.h>
 #include <limits.h>
 
+/* forward declarations */
+static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber);
+
+/*
+ * Note:
+ * Setters must return true when an error is detected, false otherwise
+ */
+
 /*
  * nodeIdType
  */
@@ -31,33 +40,15 @@ NodeIdType getNodeIdTypeNumber(void) {
        return nodeIdType;
 }
 
-/**
- Set the node ID type.
-
- @param value
- The value of the node ID type to set (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
-int setNodeIdType(const char *value, void *data __attribute__ ((unused)),
-               set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_NODE_ID_TYPE_NAME;
+static int setNodeIdType(const char *value, const char * valueName) {
        unsigned long long nodeIdTypeNew;
 
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &nodeIdTypeNew)) {
+       if (!readULL(valueName, value, &nodeIdTypeNew, 10)) {
                return true;
        }
 
        if (!isValidNodeIdType(nodeIdTypeNew)) {
-               pudError(false, "Configured %s (%llu) is reserved", valueName,
+               pudError(false, "Value in parameter %s (%llu) is reserved", valueName,
                                nodeIdTypeNew);
                return true;
        }
@@ -72,7 +63,7 @@ int setNodeIdType(const char *value, void *data __attribute__ ((unused)),
  */
 
 /** The nodeId buffer */
-static unsigned char nodeId[PUD_TX_NODEID_BUFFERSIZE + 1];
+static unsigned char nodeId[PUD_TX_NODEID_BUFFERSIZE];
 
 /** The length of the string in the nodeId buffer */
 static size_t nodeIdLength = 0;
@@ -83,14 +74,6 @@ static bool nodeIdSet = false;
 /** The nodeId as a binary representation, with status */
 static nodeIdBinaryType nodeIdBinary;
 
-/**
- @return
- The node ID
- */
-unsigned char * getNodeId(void) {
-       return getNodeIdWithLength(NULL);
-}
-
 /**
  Get the nodeId and its length
 
@@ -101,7 +84,7 @@ unsigned char * getNodeId(void) {
  @return
  The node ID
  */
-unsigned char * getNodeIdWithLength(size_t *length) {
+unsigned char * getNodeId(size_t *length) {
        if (!nodeIdSet) {
                setNodeId("", NULL, (set_plugin_parameter_addon) {.pc = NULL});
        }
@@ -127,39 +110,81 @@ nodeIdBinaryType * getNodeIdBinary(void) {
        return &nodeIdBinary;
 }
 
-/**
- Set the node ID.
-
- @param value
- The value of the node ID to set (in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setNodeId(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_NODE_ID_NAME;
        size_t valueLength;
+       char * number;
+       char * identification;
 
        assert (value != NULL);
 
-       valueLength = strlen(value);
-       if (valueLength > PUD_TX_NODEID_BUFFERSIZE) {
-               pudError(false, "Configured %s is too long, maximum length is"
-                       " %u, current length is %lu", valueName, PUD_TX_NODEID_BUFFERSIZE,
-                               (unsigned long) valueLength);
-               return true;
-       }
-
-       strcpy((char *) &nodeId[0], value);
-       nodeIdLength = valueLength;
-       nodeIdSet = true;
+  nodeId[0] = '\0';
+  nodeIdLength = 0;
+  nodeIdSet = false;
+  nodeIdBinary.set = false;
 
-       return false;
+       valueLength = strlen(value);
+  number = olsr_malloc(valueLength + 1, "setNodeId");
+  strcpy(number, value);
+
+  /* split "number,identification" */
+  identification = strchr(number, ',');
+  if (identification) {
+    *identification = '\0';
+    identification++;
+  }
+
+  /* parse number into nodeIdType (if present) */
+  valueLength = strlen(number);
+  if (valueLength && setNodeIdType(number, PUD_NODE_ID_NAME)) {
+    free(number);
+    return true;
+  }
+
+  /* copy identification into nodeId (if present) */
+  if (identification) {
+    valueLength = strlen(identification);
+    if (valueLength > (PUD_TX_NODEID_BUFFERSIZE - 1)) {
+      pudError(false, "Value in parameter %s is too long, maximum length is"
+        " %u, current length is %lu", PUD_NODE_ID_NAME, (PUD_TX_NODEID_BUFFERSIZE - 1),
+          (unsigned long) valueLength);
+      free(number);
+      return true;
+    }
+
+    if (valueLength) {
+      strcpy((char *) &nodeId[0], identification);
+      nodeIdLength = valueLength;
+      nodeIdSet = true;
+    }
+  }
+
+  free(number);
+
+  /* fill in automatic values */
+  if (!nodeIdSet) {
+    if (nodeIdType == PUD_NODEIDTYPE_DNS) {
+      memset(nodeId, 0, sizeof(nodeId));
+      errno = 0;
+      if (gethostname((char *)&nodeId[0], sizeof(nodeId) - 1) < 0) {
+        pudError(true, "Could not get the host name");
+        return true;
+      }
+
+      nodeIdLength = strlen((char *)nodeId);
+      nodeIdSet = true;
+    } else if ((nodeIdType != PUD_NODEIDTYPE_MAC) && (nodeIdType != PUD_NODEIDTYPE_IPV4)
+        && (nodeIdType != PUD_NODEIDTYPE_IPV6)) {
+      pudError(false, "No node ID set while one is required for nodeId type %u", nodeIdType);
+      return true;
+    }
+  }
+
+  if (!setupNodeIdBinaryAndValidate(nodeIdType)) {
+    pudError(false, "nodeId (type %u) is incorrectly configured", nodeIdType);
+    return true;
+  }
+
+  return false;
 }
 
 /*
@@ -199,19 +224,106 @@ static bool intSetupNodeIdBinaryMAC(void) {
  - false on failure
  */
 static bool intSetupNodeIdBinaryLongLong(unsigned long long min,
-               unsigned long long max, unsigned int bytes) {
-       unsigned long long longValue = 0;
-       if (!readULL(PUD_NODE_ID_NAME, (char *) getNodeId(), &longValue)) {
-               return false;
-       }
+    unsigned long long max, unsigned int bytes) {
+  unsigned long long longValue = 0;
+  if (!readULL(PUD_NODE_ID_NAME, (char *) getNodeId(NULL), &longValue, 10)) {
+    return false;
+  }
 
-       if ((longValue < min) || (longValue > max)) {
-               pudError(false, "%s value %llu is out of range [%llu,%llu]",
-                               PUD_NODE_ID_NAME, longValue, min, max);
-               return false;
-       }
+  if ((longValue < min) || (longValue > max)) {
+    pudError(false, "%s value %llu is out of range [%llu,%llu]",
+        PUD_NODE_ID_NAME, longValue, min, max);
+    return false;
+  }
+
+  return setupNodeIdBinaryLongLong(&nodeIdBinary, longValue, bytes);
+}
+
+/**
+ Validate whether the configured nodeId is valid w.r.t. the configured
+ nodeIdType, for types that fit in a double unsigned long long (128 bits) with
+ a certain split that defined by chars1
+
+ @param chars1
+ the number of characters of the first part
+ @param min1
+ the minimum value of the first part
+ @param max1
+ the maximum value of the first part
+ @param bytes1
+ the number of bytes of the first part in the buffer
+ @param min2
+ the minimum value of the second part
+ @param max2
+ the maximum value of the second part
+ @param bytes2
+ the number of bytes of the second part in the buffer
+ @param base
+ the base of the number conversion: 10 for decimal, 16 for hexadecimal
 
-       return setupNodeIdBinaryLongLong(&nodeIdBinary, longValue, bytes);
+ @return
+ - true when ok
+ - false on failure
+ */
+static bool intSetupNodeIdBinaryDoubleLongLong(
+    unsigned char * dst,
+    unsigned int chars1,
+    unsigned long long min1, unsigned long long max1,
+    unsigned int bytes1,
+               unsigned long long min2, unsigned long long max2,
+               unsigned int bytes2,
+               int base) {
+       unsigned long long longValue1 = 0;
+       unsigned long long longValue2 = 0;
+
+       unsigned char * node_id = getNodeId(NULL);
+       size_t node_id_len = strlen((char *)node_id);
+
+       assert(chars1 > 0);
+       assert(bytes1 > 0);
+       assert(bytes2 > 0);
+
+  /* part 1 */
+       if (node_id_len > 0) {
+    unsigned char first[chars1 + 1];
+    int cpylen = node_id_len < chars1 ? node_id_len : chars1;
+
+    memcpy(first, node_id, cpylen);
+    first[cpylen] = '\0';
+
+    if (!readULL(PUD_NODE_ID_NAME, (char *)first, &longValue1, base)) {
+      return false;
+    }
+
+    if ((longValue1 < min1) || (longValue1 > max1)) {
+      pudError(false, "First %u character(s) of %s value %llu are out of range [%llu,%llu]",
+          cpylen, PUD_NODE_ID_NAME, longValue1, min1, max1);
+      return false;
+    }
+       }
+
+  /* part 2 */
+       if (node_id_len > chars1) {
+    if (!readULL(PUD_NODE_ID_NAME, (char *)&node_id[chars1], &longValue2, base)) {
+      return false;
+    }
+
+    if ((longValue2 < min2) || (longValue2 > max2)) {
+      pudError(false, "Last %u character(s) of %s value %llu are out of range [%llu,%llu]",
+          (unsigned int)(node_id_len - chars1), PUD_NODE_ID_NAME, longValue2, min2, max2);
+      return false;
+    }
+  } else {
+    /* longvalue1 is the only value, so it is the least significant value:
+     * exchange the 2 values */
+    unsigned long long tmp = longValue1;
+    longValue1 = longValue2;
+    longValue2 = tmp;
+  }
+
+       return setupNodeIdBinaryDoubleLongLong(&nodeIdBinary,
+           longValue1, &dst[0], bytes1,
+           longValue2, &dst[bytes1], bytes2);
 }
 
 /**
@@ -223,24 +335,25 @@ static bool intSetupNodeIdBinaryLongLong(unsigned long long min,
  - false on failure
  */
 static bool intSetupNodeIdBinaryString(void) {
-       bool invalidChars;
-       char report[256];
-       size_t nodeidlength;
-       char * nodeid = (char *)getNodeIdWithLength(&nodeidlength);
-
-       invalidChars = nmea_string_has_invalid_chars(nodeid,
-                       PUD_NODE_ID_NAME, &report[0], sizeof(report));
-       if (invalidChars) {
-               pudError(false, "%s", &report[0]);
-               return false;
-       }
+  const char * invalidCharName;
+  size_t nodeidlength;
+  char * nodeid = (char *) getNodeId(&nodeidlength);
 
-       if (nodeidlength > PUD_TX_NODEID_BUFFERSIZE) {
-               pudError(false, "%s value \"%s\" is too long", PUD_NODE_ID_NAME, &nodeid[0]);
-               return false;
-       }
+  invalidCharName = nmea_parse_sentence_has_invalid_chars(nodeid, nodeidlength);
+  if (invalidCharName) {
+    char report[256];
+    snprintf(report, sizeof(report), "Configured %s (%s),"
+        " contains invalid NMEA characters (%s)", PUD_NODE_ID_NAME, nodeid, invalidCharName);
+    pudError(false, "%s", &report[0]);
+    return false;
+  }
 
-       return setupNodeIdBinaryString(&nodeIdBinary, nodeid, nodeidlength);
+  if (nodeidlength > (PUD_TX_NODEID_BUFFERSIZE - 1)) {
+    pudError(false, "Length of parameter %s (%s) is too great", PUD_NODE_ID_NAME, &nodeid[0]);
+    return false;
+  }
+
+  return setupNodeIdBinaryString(&nodeIdBinary, nodeid, nodeidlength);
 }
 
 /**
@@ -267,7 +380,7 @@ static bool intSetupNodeIdBinaryIp(void) {
 
 /**
  Validate whether the configured nodeId is valid w.r.t. the configured
- nodeIdType
+ nodeIdType and setup the binary value
 
  @return
  - true when ok
@@ -289,6 +402,20 @@ static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber) {
                case PUD_NODEIDTYPE_DNS: /* DNS name */
                        return intSetupNodeIdBinaryString();
 
+               case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
+               case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
+                       return intSetupNodeIdBinaryIp();
+
+               case PUD_NODEIDTYPE_UUID: /* a UUID number */
+                       return intSetupNodeIdBinaryDoubleLongLong(
+                           &nodeIdBinary.buffer.uuid[0],
+                           PUD_NODEIDTYPE_UUID_CHARS1,
+                           PUD_NODEIDTYPE_UUID_MIN1, PUD_NODEIDTYPE_UUID_MAX1,
+                           PUD_NODEIDTYPE_UUID_BYTES1,
+                           PUD_NODEIDTYPE_UUID_MIN2, PUD_NODEIDTYPE_UUID_MAX2,
+                           PUD_NODEIDTYPE_UUID_BYTES - PUD_NODEIDTYPE_UUID_BYTES1,
+                           16);
+
                case PUD_NODEIDTYPE_MMSI: /* an AIS MMSI number */
                        return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_MMSI_MIN,
                                PUD_NODEIDTYPE_MMSI_MAX, PUD_NODEIDTYPE_MMSI_BYTES);
@@ -297,6 +424,16 @@ static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber) {
                        return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_URN_MIN,
                                PUD_NODEIDTYPE_URN_MAX, PUD_NODEIDTYPE_URN_BYTES);
 
+               case PUD_NODEIDTYPE_MIP: /* a MIP OID number */
+                       return intSetupNodeIdBinaryDoubleLongLong(
+                           &nodeIdBinary.buffer.mip[0],
+                           PUD_NODEIDTYPE_MIP_CHARS1,
+                           PUD_NODEIDTYPE_MIP_MIN1, PUD_NODEIDTYPE_MIP_MAX1,
+                           PUD_NODEIDTYPE_MIP_BYTES1,
+                           PUD_NODEIDTYPE_MIP_MIN2, PUD_NODEIDTYPE_MIP_MAX2,
+                           PUD_NODEIDTYPE_MIP_BYTES - PUD_NODEIDTYPE_MIP_BYTES1,
+                           10);
+
                case PUD_NODEIDTYPE_192:
                        return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_192_MIN,
                                PUD_NODEIDTYPE_192_MAX, PUD_NODEIDTYPE_192_BYTES);
@@ -309,10 +446,9 @@ static bool setupNodeIdBinaryAndValidate(NodeIdType nodeIdTypeNumber) {
                        return intSetupNodeIdBinaryLongLong(PUD_NODEIDTYPE_194_MIN,
                                PUD_NODEIDTYPE_194_MAX, PUD_NODEIDTYPE_194_BYTES);
 
-               case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
-               case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
-               default: /* unsupported */
-                       return intSetupNodeIdBinaryIp();
+               default:
+                 pudError(false, "nodeId type %u is not supported", nodeIdTypeNumber);
+                 return false;
        }
 
        return false;
@@ -358,41 +494,27 @@ bool isRxNonOlsrInterface(const char *ifName) {
        return false;
 }
 
-/**
- Add a receive non-OLSR interface
-
- @param value
- The name of the non-OLSR interface to add
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int addRxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       unsigned long valueLength;
+       size_t valueLength;
+
+       if (rxNonOlsrInterfaceCount >= PUD_RX_NON_OLSR_IF_MAX) {
+               pudError(false, "Can't configure more than %u receive interfaces",
+                               PUD_RX_NON_OLSR_IF_MAX);
+               return true;
+       }
 
        assert (value != NULL);
 
        valueLength = strlen(value);
        if (valueLength > IFNAMSIZ) {
-               pudError(false, "Configured %s (%s) is too long,"
+               pudError(false, "Value of parameter %s (%s) is too long,"
                        " maximum length is %u, current length is %lu",
-                               PUD_RX_NON_OLSR_IF_NAME, value, IFNAMSIZ, valueLength);
+                               PUD_RX_NON_OLSR_IF_NAME, value, IFNAMSIZ, (long unsigned int)valueLength);
                return true;
        }
 
        if (!isRxNonOlsrInterface(value)) {
-               if (rxNonOlsrInterfaceCount >= PUD_RX_NON_OLSR_IF_MAX) {
-                       pudError(false, "Can't configure more than %u receive interfaces",
-                                       PUD_RX_NON_OLSR_IF_MAX);
-                       return true;
-               }
-
                strcpy((char *) &rxNonOlsrInterfaceNames[rxNonOlsrInterfaceCount][0],
                                value);
                rxNonOlsrInterfaceCount++;
@@ -401,6 +523,21 @@ int addRxNonOlsrInterface(const char *value, void *data __attribute__ ((unused))
        return false;
 }
 
+/**
+ * @return the number of configured non-olsr receive interfaces
+ */
+unsigned int getRxNonOlsrInterfaceCount(void) {
+       return rxNonOlsrInterfaceCount;
+}
+
+/**
+ * @param idx the index of the configured non-olsr receive interface
+ * @return the index-th interface name
+ */
+unsigned char * getRxNonOlsrInterfaceName(unsigned int idx) {
+       return &rxNonOlsrInterfaceNames[idx][0];
+}
+
 /*
  * rxAllowedSourceIpAddress
  */
@@ -458,28 +595,12 @@ bool isRxAllowedSourceIpAddress(union olsr_sockaddr * sender) {
        return false;
 }
 
-/**
- Set the RX allowed source IP addresses.
-
- @param value
- The RX allowed source IP address (in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int addRxAllowedSourceIpAddress(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_RX_ALLOWED_SOURCE_IP_NAME;
        union olsr_sockaddr addr;
        bool addrSet = false;
 
-       assert (value != NULL);
-
        if (rxAllowedSourceIpAddressesCount >= PUD_RX_ALLOWED_SOURCE_IP_MAX) {
                pudError(false, "Can't configure more than %u allowed source IP"
                        " addresses", PUD_RX_ALLOWED_SOURCE_IP_MAX);
@@ -499,7 +620,7 @@ int addRxAllowedSourceIpAddress(const char *value, void *data __attribute__ ((un
 }
 
 /*
- * rxMcAddr
+ * rxMcAddr + rxMcPort
  */
 
 /** The rx multicast address */
@@ -521,27 +642,9 @@ union olsr_sockaddr * getRxMcAddr(void) {
        return &rxMcAddr;
 }
 
-/**
- Set the receive multicast address. Sets the address to its default value when
- the value is NULL. Also sets the port to its default value when the address
- was not yet set.
-
- @param value
- The receive multicast address (in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setRxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_RX_MC_ADDR_NAME;
 
-       assert(value != NULL);
-
        if (!readIPAddress(valueName, value, PUD_RX_MC_PORT_DEFAULT, &rxMcAddr, &rxMcAddrSet)) {
                        return true;
        }
@@ -555,42 +658,17 @@ int setRxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plug
        return false;
 }
 
-/*
- * rxMcPort
- */
-
 /**
  @return
  The receive multicast port (in network byte order)
  */
 unsigned short getRxMcPort(void) {
-       in_port_t * port;
-       union olsr_sockaddr * sock = getRxMcAddr();
-       getOlsrSockaddrPortAddress(sock, &port);
-       return *port;
+       return getOlsrSockaddrPort(getRxMcAddr(), PUD_RX_MC_PORT_DEFAULT);
 }
 
-/**
- Set the receive multicast port
-
- @param value
- The receive multicast port (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setRxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_RX_MC_PORT_NAME;
        unsigned short rxMcPortNew;
-       in_port_t * port;
-       union olsr_sockaddr * addr = getRxMcAddr();
-
-       assert (value != NULL);
 
        if (!readUS(valueName, value, &rxMcPortNew)) {
                return true;
@@ -601,8 +679,7 @@ int setRxMcPort(const char *value, void *data __attribute__ ((unused)), set_plug
                return true;
        }
 
-       getOlsrSockaddrPortAddress(addr, &port);
-       *port = htons((uint16_t) rxMcPortNew);
+       setOlsrSockaddrPort(getRxMcAddr(), htons((in_port_t) rxMcPortNew));
 
        return false;
 }
@@ -629,11 +706,45 @@ char * getPositionFile(void) {
        return &positionFile[0];
 }
 
+int setPositionFile(const char *value, void *data __attribute__ ((unused)),
+               set_plugin_parameter_addon addon __attribute__ ((unused))) {
+       size_t valueLength;
+
+       assert(value != NULL);
+
+       valueLength = strlen(value);
+       if (valueLength > PATH_MAX) {
+               pudError(false, "Value of parameter %s is too long, maximum length is"
+                               " %u, current length is %lu", PUD_POSFILE_NAME, PATH_MAX, (unsigned long) valueLength);
+               return true;
+       }
+
+       strcpy((char *) &positionFile[0], value);
+       positionFileSet = true;
+
+       return false;
+}
+
+/*
+ * positionFilePeriod
+ */
+
+/** The positionFilePeriod value (milliseconds) */
+unsigned long long positionFilePeriod = PUD_POSFILEPERIOD_DEFAULT;
+
+/**
+ @return
+ The positionFilePeriod (in milliseconds)
+ */
+unsigned long long getPositionFilePeriod(void) {
+       return positionFilePeriod;
+}
+
 /**
- Set the positionFile.
+ Set the positionFilePeriod
 
  @param value
- The value of the positionFile to set (in string representation)
+ The positionFilePeriod (a number in string representation)
  @param data
  Unused
  @param addon
@@ -643,27 +754,25 @@ char * getPositionFile(void) {
  - true when an error is detected
  - false otherwise
  */
-int setPositionFile(const char *value, void *data __attribute__ ((unused)),
+int setPositionFilePeriod(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_POSFILE_NAME;
-       size_t valueLength;
+       static const char * valueName = PUD_POSFILEPERIOD_NAME;
+       unsigned long long positionFilePeriodNew;
 
        assert(value != NULL);
 
-       if (!startPositionFile()) {
-               stopPositionFile();
+       if (!readULL(valueName, value, &positionFilePeriodNew, 10)) {
                return true;
        }
 
-       valueLength = strlen(value);
-       if (valueLength > PATH_MAX) {
-               pudError(false, "Configured %s is too long, maximum length is"
-                               " %u, current length is %lu", valueName, PATH_MAX, (unsigned long) valueLength);
+       if ((positionFilePeriodNew != 0)
+                       && ((positionFilePeriodNew < PUD_POSFILEPERIOD_MIN) || (positionFilePeriodNew > PUD_POSFILEPERIOD_MAX))) {
+               pudError(false, "Configured %s (%llu) is outside of"
+                               " valid range %llu-%llu", valueName, positionFilePeriodNew, PUD_POSFILEPERIOD_MIN, PUD_POSFILEPERIOD_MAX);
                return true;
        }
 
-       strcpy((char *) &positionFile[0], value);
-       positionFileSet = true;
+       positionFilePeriod = positionFilePeriodNew;
 
        return false;
 }
@@ -672,7 +781,7 @@ int setPositionFile(const char *value, void *data __attribute__ ((unused)),
  * txNonOlsrIf
  */
 
-/** The maximum number of rx non-olsr interfaces */
+/** The maximum number of tx non-olsr interfaces */
 #define PUD_TX_NON_OLSR_IF_MAX 32
 
 /** Array with tx non-olsr interface names */
@@ -699,8 +808,7 @@ bool isTxNonOlsrInterface(const char *ifName) {
        assert (ifName != NULL);
 
        for (i = 0; i < txNonOlsrInterfaceCount; i++) {
-               if (strncmp((char *) &txNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ
-                               + 1) == 0) {
+               if (strncmp((char *) &txNonOlsrInterfaceNames[i][0], ifName, IFNAMSIZ + 1) == 0) {
                        return true;
                }
        }
@@ -708,51 +816,49 @@ bool isTxNonOlsrInterface(const char *ifName) {
        return false;
 }
 
-/**
- Add a transmit non-OLSR interface
-
- @param value
- The name of the non-OLSR interface to add
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int addTxNonOlsrInterface(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       unsigned long valueLength;
+       size_t valueLength;
 
        assert (value != NULL);
 
+       if (txNonOlsrInterfaceCount >= PUD_TX_NON_OLSR_IF_MAX) {
+               pudError(false, "Can not configure more than %u transmit interfaces", PUD_TX_NON_OLSR_IF_MAX);
+               return true;
+       }
+
        valueLength = strlen(value);
        if (valueLength > IFNAMSIZ) {
-               pudError(false, "Configured %s (%s) is too long,"
-                       " maximum length is %u, current length is %lu",
-                               PUD_TX_NON_OLSR_IF_NAME, value, IFNAMSIZ, valueLength);
+               pudError(false, "Value of parameter %s (%s) is too long, maximum length is %u, current length is %lu",
+                               PUD_TX_NON_OLSR_IF_NAME, value, IFNAMSIZ, (long unsigned int)valueLength);
                return true;
        }
 
        if (!isTxNonOlsrInterface(value)) {
-               if (txNonOlsrInterfaceCount >= PUD_TX_NON_OLSR_IF_MAX) {
-                       pudError(false, "Can not configure more than %u transmit"
-                               " interfaces", PUD_TX_NON_OLSR_IF_MAX);
-                       return true;
-               }
-
-               strcpy((char *) &txNonOlsrInterfaceNames[txNonOlsrInterfaceCount][0],
-                               value);
+               strcpy((char *) &txNonOlsrInterfaceNames[txNonOlsrInterfaceCount][0], value);
                txNonOlsrInterfaceCount++;
        }
 
        return false;
 }
 
+/**
+ * @return the number of configured non-olsr transmit interfaces
+ */
+unsigned int getTxNonOlsrInterfaceCount(void) {
+       return txNonOlsrInterfaceCount;
+}
+
+/**
+ * @param idx the index of the configured non-olsr transmit interface
+ * @return the index-th interface name
+ */
+unsigned char * getTxNonOlsrInterfaceName(unsigned int idx) {
+       return &txNonOlsrInterfaceNames[idx][0];
+}
+
 /*
- * txMcAddr
+ * txMcAddr + txMcPort
  */
 
 /** The tx multicast address */
@@ -774,27 +880,9 @@ union olsr_sockaddr * getTxMcAddr(void) {
        return &txMcAddr;
 }
 
-/**
- Set the transmit multicast address. Sets the address to its default value when
- the value is NULL. Also sets the port to its default value when the address
- was not yet set.
-
- @param value
- The transmit multicast address (in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setTxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_TX_MC_ADDR_NAME;
 
-       assert (value != NULL);
-
        if (!readIPAddress(valueName, value, PUD_TX_MC_PORT_DEFAULT, &txMcAddr, &txMcAddrSet)) {
                        return true;
        }
@@ -808,42 +896,17 @@ int setTxMcAddr(const char *value, void *data __attribute__ ((unused)), set_plug
        return false;
 }
 
-/*
- * txMcPort
- */
-
 /**
  @return
  The transmit multicast port (in network byte order)
  */
 unsigned short getTxMcPort(void) {
-       in_port_t * port;
-       union olsr_sockaddr * sock = getTxMcAddr();
-       getOlsrSockaddrPortAddress(sock, &port);
-       return *port;
+       return getOlsrSockaddrPort(getTxMcAddr(), PUD_TX_MC_PORT_DEFAULT);
 }
 
-/**
- Set the transmit multicast port
-
- @param value
- The transmit multicast port (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setTxMcPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_TX_MC_PORT_NAME;
        unsigned short txMcPortNew;
-       in_port_t * port;
-       union olsr_sockaddr * addr = getTxMcAddr();
-
-       assert (value != NULL);
 
        if (!readUS(valueName, value, &txMcPortNew)) {
                return true;
@@ -854,108 +917,149 @@ int setTxMcPort(const char *value, void *data __attribute__ ((unused)), set_plug
                return true;
        }
 
-       getOlsrSockaddrPortAddress(addr, &port);
-       *port = htons((uint16_t) txMcPortNew);
+       setOlsrSockaddrPort(getTxMcAddr(), htons((in_port_t) txMcPortNew));
 
        return false;
 }
 
 /*
- * uplinkAddr
+ * txTtl
  */
 
-/** The uplink address */
-static union olsr_sockaddr uplinkAddr;
-
-/** True when the uplink address is set */
-static bool uplinkAddrSet = false;
+/** The tx TTL */
+static unsigned char txTtl = PUD_TX_TTL_DEFAULT;
 
 /**
  @return
- - true when the uplink address is set
- - false otherwise
+ The transmit multicast IP packet time-to-live
  */
-bool isUplinkAddrSet(void) {
-       return uplinkAddrSet;
+unsigned char getTxTtl(void) {
+       return txTtl;
 }
 
-/**
- @return
- The uplink address (in network byte order). Sets both the address
- and the port to their default values when the address was not yet set.
- */
-union olsr_sockaddr * getUplinkAddr(void) {
-       if (!uplinkAddrSet) {
-               setUplinkAddr((olsr_cnf->ip_version == AF_INET) ? PUD_UPLINK_ADDR_4_DEFAULT : PUD_UPLINK_ADDR_6_DEFAULT,
-                               NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
+int setTxTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
+       static const char * valueName = PUD_TX_TTL_NAME;
+
+       if (!readUC(valueName, value, &txTtl)) {
+               return true;
        }
-       return &uplinkAddr;
+
+       if ((txTtl < 1) /* || (txTtl > MAX_TTL) */) {
+               pudError(false, "Value of parameter %s (%u) is outside of"
+                       " valid range 1-%u", valueName, txTtl, MAX_TTL);
+               return true;
+       }
+
+       return false;
 }
 
-/**
- Set the uplink address. Sets the address to its default value when
- the value is NULL. Also sets the port to its default value when the address
- was not yet set.
+/*
+ * txNmeaMessagePrefix
+ */
 
- @param value
- The uplink address (in string representation)
- @param data
- Unused
- @param addon
- Unused
+/** The exact length of the tx NMEA message prefix */
+#define PUD_TXNMEAMESSAGEPREFIXLENGTH 4
+
+/** The tx NMEA message prefix buffer */
+static unsigned char txNmeaMessagePrefix[PUD_TXNMEAMESSAGEPREFIXLENGTH + 1];
 
+/** True when the tx NMEA message prefix is set */
+static bool txNmeaMessagePrefixSet = false;
+
+/**
  @return
- - true when an error is detected
- - false otherwise
+ The transmit multicast NMEA message prefix
  */
-int setUplinkAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_UPLINK_ADDR_NAME;
+unsigned char * getTxNmeaMessagePrefix(void) {
+       if (!txNmeaMessagePrefixSet) {
+               setTxNmeaMessagePrefix(PUD_TX_NMEAMESSAGEPREFIX_DEFAULT, NULL,
+                               (set_plugin_parameter_addon) {.pc = NULL});
+       }
+       return &txNmeaMessagePrefix[0];
+}
+
+int setTxNmeaMessagePrefix(const char *value, void *data __attribute__ ((unused)),
+               set_plugin_parameter_addon addon __attribute__ ((unused))) {
+       const char * invalidCharName;
+       static const char * valueName = PUD_TX_NMEAMESSAGEPREFIX_NAME;
+       size_t valueLength;
 
        assert (value != NULL);
 
-       if (!readIPAddress(valueName, value, PUD_UPLINK_PORT_DEFAULT, &uplinkAddr, &uplinkAddrSet)) {
-                       return true;
+       valueLength = strlen(value);
+       if (valueLength != PUD_TXNMEAMESSAGEPREFIXLENGTH) {
+               pudError(false, "Length of parameter %s (%s) must be exactly %u characters",
+                               valueName, value, PUD_TXNMEAMESSAGEPREFIXLENGTH);
+               return true;
        }
 
+  invalidCharName = nmea_parse_sentence_has_invalid_chars(value, valueLength);
+  if (invalidCharName) {
+    char report[256];
+    snprintf(report, sizeof(report), "Configured %s (%s),"
+        " contains invalid NMEA characters (%s)", valueName, value, invalidCharName);
+    pudError(false, "%s", report);
+    return true;
+  }
+
+       if ((strchr(value, ' ') != NULL) || (strchr(value, '\t') != NULL)) {
+               pudError(false, "Value of parameter %s (%s) can not contain whitespace",
+                               valueName, value);
+               return true;
+       }
+
+       strcpy((char *) &txNmeaMessagePrefix[0], value);
+       txNmeaMessagePrefixSet = true;
        return false;
 }
 
 /*
- * uplinkPort
+ * uplinkAddr + uplinkPort
  */
 
+/** The uplink address */
+static union olsr_sockaddr uplinkAddr;
+
+/** True when the uplink address is set */
+static bool uplinkAddrSet = false;
+
 /**
  @return
- The uplink port (in network byte order)
+ - true when the uplink address is set
+ - false otherwise
  */
-unsigned short getUplinkPort(void) {
-       in_port_t * port;
-       union olsr_sockaddr * addr = getUplinkAddr();
-       getOlsrSockaddrPortAddress(addr, &port);
-       return *port;
+bool isUplinkAddrSet(void) {
+       return uplinkAddrSet;
 }
 
 /**
- Set the uplink port
+ @return
+ The uplink address (in network byte order). Sets both the address
+ and the port to their default values when the address was not yet set.
+ */
+union olsr_sockaddr * getUplinkAddr(void) {
+       if (!uplinkAddrSet) {
+               setUplinkAddr((olsr_cnf->ip_version == AF_INET) ? PUD_UPLINK_ADDR_4_DEFAULT : PUD_UPLINK_ADDR_6_DEFAULT,
+                               NULL, ((set_plugin_parameter_addon) {.pc = NULL}));
+       }
+       return &uplinkAddr;
+}
 
- @param value
- The uplink port (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
+int setUplinkAddr(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
+       return !readIPAddress(PUD_UPLINK_ADDR_NAME, value, PUD_UPLINK_PORT_DEFAULT, &uplinkAddr, &uplinkAddrSet);
+}
 
+/**
  @return
- - true when an error is detected
- - false otherwise
+ The uplink port (in network byte order)
  */
+unsigned short getUplinkPort(void) {
+       return getOlsrSockaddrPort(getUplinkAddr(), PUD_UPLINK_PORT_DEFAULT);
+}
+
 int setUplinkPort(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_UPLINK_PORT_NAME;
        unsigned short uplinkPortNew;
-       in_port_t * port;
-       union olsr_sockaddr * addr = getUplinkAddr();
-
-       assert (value != NULL);
 
        if (!readUS(valueName, value, &uplinkPortNew)) {
                return true;
@@ -966,13 +1070,11 @@ int setUplinkPort(const char *value, void *data __attribute__ ((unused)), set_pl
                return true;
        }
 
-       getOlsrSockaddrPortAddress(addr, &port);
-       *port = htons((uint16_t) uplinkPortNew);
+       setOlsrSockaddrPort(getUplinkAddr(), htons((in_port_t) uplinkPortNew));
 
        return false;
 }
 
-
 /*
  * downlinkPort
  */
@@ -996,27 +1098,11 @@ unsigned short getDownlinkPort(void) {
        return downlinkPort;
 }
 
-/**
- Set the downlink port
-
- @param value
- The downlink port (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setDownlinkPort(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_DOWNLINK_PORT_NAME;
        unsigned short downlinkPortNew;
 
-       assert(value != NULL);
-
        if (!readUS(valueName, value, &downlinkPortNew)) {
                return true;
        }
@@ -1032,129 +1118,6 @@ int setDownlinkPort(const char *value, void *data __attribute__ ((unused)),
        return false;
 }
 
-/*
- * txTtl
- */
-
-/** The tx TTL */
-static unsigned char txTtl = PUD_TX_TTL_DEFAULT;
-
-/**
- @return
- The transmit multicast IP packet time-to-live
- */
-unsigned char getTxTtl(void) {
-       return txTtl;
-}
-
-/**
- Set the transmit multicast IP packet time-to-live
-
- @param value
- The transmit multicast IP packet time-to-live (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
-int setTxTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_TX_TTL_NAME;
-       unsigned long long txTtlNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &txTtlNew)) {
-               return true;
-       }
-
-       if ((txTtlNew < 1) || (txTtlNew > MAX_TTL)) {
-               pudError(false, "Configured %s (%llu) is outside of"
-                       " valid range 1-%u", valueName, txTtlNew, MAX_TTL);
-               return true;
-       }
-
-       txTtl = txTtlNew;
-
-       return false;
-}
-
-/*
- * txNmeaMessagePrefix
- */
-
-/** The exact length of the tx NMEA message prefix */
-#define PUD_TXNMEAMESSAGEPREFIXLENGTH 4
-
-/** The tx NMEA message prefix buffer */
-static unsigned char txNmeaMessagePrefix[PUD_TXNMEAMESSAGEPREFIXLENGTH + 1];
-
-/** True when the tx NMEA message prefix is set */
-static bool txNmeaMessagePrefixSet = false;
-
-/**
- @return
- The transmit multicast NMEA message prefix
- */
-unsigned char * getTxNmeaMessagePrefix(void) {
-       if (!txNmeaMessagePrefixSet) {
-               setTxNmeaMessagePrefix(PUD_TX_NMEAMESSAGEPREFIX_DEFAULT, NULL,
-                               (set_plugin_parameter_addon) {.pc = NULL});
-       }
-       return &txNmeaMessagePrefix[0];
-}
-
-/**
- Set the transmit multicast NMEA message prefix
-
- @param value
- The transmit multicast NMEA message prefix (in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
-int setTxNmeaMessagePrefix(const char *value, void *data __attribute__ ((unused)),
-               set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_TX_NMEAMESSAGEPREFIX_NAME;
-       size_t valueLength;
-       bool invalidChars;
-       char report[256];
-
-       assert (value != NULL);
-
-       valueLength = strlen(value);
-       if (valueLength != PUD_TXNMEAMESSAGEPREFIXLENGTH) {
-               pudError(false, "Configured %s (%s) must be %u exactly characters",
-                               valueName, value, PUD_TXNMEAMESSAGEPREFIXLENGTH);
-               return true;
-       }
-
-       invalidChars = nmea_string_has_invalid_chars(value, valueName, &report[0],
-                       sizeof(report));
-       if (invalidChars) {
-               pudError(false, "%s", &report[0]);
-               return true;
-       }
-
-       if ((strchr(value, ' ') != NULL) || (strchr(value, '\t') != NULL)) {
-               pudError(false, "Configured %s (%s) can not contain whitespace",
-                               valueName, value);
-               return true;
-       }
-
-       strcpy((char *) &txNmeaMessagePrefix[0], value);
-       txNmeaMessagePrefixSet = true;
-       return false;
-}
-
 /*
  * olsrTtl
  */
@@ -1170,38 +1133,19 @@ unsigned char getOlsrTtl(void) {
        return olsrTtl;
 }
 
-/**
- Set the OLSR multicast IP packet time-to-live
-
- @param value
- The OLSR multicast IP packet time-to-live (a number in string representation)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setOlsrTtl(const char *value, void *data __attribute__ ((unused)), set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_OLSR_TTL_NAME;
-       unsigned long long olsrTtlNew;
 
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &olsrTtlNew)) {
+       if (!readUC(valueName, value, &olsrTtl)) {
                return true;
        }
 
-       if ((olsrTtlNew < 1) || (olsrTtlNew > MAX_TTL)) {
-               pudError(false, "Configured %s (%llu) is outside of valid range 1-%u",
-                               valueName, olsrTtlNew, MAX_TTL);
+       if ((olsrTtl < 1) /* || (olsrTtl > MAX_TTL) */) {
+               pudError(false, "Value of parameter %s (%u) is outside of valid range 1-%u",
+                               valueName, olsrTtl, MAX_TTL);
                return true;
        }
 
-       olsrTtl = olsrTtlNew;
-
        return false;
 }
 
@@ -1220,38 +1164,19 @@ unsigned long long getUpdateIntervalStationary(void) {
        return updateIntervalStationary;
 }
 
-/**
- Set stationary interval update plugin parameter
-
- @param value
- The stationary interval update plugin parameter (in seconds)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_UPDATE_INTERVAL_STATIONARY_NAME;
-       unsigned long long updateIntervalStationaryNew;
-
-       assert (value != NULL);
 
-       if (!readULL(valueName, value, &updateIntervalStationaryNew)) {
+       if (!readULL(valueName, value, &updateIntervalStationary, 10)) {
                return true;
        }
 
-       if (updateIntervalStationaryNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (updateIntervalStationary < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       updateIntervalStationary = updateIntervalStationaryNew;
-
        return false;
 }
 
@@ -1270,38 +1195,19 @@ unsigned long long getUpdateIntervalMoving(void) {
        return updateIntervalMoving;
 }
 
-/**
- Set moving interval update plugin parameter
-
- @param value
- The moving interval update plugin parameter (in seconds)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_UPDATE_INTERVAL_MOVING_NAME;
-       unsigned long long updateIntervalMovingNew;
-
-       assert (value != NULL);
 
-       if (!readULL(valueName, value, &updateIntervalMovingNew)) {
+       if (!readULL(valueName, value, &updateIntervalMoving, 10)) {
                return true;
        }
 
-       if (updateIntervalMovingNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (updateIntervalMoving < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       updateIntervalMoving = updateIntervalMovingNew;
-
        return false;
 }
 
@@ -1320,38 +1226,19 @@ unsigned long long getUplinkUpdateIntervalStationary(void) {
        return uplinkUpdateIntervalStationary;
 }
 
-/**
- Set uplink stationary interval update plugin parameter
-
- @param value
- The uplink stationary interval update plugin parameter (in seconds)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUplinkUpdateIntervalStationary(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_STATIONARY_NAME;
-       unsigned long long uplinkUpdateIntervalStationaryNew;
 
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &uplinkUpdateIntervalStationaryNew)) {
+       if (!readULL(valueName, value, &uplinkUpdateIntervalStationary, 10)) {
                return true;
        }
 
-       if (uplinkUpdateIntervalStationaryNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (uplinkUpdateIntervalStationary < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       uplinkUpdateIntervalStationary = uplinkUpdateIntervalStationaryNew;
-
        return false;
 }
 
@@ -1370,38 +1257,19 @@ unsigned long long getUplinkUpdateIntervalMoving(void) {
        return uplinkUpdateIntervalMoving;
 }
 
-/**
- Set uplink moving interval update plugin parameter
-
- @param value
- The uplink moving interval update plugin parameter (in seconds)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUplinkUpdateIntervalMoving(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_UPLINK_UPDATE_INTERVAL_MOVING_NAME;
-       unsigned long long uplinkUpdateIntervalMovingNew;
 
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &uplinkUpdateIntervalMovingNew)) {
+       if (!readULL(valueName, value, &uplinkUpdateIntervalMoving, 10)) {
                return true;
        }
 
-       if (uplinkUpdateIntervalMovingNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (uplinkUpdateIntervalMoving < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       uplinkUpdateIntervalMoving = uplinkUpdateIntervalMovingNew;
-
        return false;
 }
 
@@ -1420,38 +1288,19 @@ unsigned long long getGatewayDeterminationInterval(void) {
        return gatewayDeterminationInterval;
 }
 
-/**
- Set gateway determination interval plugin parameter
-
- @param value
- The gateway determination interval plugin parameter (in seconds)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setGatewayDeterminationInterval(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_GATEWAY_DETERMINATION_INTERVAL_NAME;
-       unsigned long long gatewayDeterminationIntervalNew;
 
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &gatewayDeterminationIntervalNew)) {
+       if (!readULL(valueName, value, &gatewayDeterminationInterval, 10)) {
                return true;
        }
 
-       if (gatewayDeterminationIntervalNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (gatewayDeterminationInterval < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       gatewayDeterminationInterval = gatewayDeterminationIntervalNew;
-
        return false;
 }
 
@@ -1470,34 +1319,9 @@ unsigned long long getMovingSpeedThreshold(void) {
        return movingSpeedThreshold;
 }
 
-/**
- Set moving speed threshold plugin parameter
-
- @param value
- The moving speed threshold plugin parameter (in kph)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setMovingSpeedThreshold(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_MOVING_SPEED_THRESHOLD_NAME;
-       unsigned long long movingSpeedThresholdNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &movingSpeedThresholdNew)) {
-               return true;
-       }
-
-       movingSpeedThreshold = movingSpeedThresholdNew;
-
-       return false;
+       return !readULL(PUD_MOVING_SPEED_THRESHOLD_NAME, value, &movingSpeedThreshold, 10);
 }
 
 /*
@@ -1515,41 +1339,16 @@ unsigned long long getMovingDistanceThreshold(void) {
        return movingDistanceThreshold;
 }
 
-/**
- Set moving distance threshold plugin parameter
-
- @param value
- The moving distance threshold plugin parameter (in meter)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
-int setMovingDistanceThreshold(const char *value, void *data __attribute__ ((unused)),
-               set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
-       unsigned long long movingDistanceThresholdNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &movingDistanceThresholdNew)) {
-               return true;
-       }
-
-       movingDistanceThreshold = movingDistanceThresholdNew;
-
-       return false;
+int setMovingDistanceThreshold(const char *value, void *data __attribute__ ((unused)),
+               set_plugin_parameter_addon addon __attribute__ ((unused))) {
+       return !readULL(PUD_MOVING_DISTANCE_THRESHOLD_NAME, value, &movingDistanceThreshold, 10);
 }
 
 /*
  * dopMultiplier
  */
 
-/* The DOP multiplier plugin parameter */
+/** The DOP multiplier plugin parameter */
 static double dopMultiplier = PUD_DOP_MULTIPLIER_DEFAULT;
 
 /**
@@ -1560,34 +1359,9 @@ double getDopMultiplier(void) {
        return dopMultiplier;
 }
 
-/**
- Set DOP multiplier plugin parameter
-
- @param value
- The DOP multiplier plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setDopMultiplier(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_DOP_MULTIPLIER_NAME;
-       double dopMultiplierNew;
-
-       assert (value != NULL);
-
-       if (!readDouble(valueName, value, &dopMultiplierNew)) {
-               return true;
-       }
-
-       dopMultiplier = dopMultiplierNew;
-
-       return false;
+       return !readDouble(PUD_DOP_MULTIPLIER_NAME, value, &dopMultiplier);
 }
 
 /*
@@ -1605,34 +1379,9 @@ unsigned long long getDefaultHdop(void) {
        return defaultHdop;
 }
 
-/**
- Set default HDOP plugin parameter
-
- @param value
- The default HDOP plugin parameter (in meters)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setDefaultHdop(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
-       unsigned long long defaultHdopNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &defaultHdopNew)) {
-               return true;
-       }
-
-       defaultHdop = defaultHdopNew;
-
-       return false;
+       return !readULL(PUD_DEFAULT_HDOP_NAME, value, &defaultHdop, 10);
 }
 
 /*
@@ -1650,34 +1399,9 @@ unsigned long long getDefaultVdop(void) {
        return defaultVdop;
 }
 
-/**
- Set default VDOP plugin parameter
-
- @param value
- The default VDOP plugin parameter (in meters)
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setDefaultVdop(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_MOVING_DISTANCE_THRESHOLD_NAME;
-       unsigned long long defaultVdopNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &defaultVdopNew)) {
-               return true;
-       }
-
-       defaultVdop = defaultVdopNew;
-
-       return false;
+       return !readULL(PUD_DEFAULT_VDOP_NAME, value, &defaultVdop, 10);
 }
 
 /*
@@ -1695,38 +1419,19 @@ unsigned long long getAverageDepth(void) {
        return averageDepth;
 }
 
-/**
- Set average depth plugin parameter
-
- @param value
- The average depth plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setAverageDepth(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
        static const char * valueName = PUD_AVERAGE_DEPTH_NAME;
-       unsigned long long averageDepthNew;
-
-       assert (value != NULL);
 
-       if (!readULL(valueName, value, &averageDepthNew)) {
+       if (!readULL(valueName, value, &averageDepth, 10)) {
                return true;
        }
 
-       if (averageDepthNew < 1) {
-               pudError(false, "Configured %s must be at least 1", valueName);
+       if (averageDepth < 1) {
+               pudError(false, "Value of parameter %s must be at least 1", valueName);
                return true;
        }
 
-       averageDepth = averageDepthNew;
-
        return false;
 }
 
@@ -1745,34 +1450,9 @@ unsigned long long getHysteresisCountToStationary(void) {
        return hysteresisCountToStationary;
 }
 
-/**
- Set hysteresis count plugin parameter
-
- @param value
- The hysteresis count plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_HYSTERESIS_COUNT_2STAT_NAME;
-       unsigned long long hysteresisCountNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &hysteresisCountNew)) {
-               return true;
-       }
-
-       hysteresisCountToStationary = hysteresisCountNew;
-
-       return false;
+       return !readULL(PUD_HYSTERESIS_COUNT_2STAT_NAME, value, &hysteresisCountToStationary, 10);
 }
 
 /*
@@ -1790,34 +1470,9 @@ unsigned long long getHysteresisCountToMoving(void) {
        return hysteresisCountToMoving;
 }
 
-/**
- Set hysteresis count plugin parameter
-
- @param value
- The hysteresis count plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_HYSTERESIS_COUNT_2MOV_NAME;
-       unsigned long long hysteresisCountNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &hysteresisCountNew)) {
-               return true;
-       }
-
-       hysteresisCountToMoving = hysteresisCountNew;
-
-       return false;
+       return !readULL(PUD_HYSTERESIS_COUNT_2MOV_NAME, value, &hysteresisCountToMoving, 10);
 }
 
 /*
@@ -1835,34 +1490,9 @@ unsigned long long getGatewayHysteresisCountToStationary(void) {
        return gatewayHysteresisCountToStationary;
 }
 
-/**
- Set hysteresis count plugin parameter
-
- @param value
- The hysteresis count plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setGatewayHysteresisCountToStationary(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_GAT_HYSTERESIS_COUNT_2STAT_NAME;
-       unsigned long long hysteresisCountNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &hysteresisCountNew)) {
-               return true;
-       }
-
-       gatewayHysteresisCountToStationary = hysteresisCountNew;
-
-       return false;
+       return !readULL(PUD_GAT_HYSTERESIS_COUNT_2STAT_NAME, value, &gatewayHysteresisCountToStationary, 10);
 }
 
 /*
@@ -1880,41 +1510,16 @@ unsigned long long getGatewayHysteresisCountToMoving(void) {
        return gatewayHysteresisCountToMoving;
 }
 
-/**
- Set hysteresis count plugin parameter
-
- @param value
- The hysteresis count plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setGatewayHysteresisCountToMoving(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_GAT_HYSTERESIS_COUNT_2MOV_NAME;
-       unsigned long long hysteresisCountNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &hysteresisCountNew)) {
-               return true;
-       }
-
-       gatewayHysteresisCountToMoving = hysteresisCountNew;
-
-       return false;
+       return !readULL(PUD_GAT_HYSTERESIS_COUNT_2MOV_NAME, value, &gatewayHysteresisCountToMoving, 10);
 }
 
 /*
  * useDeDup
  */
 
-/* when true then duplicate message detection is performed */
+/** when true then duplicate message detection is performed */
 static bool useDeDup = PUD_USE_DEDUP_DEFAULT;
 
 /**
@@ -1925,92 +1530,36 @@ bool getUseDeDup(void) {
        return useDeDup;
 }
 
-/**
- Set duplicate message detection setting plugin parameter
-
- @param value
- The duplicate message detection setting plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUseDeDup(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_USE_DEDUP_NAME;
-       unsigned long long useDeDupNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &useDeDupNew)) {
-               return true;
-       }
-
-       if ((useDeDupNew != 0) && (useDeDupNew != 1)) {
-               pudError(false, "Configured %s must be 0 (false) or 1 (true)",
-                               valueName);
-               return true;
-       }
-
-       useDeDup = (useDeDupNew == 1);
-
-       return false;
+       return !readBool(PUD_USE_DEDUP_NAME, value, &useDeDup);
 }
 
 /*
  * deDupDepth
  */
 
-/** The hysteresis count for changing state from stationary to moving */
+/** The deduplication depth */
 static unsigned long long deDupDepth = PUD_DEDUP_DEPTH_DEFAULT;
 
 /**
  @return
- The hysteresis count for changing state from stationary to moving
+ The deduplication depth
  */
 unsigned long long getDeDupDepth(void) {
        return deDupDepth;
 }
 
-/**
- Set de-duplication depth plugin parameter
-
- @param value
- The de-duplication depth plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setDeDupDepth(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_DEDUP_DEPTH_NAME;
-       unsigned long long deDupDepthNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &deDupDepthNew)) {
-               return true;
-       }
-
-       deDupDepth = deDupDepthNew;
-
-       return false;
+       return !readULL(PUD_DEDUP_DEPTH_NAME, value, &deDupDepth, 10);
 }
 
 /*
  * useLoopback
  */
 
-/* when true then loopback is performed */
+/** when true then loopback is performed */
 static bool useLoopback = PUD_USE_LOOPBACK_DEFAULT;
 
 /**
@@ -2021,40 +1570,9 @@ bool getUseLoopback(void) {
        return useLoopback;
 }
 
-/**
- Set loopback usage plugin parameter
-
- @param value
- The loopback usage plugin parameter
- @param data
- Unused
- @param addon
- Unused
-
- @return
- - true when an error is detected
- - false otherwise
- */
 int setUseLoopback(const char *value, void *data __attribute__ ((unused)),
                set_plugin_parameter_addon addon __attribute__ ((unused))) {
-       static const char * valueName = PUD_USE_LOOPBACK_NAME;
-       unsigned long long useLoopbackNew;
-
-       assert (value != NULL);
-
-       if (!readULL(valueName, value, &useLoopbackNew)) {
-               return true;
-       }
-
-       if ((useLoopbackNew != 0) && (useLoopbackNew != 1)) {
-               pudError(false, "Configured %s must be 0 (false) or 1 (true)",
-                               valueName);
-               return true;
-       }
-
-       useLoopback = (useLoopbackNew == 1);
-
-       return false;
+       return !readBool(PUD_USE_LOOPBACK_NAME, value, &useLoopback);
 }
 
 /*
@@ -2071,11 +1589,6 @@ int setUseLoopback(const char *value, void *data __attribute__ ((unused)),
 unsigned int checkConfig(void) {
        int retval = true;
 
-       if (!olsr_cnf->smart_gw_active) {
-               pudError(false, "Smart Gateway must be active");
-               retval = false;
-       }
-
        if (rxNonOlsrInterfaceCount == 0) {
                pudError(false, "No receive non-OLSR interfaces configured");
                retval = false;
@@ -2086,30 +1599,6 @@ unsigned int checkConfig(void) {
                retval = false;
        }
 
-       if (!nodeIdSet) {
-               if (nodeIdType == PUD_NODEIDTYPE_DNS) {
-                       char name[PUD_TX_NODEID_BUFFERSIZE + 1];
-
-                       errno = 0;
-                       if (gethostname(&name[0], sizeof(name)) < 0) {
-                               pudError(true, "Could not get the host name");
-                               retval = false;
-                       } else {
-                               setNodeId(&name[0], NULL,
-                                               (set_plugin_parameter_addon) {.pc = NULL});
-                       }
-               } else if ((nodeIdType != PUD_NODEIDTYPE_MAC) && (nodeIdType
-                               != PUD_NODEIDTYPE_IPV4) && (nodeIdType != PUD_NODEIDTYPE_IPV6)) {
-                       pudError(false, "No node ID set while one is required for"
-                               " node type %u", nodeIdType);
-                       retval = false;
-               }
-       }
-
-       if (!setupNodeIdBinaryAndValidate(nodeIdType)) {
-               retval = false;
-       }
-
        if (updateIntervalMoving > updateIntervalStationary) {
                pudError(false,"The update interval for moving situations must not be"
                " larger than that for stationary situations");
@@ -2122,7 +1611,7 @@ unsigned int checkConfig(void) {
                retval = false;
        }
 
-       if (getUplinkPort() == getDownlinkPort()) {
+       if (isUplinkAddrSet() && (getUplinkPort() == getDownlinkPort())) {
                pudError(false, "The uplink port and the downlink port must not be the same");
                retval = false;
        }
@@ -2139,52 +1628,5 @@ unsigned int checkConfig(void) {
  - false otherwise
  */
 unsigned int checkRunSetup(void) {
-       int retval = true;
-       unsigned int i;
-
-       /* any receive interface name that is configured but is not the name of an
-        * actual receive interface is not a valid interface name */
-       for (i = 0; i < rxNonOlsrInterfaceCount; i++) {
-               unsigned char * nonOlsrInterfaceName = &rxNonOlsrInterfaceNames[i][0];
-
-               TRxTxNetworkInterface * interfaceObject = getRxNetworkInterfaces();
-               bool found = false;
-               while (interfaceObject != NULL) {
-                       if (strncmp((char *) nonOlsrInterfaceName,
-                                       (char *) &interfaceObject->name[0], IFNAMSIZ + 1) == 0) {
-                               found = true;
-                               break;
-                       }
-                       interfaceObject = interfaceObject->next;
-               }
-               if (!found) {
-                       pudError(false, "Configured receive non-OLSR interface %s is not"
-                               " a known interface name", nonOlsrInterfaceName);
-                       retval = false;
-               }
-       }
-
-       /* any transmit interface name that is configured but is not the name of an
-        * actual transmit interface is not a valid interface name */
-       for (i = 0; i < txNonOlsrInterfaceCount; i++) {
-               unsigned char * nonOlsrInterfaceName = &txNonOlsrInterfaceNames[i][0];
-
-               TRxTxNetworkInterface * interfaceObject = getTxNetworkInterfaces();
-               bool found = false;
-               while (interfaceObject != NULL) {
-                       if (strncmp((char *) nonOlsrInterfaceName,
-                                       (char *) &interfaceObject->name[0], IFNAMSIZ + 1) == 0) {
-                               found = true;
-                               break;
-                       }
-                       interfaceObject = interfaceObject->next;
-               }
-               if (!found) {
-                       pudError(false, "Configured transmit non-OLSR interface %s is not"
-                               " a known interface name", nonOlsrInterfaceName);
-                       retval = false;
-               }
-       }
-
-       return retval;
+       return true;
 }