Remove support for base 1024 isonumbers
authorHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Mon, 25 Sep 2017 12:41:34 +0000 (14:41 +0200)
committerHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Mon, 25 Sep 2017 12:41:34 +0000 (14:41 +0200)
Increase testing case coverage for isonumbers

31 files changed:
src-api/common/isonumber.c
src-api/common/isonumber.h
src-api/config/cfg_help.c
src-api/config/cfg_help.h
src-api/config/cfg_schema.c
src-api/config/cfg_schema.h
src-api/config/cfg_validate.c
src-api/config/cfg_validate.h
src-plugins/generic/dlep/radio/dlep_radio.c
src-plugins/generic/dlep/router/dlep_router.c
src-plugins/generic/eth_listener/eth_listener.c
src-plugins/generic/example/example.c
src-plugins/generic/layer2_config/layer2_config.c
src-plugins/generic/link_config/link_config.c
src-plugins/generic/systeminfo/systeminfo.c
src-plugins/nhdp/constant_metric/constant_metric.c
src-plugins/nhdp/ff_dat_metric/ff_dat_metric.c
src-plugins/nhdp/hysteresis_olsrv1/hysteresis_olsrv1.c
src-plugins/nhdp/neighbor_probing/neighbor_probing.c
src-plugins/nhdp/nhdp/nhdp.c
src-plugins/olsrv2/lan_import/lan_import.c
src-plugins/olsrv2/olsrv2/olsrv2.c
src-plugins/olsrv2/route_modifier/route_modifier.c
src-plugins/subsystems/oonf_clock.h
src-plugins/subsystems/oonf_http.c
src-plugins/subsystems/oonf_layer2.c
src-plugins/subsystems/oonf_layer2.h
src-plugins/subsystems/oonf_rfc5444.c
src-plugins/subsystems/oonf_telnet.c
tests/common/test_common_isonumber.c
tests/config/test_config_mapping.c

index 6f196fb..1f59abb 100644 (file)
@@ -52,7 +52,7 @@
 
 static const char *_isonumber_u64_to_string(char *out,
     size_t out_len, uint64_t number, const char *unit, size_t fraction,
-    bool binary, bool raw);
+    bool raw);
 
 /**
  * Converts an unsigned 64 bit integer into a human readable number
@@ -64,18 +64,15 @@ static const char *_isonumber_u64_to_string(char *out,
  * @param number number to convert.
  * @param unit unit to be appended at the end, can be NULL
  * @param fraction number of fractional digits
- * @param binary true if conversion should use 1024 as factor,
- *   false for default 1000 conversion factor
  * @param raw true if the whole text conversion should be bypassed
  *   and only the raw number shall be written, false otherwise
  * @return pointer to converted string
  */
 const char *
 isonumber_from_u64(struct isonumber_str *out,
-    uint64_t number, const char *unit, int fraction,
-    bool binary, bool raw) {
+    uint64_t number, const char *unit, int fraction, bool raw) {
   return _isonumber_u64_to_string(
-      out->buf, sizeof(*out), number, unit, fraction, binary, raw);
+      out->buf, sizeof(*out), number, unit, fraction, raw);
 }
 
 /**
@@ -88,16 +85,13 @@ isonumber_from_u64(struct isonumber_str *out,
  * @param number number to convert.
  * @param unit unit to be appended at the end, can be NULL
  * @param fraction number of fractional digits of fractional digits
- * @param binary true if conversion should use 1024 as factor,
- *   false for default 1000 conversion factor
  * @param raw true if the whole text conversion should be bypassed
  *   and only the raw number shall be written, false otherwise
  * @return pointer to converted string
  */
 const char *
 isonumber_from_s64(struct isonumber_str *out,
-    int64_t number, const char *unit, int fraction,
-    bool binary, bool raw) {
+    int64_t number, const char *unit, int fraction, bool raw) {
   char *outbuf = out->buf;
   uint64_t num;
   size_t len;
@@ -118,7 +112,7 @@ isonumber_from_s64(struct isonumber_str *out,
   }
 
   if (_isonumber_u64_to_string(
-      outbuf, len, num, unit, fraction, binary, raw)) {
+      outbuf, len, num, unit, fraction, raw)) {
     return out->buf;
   }
   return NULL;
@@ -130,12 +124,10 @@ isonumber_from_s64(struct isonumber_str *out,
  * @param dst pointer to destination variable
  * @param iso pointer to string source
  * @param fractions number of fractional digits, might be zero
- * @param binary true if prefixes should use factor 1024, false if they should
- *   use a factor of 1000
  * @return -1 if an error happened, 0 otherwise
  */
 int
-isonumber_to_s64(int64_t *dst, const char *iso, int fractions, bool binary) {
+isonumber_to_s64(int64_t *dst, const char *iso, int fractions) {
   const char *ptr;
   int result;
   uint64_t u64;
@@ -145,7 +137,7 @@ isonumber_to_s64(int64_t *dst, const char *iso, int fractions, bool binary) {
     ptr++;
   }
 
-  result = isonumber_to_u64(&u64, ptr, fractions, binary);
+  result = isonumber_to_u64(&u64, ptr, fractions);
   if (!result) {
     if (*iso == '-') {
       *dst = -((int64_t)u64);
@@ -163,17 +155,14 @@ isonumber_to_s64(int64_t *dst, const char *iso, int fractions, bool binary) {
  * @param dst pointer to destination variable
  * @param iso pointer to string source
  * @param fraction number of fractional digits, might be zero
- * @param binary true if prefixes should use factor 1024, false if they should
- *   use a factor of 1000
  * @return -1 if an error happened, 0 otherwise
  */
 int
-isonumber_to_u64(uint64_t *dst, const char *iso, int fraction, bool binary) {
+isonumber_to_u64(uint64_t *dst, const char *iso, int fraction) {
   static const char symbol_large[] = " kMGTPE";
 
   uint64_t num;
   uint64_t factor;
-  uint64_t multiplicator;
   int frac;
   char *next = NULL, *prefix;
 
@@ -195,15 +184,16 @@ isonumber_to_u64(uint64_t *dst, const char *iso, int fraction, bool binary) {
   frac = 0;
   if (*next == '.') {
     next++;
-    while (*next >='0' && *next <='9' && frac < fraction) {
+    while (*next >='0' && *next <='9') {
       num *= 10;
       num += (*next - '0');
       frac++;
       next++;
     }
   }
-  while (frac++ < fraction) {
+  while (frac < fraction) {
     num *= 10;
+    frac ++;
   }
 
   /* handle spaces */
@@ -218,19 +208,26 @@ isonumber_to_u64(uint64_t *dst, const char *iso, int fraction, bool binary) {
       return -1;
     }
 
-    multiplicator = binary ? 1024 : 1000;
-
     prefix = strchr(symbol_large, next[0]);
     if (!prefix) {
       return -1;
     }
 
     while (prefix > symbol_large) {
-      factor *= multiplicator;
+      factor *= 1000;
       prefix--;
     }
   }
 
+  while (frac > fraction) {
+    frac -= 3;
+    if (factor > 1) {
+      factor /= 1000;
+    }
+    else {
+      num /= 1000;
+    }
+  }
   if (num > UINT64_MAX / factor) {
     /* this would be an integer overflow */
     return -1;
@@ -249,23 +246,19 @@ isonumber_to_u64(uint64_t *dst, const char *iso, int fraction, bool binary) {
  * @param number number to convert
  * @param unit unit that should be appended on result
  * @param fraction number of fractional digits
- * @param binary true if prefixes should use factor 1024, false if they should
- *   use a factor of 1000
  * @param raw true to suppress iso prefixes and unit, false otherwise
  * @return pointer to output buffer, NULL if an error happened
  */
 static const char *
 _isonumber_u64_to_string(char *out, size_t out_len,
-    uint64_t number, const char *unit, size_t fraction,
-    bool binary, bool raw) {
+    uint64_t number, const char *unit, size_t fraction, bool raw) {
   static const char symbol_large[] = " kMGTPE";
   static const char symbol_small[] = " munpfa";
-  uint64_t step, multiplier, print, n;
+  uint64_t multiplier, print, n;
   const char *unit_modifier;
   size_t idx, len;
   int result;
 
-  step = binary ? 1024 : 1000;
   multiplier = 1;
 
   while (fraction > 0) {
@@ -275,16 +268,16 @@ _isonumber_u64_to_string(char *out, size_t out_len,
 
   if (number >= multiplier) {
     unit_modifier = symbol_large;
-    while (!raw && *unit_modifier != 0 && number / step >= multiplier) {
-      multiplier *= step;
+    while (!raw && *unit_modifier != 0 && number / 1000 >= multiplier) {
+      multiplier *= 1000;
       unit_modifier++;
     }
   }
   else {
     unit_modifier = symbol_small;
     while (!raw && *unit_modifier != 0 && number < multiplier
-        && multiplier >= step) {
-      multiplier /= step;
+        && multiplier >= 1000) {
+      multiplier /= 1000;
       unit_modifier++;
     }
   }
index 33c14d6..07dfb30 100644 (file)
@@ -58,12 +58,12 @@ struct isonumber_str {
 };
 
 EXPORT const char *isonumber_from_u64(struct isonumber_str *out,
-    uint64_t number, const char *unit, int fraction, bool binary, bool raw);
+    uint64_t number, const char *unit, int fraction, bool raw);
 EXPORT const char *isonumber_from_s64(struct isonumber_str *out,
-    int64_t number, const char *unit, int fraction, bool binary, bool raw);
+    int64_t number, const char *unit, int fraction, bool raw);
 EXPORT int isonumber_to_u64(
-    uint64_t *dst, const char *iso, int fractions, bool binary);
+    uint64_t *dst, const char *iso, int fractions);
 EXPORT int isonumber_to_s64(
-    int64_t *dst, const char *iso, int fractions, bool binary);
+    int64_t *dst, const char *iso, int fractions);
 
 #endif /* ISONUMBER_H_ */
index 0ce39ac..7ae93b0 100644 (file)
@@ -109,11 +109,10 @@ cfg_help_choice(struct autobuf *out, bool preamble,
  * @param max maximal value
  * @param bytelen number of bytes the storage types has
  * @param fraction number of fractional digits
- * @param base2 true if iso prefixes should use factor 1024
  */
 void
 cfg_help_int(struct autobuf *out,
-    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction, bool base2) {
+    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction) {
   struct isonumber_str hbuf1, hbuf2;
   int64_t min64, max64;
 
@@ -121,8 +120,8 @@ cfg_help_int(struct autobuf *out,
   max64 = INT64_MAX >> (8 * (8 - bytelen));
 
   /* get string representation of min/max */
-  isonumber_from_s64(&hbuf1, min, "", fraction, base2, true);
-  isonumber_from_s64(&hbuf2, max, "", fraction, base2, true);
+  isonumber_from_s64(&hbuf1, min, "", fraction, true);
+  isonumber_from_s64(&hbuf2, max, "", fraction, true);
 
   if (min > min64) {
     if (max < max64) {
index 80ff434..0c7b279 100644 (file)
@@ -54,7 +54,7 @@ EXPORT void cfg_help_strlen(struct autobuf *out, size_t len);
 EXPORT void cfg_help_choice(struct autobuf *out, bool preamble,
     const char **choices, size_t choice_count);
 EXPORT void cfg_help_int(struct autobuf *out,
-    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction, bool base2);
+    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction);
 EXPORT void cfg_help_netaddr(struct autobuf *out, bool preamble,
     bool prefix, const int8_t *af_types, size_t af_types_count);
 EXPORT void cfg_help_acl(struct autobuf *out, bool preamble,
index ed26bea..36968cf 100644 (file)
@@ -522,8 +522,7 @@ cfg_schema_validate_int(const struct cfg_schema_entry *entry,
   return cfg_validate_int(out, section_name, entry->key.entry, value,
       entry->validate_param[0].i64, entry->validate_param[1].i64,
       entry->validate_param[2].i16[0],
-      entry->validate_param[2].i16[1],
-      entry->validate_param[2].i16[2] == 2);
+      entry->validate_param[2].i16[1]);
 }
 
 /**
@@ -622,8 +621,7 @@ void
 cfg_schema_help_int(const struct cfg_schema_entry *entry, struct autobuf *out) {
   cfg_help_int(out, entry->validate_param[0].i64, entry->validate_param[1].i64,
       entry->validate_param[2].i16[0],
-      entry->validate_param[2].i16[1],
-      entry->validate_param[2].i16[2] == 2);
+      entry->validate_param[2].i16[1]);
 }
 
 /**
@@ -760,7 +758,7 @@ cfg_schema_tobin_int(const struct cfg_schema_entry *s_entry,
   }
 
   result = isonumber_to_s64(&i, strarray_get_first_c(value),
-      s_entry->validate_param[2].u16[1], s_entry->validate_param[2].u16[2] == 2);
+      s_entry->validate_param[2].u16[1]);
   if (result == 0) {
     switch (s_entry->validate_param[2].u16[0]) {
       case 4:
index 19cf9a0..5c808e6 100644 (file)
@@ -108,12 +108,11 @@ struct cfg_schema_entry;
  * @param p_help help text for configuration entry
  * @param size number of bytes for integer storage
  * @param fraction number of fractional digits
- * @param base2 true if iso prefixes should use factor 1024
  * @param min minimal allowed parameter value
  * @param max maximum allowed parameter value
  * @param args variable list of additional arguments
  */
-#define _CFG_VALIDATE_INT(p_name, p_def, p_help, size, fraction, base2, min, max, args...)   _CFG_VALIDATE(p_name, p_def, p_help, .cb_validate = cfg_schema_validate_int, .cb_valhelp = cfg_schema_help_int, .validate_param = {{.i64 = (min)}, {.i64 = (max)}, {.u16 = {size, fraction, !!(base2) ? 2 : 10}}}, ##args )
+#define _CFG_VALIDATE_INT(p_name, p_def, p_help, size, fraction, min, max, args...)   _CFG_VALIDATE(p_name, p_def, p_help, .cb_validate = cfg_schema_validate_int, .cb_valhelp = cfg_schema_help_int, .validate_param = {{.i64 = (min)}, {.i64 = (max)}, {.u16 = {size, fraction}}}, ##args )
 
 /**
  * Creates a cfg_schema_entry for a parameter that does not need to be validated
@@ -173,10 +172,9 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param args variable list of additional arguments
  */
-#define CFG_VALIDATE_INT32(p_name, p_def, p_help, fraction, base2, args...)                  _CFG_VALIDATE_INT(p_name, p_def, p_help, 4, fraction, base2, INT32_MIN, INT32_MAX, ##args)
+#define CFG_VALIDATE_INT32(p_name, p_def, p_help, fraction, base2, args...)                  _CFG_VALIDATE_INT(p_name, p_def, p_help, 4, fraction, INT32_MIN, INT32_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 64 bit signed integer parameter
@@ -184,10 +182,9 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param args variable list of additional arguments
  */
-#define CFG_VALIDATE_INT64(p_name, p_def, p_help, fraction, base2, args...)                  _CFG_VALIDATE_INT(p_name, p_def, p_help, 8, fraction, base2, INT64_MIN, INT64_MAX, ##args)
+#define CFG_VALIDATE_INT64(p_name, p_def, p_help, fraction, base2, args...)                  _CFG_VALIDATE_INT(p_name, p_def, p_help, 8, fraction, INT64_MIN, INT64_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 32 bit signed integer parameter
@@ -196,12 +193,11 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param min minimal allowed value
  * @param max maximal allowed value
  * @param args variable list of additional arguments
  */
-#define CFG_VALIDATE_INT32_MINMAX(p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_VALIDATE_INT(p_name, p_def, p_help, 4, fraction, base2, min, max, ##args)
+#define CFG_VALIDATE_INT32_MINMAX(p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_VALIDATE_INT(p_name, p_def, p_help, 4, fraction, min, max, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 64 bit signed integer parameter
@@ -210,12 +206,11 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param min minimal allowed value
  * @param max maximal allowed value
  * @param args variable list of additional arguments
  */
-#define CFG_VALIDATE_INT64_MINMAX(p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_VALIDATE_INT(p_name, p_def, p_help, 8, fraction, base2, min, max, ##args)
+#define CFG_VALIDATE_INT64_MINMAX(p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_VALIDATE_INT(p_name, p_def, p_help, 8, fraction, min, max, ##args)
 
 /**
  * Creates a cfg_schema_entry for a network address of any type
@@ -434,7 +429,7 @@ struct cfg_schema_entry;
  * @param max maximum allowed parameter value
  * @param args variable list of additional arguments
  */
-#define _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, size, fraction, base2, min, max, args...)   _CFG_VALIDATE_INT(p_name, p_def, p_help, size, fraction, base2, min, max, .cb_to_binary = cfg_schema_tobin_int, .bin_size = calculate_size(p_reference, p_field), .bin_offset = offsetof(struct p_reference, p_field), ##args )
+#define _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, size, fraction, min, max, args...)   _CFG_VALIDATE_INT(p_name, p_def, p_help, size, fraction, min, max, .cb_to_binary = cfg_schema_tobin_int, .bin_size = calculate_size(p_reference, p_field), .bin_offset = offsetof(struct p_reference, p_field), ##args )
 
 /**
  * Creates a cfg_schema_entry for a parameter that does not need to be validated
@@ -543,10 +538,9 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_INT32(p_reference, p_field, p_name, p_def, p_help, fraction, base2, args...)                  _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 4, fraction, base2, INT32_MIN, INT32_MAX, ##args)
+#define CFG_MAP_INT32(p_reference, p_field, p_name, p_def, p_help, fraction, args...)                  _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 4, fraction, INT32_MIN, INT32_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 64 bit signed integer parameter
@@ -558,10 +552,9 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_INT64(p_reference, p_field, p_name, p_def, p_help, fraction, base2, args...)                  _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 8, fraction, base2, INT64_MIN, INT64_MAX, ##args)
+#define CFG_MAP_INT64(p_reference, p_field, p_name, p_def, p_help, fraction, args...)                  _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 8, fraction, INT64_MIN, INT64_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 32 bit signed integer parameter
@@ -573,12 +566,11 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param min minimal allowed value
  * @param max maximal allowed value
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_INT32_MINMAX(p_reference, p_field, p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 4, fraction, base2, min, max, ##args)
+#define CFG_MAP_INT32_MINMAX(p_reference, p_field, p_name, p_def, p_help, fraction, min, max, args...) _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 4, fraction, min, max, ##args)
 
 /**
  * Creates a cfg_schema_entry for a 64 bit signed integer parameter
@@ -590,12 +582,11 @@ struct cfg_schema_entry;
  * @param p_def parameter default value
  * @param p_help help text for configuration entry
  * @param fraction number of fractional digits
- * @param base2 true if iso-prefixes should use factor 1024
  * @param min minimal allowed value
  * @param max maximal allowed value
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, fraction, base2, min, max, args...) _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 8, fraction, base2, min, max, ##args)
+#define CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, fraction, min, max, args...) _CFG_MAP_INT(p_reference, p_field, p_name, p_def, p_help, 8, fraction, min, max, ##args)
 
 /**
  * Creates a cfg_schema_entry for a network address of any type
index b9d9a00..7fa9e5a 100644 (file)
@@ -137,18 +137,16 @@ cfg_validate_choice(struct autobuf *out, const char *section_name,
  * @param max maximum value of number including fractional digits
  * @param bytelen number of bytes available for target number
  * @param fraction number of fractional digits of target number
- * @param base2 true if number shall use binary prefixes instead of
- *    iso prefixes (1024 instead of 1000)
  * @return 0 if value is valid, -1 otherwise
  */
 int
 cfg_validate_int(struct autobuf *out, const char *section_name,
     const char *entry_name, const char *value, int64_t min, int64_t max,
-    uint16_t bytelen, uint16_t fraction, bool base2) {
+    uint16_t bytelen, uint16_t fraction) {
   int64_t i, min64, max64;
   struct isonumber_str hbuf;
 
-  if (isonumber_to_s64(&i, value, fraction, base2)) {
+  if (isonumber_to_s64(&i, value, fraction)) {
     if (fraction) {
       cfg_append_printable_line(out, "Value '%s' for entry '%s'"
           " in section %s is not a fractional %d-byte integer"
@@ -180,14 +178,14 @@ cfg_validate_int(struct autobuf *out, const char *section_name,
     cfg_append_printable_line(out, "Value '%s' for entry '%s' in section %s is "
         "smaller than %s",
         value, entry_name, section_name,
-        isonumber_from_s64(&hbuf, min, "", fraction, base2, true));
+        isonumber_from_s64(&hbuf, min, "", fraction, true));
     return -1;
   }
   if (i > max) {
     cfg_append_printable_line(out, "Value '%s' for entry '%s' in section %s is "
         "larger than %s",
         value, entry_name, section_name,
-        isonumber_from_s64(&hbuf, min, "", fraction, base2, true));
+        isonumber_from_s64(&hbuf, min, "", fraction, true));
     return -1;
   }
   return 0;
index 53c4b0e..8673aa9 100644 (file)
@@ -60,7 +60,7 @@ EXPORT int cfg_validate_choice(struct autobuf *out,
     const char **choices, size_t choice_count);
 EXPORT int cfg_validate_int(struct autobuf *out,
     const char *section_name, const char *entry_name, const char *value,
-    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction, bool base2);
+    int64_t min, int64_t max, uint16_t bytelen, uint16_t fraction);
 EXPORT int cfg_validate_netaddr(struct autobuf *out,
     const char *section_name, const char *entry_name, const char *value,
     bool prefix, const int8_t *af_types, size_t af_types_count);
index a2ba6ad..da465ee 100644 (file)
@@ -86,12 +86,12 @@ static struct cfg_schema_entry _radio_entries[] = {
   CFG_MAP_NETADDR_V6(dlep_radio_if, interf.udp_config.multicast_v6, "discovery_mc_v6",
     DLEP_WELL_KNOWN_MULTICAST_ADDRESS_6, "IPv6 address to send discovery UDP packet to", false, false),
   CFG_MAP_INT32_MINMAX(dlep_radio_if, interf.udp_config.port, "discovery_port",
-    DLEP_WELL_KNOWN_MULTICAST_PORT_TXT, "UDP port for discovery packets", 0, false, 1, 65535),
+    DLEP_WELL_KNOWN_MULTICAST_PORT_TXT, "UDP port for discovery packets", 0, 1, 65535),
   CFG_MAP_ACL_V46(dlep_radio_if, interf.udp_config.bindto, "discovery_bindto", "fe80::/10",
     "Filter to determine the binding of the UDP discovery socket"),
 
   CFG_MAP_INT32_MINMAX(dlep_radio_if, tcp_config.port, "session_port",
-      DLEP_WELL_KNOWN_SESSION_PORT_TXT, "Server port for DLEP tcp sessions", 0, false, 1, 65535),
+      DLEP_WELL_KNOWN_SESSION_PORT_TXT, "Server port for DLEP tcp sessions", 0, 1, 65535),
   CFG_MAP_ACL_V46(dlep_radio_if, tcp_config.bindto, "session_bindto", "224.0.0.1\0fe80::/10",
       "Filter to determine the binding of the TCP server socket"),
   CFG_MAP_CLOCK_MINMAX(dlep_radio_if, interf.session.cfg.heartbeat_interval,
index fee79b5..ce0d811 100644 (file)
@@ -82,7 +82,7 @@ static struct cfg_schema_entry _router_entries[] = {
   CFG_MAP_NETADDR_V6(dlep_router_if, interf.udp_config.multicast_v6, "discovery_mc_v6",
     DLEP_WELL_KNOWN_MULTICAST_ADDRESS_6, "IPv6 address to send discovery UDP packet to", false, false),
   CFG_MAP_INT32_MINMAX(dlep_router_if, interf.udp_config.multicast_port, "discovery_port",
-    DLEP_WELL_KNOWN_MULTICAST_PORT_TXT, "UDP port for discovery packets", 0, false, 1, 65535),
+    DLEP_WELL_KNOWN_MULTICAST_PORT_TXT, "UDP port for discovery packets", 0, 1, 65535),
 
   CFG_MAP_ACL_V46(dlep_router_if, interf.udp_config.bindto, "discovery_bindto", "224.0.0.1\0fe80::/10",
     "Filter to determine the binding of the UDP discovery socket"),
@@ -104,7 +104,7 @@ static struct cfg_schema_entry _router_entries[] = {
   CFG_MAP_NETADDR_V46(dlep_router_if, connect_to_addr, "connect_to", "-",
       "IP to directly connect to a known DLEP radio TCP socket", false, true),
   CFG_MAP_INT32_MINMAX(dlep_router_if, connect_to_port, "connect_to_port", "1",
-      "TCP port to directly connect to a known DLEP radio TCP socket", 0, false, 1, 65535),
+      "TCP port to directly connect to a known DLEP radio TCP socket", 0, 1, 65535),
 };
 
 static struct cfg_schema_section _router_section = {
index bae9489..10ce457 100644 (file)
@@ -224,7 +224,7 @@ _cb_transmission_event(struct oonf_timer_instance *ptr __attribute((unused))) {
     /* set corresponding database entries */
     OONF_DEBUG(LOG_ETH, "Set default link speed of interface %s to %s",
         os_if->name,
-        isonumber_from_s64(&ibuf, ethspeed, "bit/s", 0, false, false));
+        isonumber_from_s64(&ibuf, ethspeed, "bit/s", 0, false));
 
     oonf_layer2_data_set_int64(&l2net->neighdata[OONF_LAYER2_NEIGH_RX_BITRATE],
         &_l2_origin, ethspeed);
index 555f19c..c6928a0 100644 (file)
@@ -77,7 +77,7 @@ static void _cb_config_changed(void);
 /* configuration */
 static struct cfg_schema_entry _example_entries[] = {
   CFG_MAP_INT64_MINMAX(_example_config, start, "start", "0",
-      "Starting value for counter", 0, false, 0, 1000),
+      "Starting value for counter", 0, 0, 1000),
   CFG_MAP_CLOCK_MIN(_example_config, interval, "interval", "1.0",
       "Interval between counter updates", 100),
 };
index d550b45..1a8c908 100644 (file)
@@ -386,9 +386,7 @@ _cb_validate_l2netdata(const struct cfg_schema_entry *entry,
 
   /* test if second word is a human readable number */
   if (cfg_validate_int(out, section_name, entry->key.entry, ptr,
-      INT64_MIN, INT64_MAX, 8,
-      oonf_layer2_net_metadata_get(idx)->fraction,
-      oonf_layer2_net_metadata_get(idx)->binary)) {
+      INT64_MIN, INT64_MAX, 8, oonf_layer2_net_metadata_get(idx)->fraction)) {
     return -1;
   }
   return 0;
@@ -426,9 +424,7 @@ _cb_validate_l2defdata(const struct cfg_schema_entry *entry,
 
   /* test if second word is a human readable number */
   if (cfg_validate_int(out, section_name, entry->key.entry, ptr,
-      INT64_MIN, INT64_MAX, 8,
-      oonf_layer2_neigh_metadata_get(idx)->fraction,
-      oonf_layer2_neigh_metadata_get(idx)->binary)) {
+      INT64_MIN, INT64_MAX, 8, oonf_layer2_neigh_metadata_get(idx)->fraction)) {
     return -1;
   }
   return 0;
@@ -469,9 +465,7 @@ _cb_validate_l2neighdata(const struct cfg_schema_entry *entry,
   /* test if second word is a human readable number */
   ptr = str_cpynextword(sbuf.buf, ptr, sizeof(sbuf));
   if (cfg_validate_int(out, section_name, entry->key.entry, sbuf.buf,
-      INT64_MIN, INT64_MAX, 8,
-      oonf_layer2_neigh_metadata_get(idx)->fraction,
-      oonf_layer2_neigh_metadata_get(idx)->binary)) {
+      INT64_MIN, INT64_MAX, 8, oonf_layer2_neigh_metadata_get(idx)->fraction)) {
     return -1;
   }
 
index 9c76708..7df4020 100644 (file)
@@ -250,9 +250,7 @@ _cb_validate_linkdata(const struct cfg_schema_entry *entry,
   /* test if first word is a human readable number */
   ptr = str_cpynextword(sbuf.buf, value, sizeof(sbuf));
   if (cfg_validate_int(out, section_name, entry->key.entry, sbuf.buf,
-      INT64_MIN, INT64_MAX, 8,
-      oonf_layer2_neigh_metadata_get(idx)->fraction,
-      oonf_layer2_neigh_metadata_get(idx)->binary)) {
+      INT64_MIN, INT64_MAX, 8, oonf_layer2_neigh_metadata_get(idx)->fraction)) {
     return -1;
   }
 
@@ -295,9 +293,7 @@ _parse_strarray(struct strarray *array, const char *ifname,
 
   strarray_for_each_element(array, entry) {
     ptr = str_cpynextword(hbuf.buf, entry, sizeof(hbuf));
-    if (isonumber_to_s64(&value, hbuf.buf,
-        oonf_layer2_neigh_metadata_get(idx)->fraction,
-        oonf_layer2_neigh_metadata_get(idx)->binary)) {
+    if (isonumber_to_s64(&value, hbuf.buf, oonf_layer2_neigh_metadata_get(idx)->fraction)) {
       continue;
     }
 
index d8c2185..b18a87d 100644 (file)
@@ -345,7 +345,7 @@ static void
 _initialize_time_values(struct oonf_viewer_template *template) {
   oonf_log_get_walltime(&_value_system_time);
   isonumber_from_u64(&_value_internal_time, oonf_clock_getNow(),
-      "", 3, false, template->create_raw);
+      "", 3, template->create_raw);
 }
 
 /**
@@ -369,13 +369,13 @@ _initialize_memory_values(struct oonf_viewer_template *template,
   strscpy(_value_stat_name, cl->name, sizeof(_value_stat_name));
 
   isonumber_from_u64(&_value_memory_usage,
-      oonf_class_get_usage(cl), "", 0, false, template->create_raw);
+      oonf_class_get_usage(cl), "", 0, template->create_raw);
   isonumber_from_u64(&_value_memory_freelist,
-      oonf_class_get_free(cl), "", 0, false, template->create_raw);
+      oonf_class_get_free(cl), "", 0, template->create_raw);
   isonumber_from_u64(&_value_memory_alloc,
-      oonf_class_get_allocations(cl), "", 0, false, template->create_raw);
+      oonf_class_get_allocations(cl), "", 0, template->create_raw);
   isonumber_from_u64(&_value_memory_recycled,
-      oonf_class_get_recycled(cl), "", 0, false, template->create_raw);
+      oonf_class_get_recycled(cl), "", 0, template->create_raw);
 }
 
 /**
@@ -387,13 +387,13 @@ _initialize_timer_values(struct oonf_viewer_template *template,
   strscpy(_value_stat_name, tc->name, sizeof(_value_stat_name));
 
   isonumber_from_u64(&_value_timer_usage,
-      oonf_timer_get_usage(tc), "", 0, false, template->create_raw);
+      oonf_timer_get_usage(tc), "", 0, template->create_raw);
   isonumber_from_u64(&_value_timer_change,
-      oonf_timer_get_changes(tc), "", 0, false, template->create_raw);
+      oonf_timer_get_changes(tc), "", 0, template->create_raw);
   isonumber_from_u64(&_value_timer_fire,
-      oonf_timer_get_fired(tc), "", 0, false, template->create_raw);
+      oonf_timer_get_fired(tc), "", 0, template->create_raw);
   isonumber_from_u64(&_value_timer_long,
-      oonf_timer_get_long(tc), "", 0, false, template->create_raw);
+      oonf_timer_get_long(tc), "", 0, template->create_raw);
 }
 
 /**
@@ -405,11 +405,11 @@ _initialize_socket_values(struct oonf_viewer_template *template,
   strscpy(_value_stat_name, sock->name, sizeof(_value_stat_name));
 
   isonumber_from_u64(&_value_socket_recv,
-      oonf_socket_get_recv(sock), "", 0, false, template->create_raw);
+      oonf_socket_get_recv(sock), "", 0, template->create_raw);
   isonumber_from_u64(&_value_socket_send,
-      oonf_socket_get_send(sock), "", 0, false, template->create_raw);
+      oonf_socket_get_send(sock), "", 0, template->create_raw);
   isonumber_from_u64(&_value_socket_long,
-      oonf_socket_get_long(sock), "", 0, false, template->create_raw);
+      oonf_socket_get_long(sock), "", 0, template->create_raw);
 }
 
 /**
@@ -422,7 +422,7 @@ static void _initialize_logging_values(
   strscpy(_value_log_source, LOG_SOURCE_NAMES[source],
       sizeof(_value_log_source));
   isonumber_from_u64(&_value_log_warnings,
-      oonf_log_get_warning_count(source), "", 0, false, template->create_raw);
+      oonf_log_get_warning_count(source), "", 0, template->create_raw);
 }
 
 /**
index 09b0195..f3abc18 100644 (file)
@@ -336,7 +336,7 @@ _cb_validate_link(const struct cfg_schema_entry *entry,
   /* test if second word is a human readable number */
   ptr = str_cpynextword(sbuf.buf, ptr, sizeof(sbuf));
   if (cfg_validate_int(out, section_name, entry->key.entry, sbuf.buf,
-      RFC7181_METRIC_MIN, RFC7181_METRIC_MAX, 4, 0, false)) {
+      RFC7181_METRIC_MIN, RFC7181_METRIC_MAX, 4, 0)) {
     return -1;
   }
 
@@ -385,7 +385,7 @@ _cb_cfg_changed(void) {
         oonf_class_free(&_linkcost_class, lk);
         continue;
       }
-      if (isonumber_to_s64(&cost, cost_ptr, 0, false)) {
+      if (isonumber_to_s64(&cost, cost_ptr, 0)) {
         oonf_class_free(&_linkcost_class, lk);
         continue;
       }
index 2c76bf6..85e4de2 100644 (file)
@@ -1078,7 +1078,7 @@ _link_to_string(struct nhdp_metric_str *buf, uint32_t metric) {
     value = (uint32_t)(DATFF_LINKSPEED_MINIMUM) * (uint32_t)(DATFF_LINKSPEED_RANGE) / metric;
   }
   isonumber_from_u64((struct isonumber_str *)buf,
-      value, "bit/s", 0, true, false);
+      value, "bit/s", 0, false);
   return buf->buf;
 }
 
index 414397b..118bed2 100644 (file)
@@ -124,11 +124,11 @@ static int _cb_cfg_validate(const char *section_name,
 /* configuration options */
 static struct cfg_schema_entry _hysteresis_entries[] = {
   CFG_MAP_INT32_MINMAX(_config, accept, "accept", "0.7",
-      "link quality to consider a link up", 3, false, 0, 1000),
+      "link quality to consider a link up", 3, 0, 1000),
   CFG_MAP_INT32_MINMAX(_config, reject, "reject", "0.3",
-      "link quality to consider a link down", 3, false, 0, 1000),
+      "link quality to consider a link down", 3, 0, 1000),
   CFG_MAP_INT32_MINMAX(_config, scaling, "scaling", "0.25",
-      "exponential aging to control speed of link hysteresis", 3, false, 1, 1000),
+      "exponential aging to control speed of link hysteresis", 3, 1, 1000),
 };
 
 static struct cfg_schema_section _hysteresis_section = {
@@ -350,7 +350,7 @@ _cb_to_string(struct nhdp_hysteresis_str *buf, struct nhdp_link *lnk) {
   data = oonf_class_get_extension(&_link_extenstion, lnk);
 
   snprintf(buf->buf, sizeof(*buf), "quality=%s",
-      isonumber_from_s64(&fbuf, data->quality, "", 3, false, true));
+      isonumber_from_s64(&fbuf, data->quality, "", 3, true));
 
   return buf->buf;
 }
@@ -405,8 +405,8 @@ _cb_cfg_validate(const char *section_name,
 
   if (cfg.accept <= cfg.reject) {
     cfg_append_printable_line(out, "hysteresis accept (%s) is not smaller than reject (%s) value",
-        isonumber_from_s64(&buf1, cfg.accept, "", 3, false, true),
-        isonumber_from_s64(&buf2, cfg.reject, "", 3, false, true));
+        isonumber_from_s64(&buf1, cfg.accept, "", 3, true),
+        isonumber_from_s64(&buf2, cfg.reject, "", 3, true));
     return -1;
   }
   return 0;
index d8bdc0b..67fbef0 100644 (file)
@@ -113,7 +113,7 @@ static struct cfg_schema_entry _probing_entries[] = {
       "Time interval between link probing", 100),
   CFG_MAP_INT32_MINMAX(_config, probe_size, "size", "512",
       "Number of bytes used for neighbor probe",
-      0, false, 1, 1500),
+      0, 1, 1500),
   CFG_MAP_BOOL(_config, probe_dlep, "probe_dlep", "true",
       "Probe DLEP interfaces in addition to wireless interfaces"
       " if they don't support the 'need probing' flag"),
index d692a80..f505396 100644 (file)
@@ -107,7 +107,7 @@ static struct cfg_schema_entry _nhdp_entries[] = {
       NHDP_DOMAIN_MPR_MAXLEN),
   CFG_MAP_INT32_MINMAX(_generic_parameters, mpr_willingness, "willingness",
       RFC7181_WILLINGNESS_DEFAULT_STRING,
-      "Flooding willingness for MPR calculation", 0, false,
+      "Flooding willingness for MPR calculation", 0,
       RFC7181_WILLINGNESS_MIN, RFC7181_WILLINGNESS_MAX),
 };
 
@@ -151,7 +151,7 @@ static struct cfg_schema_entry _domain_entries[] = {
       NHDP_DOMAIN_MPR_MAXLEN),
   CFG_MAP_INT32_MINMAX(_domain_parameters, mpr_willingness, "willingness",
       RFC7181_WILLINGNESS_DEFAULT_STRING, "Routing willingness used for MPR calculation",
-      0, false, RFC7181_WILLINGNESS_MIN, RFC7181_WILLINGNESS_MAX),
+      0, RFC7181_WILLINGNESS_MIN, RFC7181_WILLINGNESS_MAX),
 };
 
 static struct cfg_schema_section _domain_section = {
index b76dee3..92e544f 100644 (file)
@@ -144,24 +144,24 @@ static void _cb_cfg_changed(void);
 /* plugin declaration */
 static struct cfg_schema_entry _import_entries[] = {
   CFG_MAP_INT32_MINMAX(_import_entry, domain, "domain", "-1",
-      "Routing domain extension for filter, -1 for all domains", 0, false, -1, 255),
+      "Routing domain extension for filter, -1 for all domains", 0, -1, 255),
   CFG_MAP_ACL(_import_entry, filter, "matches",  ACL_DEFAULT_ACCEPT,
       "Ip addresses the filter should be applied to"
       " (the plugin will never import loopback, linklocal or multicast IPs)"),
   CFG_MAP_INT32_MINMAX(_import_entry, prefix_length, "prefix_length", "-1",
       "Prefix length the filter should be applied to, -1 for any prefix length",
-      0, false, -1, 128),
+      0, -1, 128),
   CFG_MAP_STRING_ARRAY(_import_entry, ifname, "interface", "",
       "Interface name of matching routes, empty if all interfaces", IF_NAMESIZE),
   CFG_MAP_INT32_MINMAX(_import_entry, table, "table", "-1",
-      "Routing table of matching routes, 0 for matching all tables", 0, false, -1, 255),
+      "Routing table of matching routes, 0 for matching all tables", 0, -1, 255),
   CFG_MAP_INT32_MINMAX(_import_entry, protocol, "protocol", "-1",
-      "Routing protocol of matching routes, 0 for all protocols", 0, false, -1, 255),
+      "Routing protocol of matching routes, 0 for all protocols", 0, -1, 255),
   CFG_MAP_INT32_MINMAX(_import_entry, distance, "metric", "-1",
-      "Metric of matching routes, 0 for all metrics", 0, false, -1, INT32_MAX),
+      "Metric of matching routes, 0 for all metrics", 0, -1, INT32_MAX),
   CFG_MAP_INT32_MINMAX(_import_entry, routing_metric, "routing_metric", "1",
       "Set the routing metric of an imported route to a specific value",
-         false, false, RFC7181_METRIC_MIN, RFC7181_METRIC_MAX),
+         false, RFC7181_METRIC_MIN, RFC7181_METRIC_MAX),
   CFG_MAP_CLOCK(_import_entry, metric_aging, "metric_aging", "0",
       "Double the routing metric value every time interval, 0 to disable"),
 };
index 3b0ef44..2c065ba 100644 (file)
@@ -161,11 +161,11 @@ static struct cfg_schema_entry _rt_domain_entries[] = {
   CFG_MAP_BOOL(olsrv2_routing_domain, use_srcip_in_routes, "srcip_routes", "true",
       "Set the source IP of IPv4-routes to a fixed value."),
   CFG_MAP_INT32_MINMAX(olsrv2_routing_domain, protocol, "protocol", "100",
-      "Protocol number to be used in routing table", 0, false, 1, 254),
+      "Protocol number to be used in routing table", 0, 1, 254),
   CFG_MAP_INT32_MINMAX(olsrv2_routing_domain, table, "table", "254",
-      "Routing table number for routes", 0, false, 1, 254),
+      "Routing table number for routes", 0, 1, 254),
   CFG_MAP_INT32_MINMAX(olsrv2_routing_domain, distance, "distance", "2",
-      "Metric Distance to be used in routing table", 0, false, 1, 255),
+      "Metric Distance to be used in routing table", 0, 1, 255),
   CFG_MAP_BOOL(olsrv2_routing_domain, source_specific, "source_specific", "true",
       "This domain uses IPv6 source specific routing"),
 };
@@ -189,7 +189,7 @@ static struct cfg_schema_entry _olsrv2_entries[] = {
   CFG_MAP_CLOCK_MIN(_config, p_hold_time, "processing_hold_time", "300.0",
     "Holdtime for processing set information", 100),
   CFG_MAP_INT64_MINMAX(_config, a_hold_time_factor, "advertisement_hold_time_factor", "3",
-    "Holdtime for TC advertisements as a factor of TC interval time", false, false, 1, 255),
+    "Holdtime for TC advertisements as a factor of TC interval time", false, 1, 255),
   CFG_MAP_BOOL(_config, nhdp_routable, "nhdp_routable", "no",
     "Decides if NHDP interface addresses"
     " are routed to other nodes. 'true' means the 'routable_acl' parameter"
index 2282170..936e7ab 100644 (file)
@@ -106,19 +106,19 @@ static void _cb_cfg_changed(void);
 /* plugin declaration */
 static struct cfg_schema_entry _modifier_entries[] = {
   CFG_MAP_INT32_MINMAX(_routemodifier, domain, "domain", "0",
-      "Routing domain id for filter", 0, false, 0, 255),
+      "Routing domain id for filter", 0, 0, 255),
   CFG_MAP_ACL(_routemodifier, filter, "matches",
       ACL_FIRST_REJECT "\0" ACL_DEFAULT_REJECT,
       "Ip addresses the filter should be applied to"),
   CFG_MAP_INT32_MINMAX(_routemodifier, prefix_length, "prefix_length", "-1",
       "Prefix length the filter should be applied to, -1 for any prefix length",
-      0, false, -1, 128),
+      0, -1, 128),
   CFG_MAP_INT32_MINMAX(_routemodifier, table, "table", "0",
-      "Set routing table of matching routes to this value", 0, false, 0, 255),
+      "Set routing table of matching routes to this value", 0, 0, 255),
   CFG_MAP_INT32_MINMAX(_routemodifier, protocol, "protocol", "0",
-      "Set routing protocol of matching routes to this value", 0, false, 0, 255),
+      "Set routing protocol of matching routes to this value", 0, 0, 255),
   CFG_MAP_INT32_MINMAX(_routemodifier, distance, "metric", "0",
-      "Set routing metric of matching routes to this value", 0, false, 0, INT32_MAX),
+      "Set routing metric of matching routes to this value", 0, 0, INT32_MAX),
 };
 
 static struct cfg_schema_section _modifier_section = {
index 9f0ba01..c26d18b 100644 (file)
@@ -116,7 +116,7 @@ enum {
  * @param p_help help text for configuration entry
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_CLOCK(p_reference, p_field, p_name, p_def, p_help, args...)                  CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, false, 0, INT64_MAX, ##args)
+#define CFG_MAP_CLOCK(p_reference, p_field, p_name, p_def, p_help, args...)                  CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, 0, INT64_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a clock value with minimal value that
@@ -130,7 +130,7 @@ enum {
  * @param min minimal allowed clock value
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_CLOCK_MIN(p_reference, p_field, p_name, p_def, p_help, min, args...)         CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, false, min, INT64_MAX, ##args)
+#define CFG_MAP_CLOCK_MIN(p_reference, p_field, p_name, p_def, p_help, min, args...)         CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, min, INT64_MAX, ##args)
 
 /**
  * Creates a cfg_schema_entry for a clock value with maximal value that
@@ -144,7 +144,7 @@ enum {
  * @param max maximal allowed clock value
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_CLOCK_MAX(p_reference, p_field, p_name, p_def, p_help, max, args...)         CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, false, 0, max, ##args)
+#define CFG_MAP_CLOCK_MAX(p_reference, p_field, p_name, p_def, p_help, max, args...)         CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, 0, max, ##args)
 
 /**
  * Creates a cfg_schema_entry for a clock value with minimal
@@ -159,7 +159,7 @@ enum {
  * @param max maximal allowed clock value
  * @param args variable list of additional arguments
  */
-#define CFG_MAP_CLOCK_MINMAX(p_reference, p_field, p_name, p_def, p_help, min, max, args...) CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, false, min, max, ##args)
+#define CFG_MAP_CLOCK_MINMAX(p_reference, p_field, p_name, p_def, p_help, min, max, args...) CFG_MAP_INT64_MINMAX(p_reference, p_field, p_name, p_def, p_help, 3, min, max, ##args)
 
 EXPORT int oonf_clock_update(void) __attribute__((warn_unused_result));
 
@@ -176,7 +176,7 @@ EXPORT const char *oonf_clock_toClockString(struct isonumber_str *, uint64_t);
  */
 static INLINE const char *
 oonf_clock_toIntervalString(struct isonumber_str *buf, int64_t i) {
-  return isonumber_from_s64(buf, i, "", 3, false, true);
+  return isonumber_from_s64(buf, i, "", 3, true);
 }
 
 /**
@@ -191,7 +191,7 @@ oonf_clock_fromIntervalString(uint64_t *result, const char *string) {
   int64_t t;
   int r;
 
-  r = isonumber_to_s64(&t, string, 3, false);
+  r = isonumber_to_s64(&t, string, 3);
   if (r == 0) {
     *result = t;
   }
index 1f0e08d..a4e88cf 100644 (file)
@@ -148,7 +148,7 @@ static struct cfg_schema_entry _http_entries[] = {
   CFG_MAP_ACL_V46(_http_config, smc.bindto,
       "bindto", "127.0.0.1\0" "::1\0" ACL_DEFAULT_REJECT, "Bind http socket to this address"),
   CFG_MAP_INT32_MINMAX(_http_config, smc.port,
-      "port", "1980", "Network port for http interface", 0, false, 1, 65535),
+      "port", "1980", "Network port for http interface", 0, 1, 65535),
   CFG_MAP_STRING(_http_config, www_dir, "webserver", "",
       "Path to map into the /www subdirectory of the HTTP server, empty path"
       " feature will be disabled"),
index 42e0276..787e82f 100644 (file)
@@ -84,15 +84,15 @@ DECLARE_OONF_PLUGIN(_oonf_layer2_subsystem);
 static const struct oonf_layer2_metadata _oonf_layer2_metadata_neigh[OONF_LAYER2_NEIGH_COUNT] = {
   [OONF_LAYER2_NEIGH_TX_SIGNAL]      = { .key = "tx_signal", .type = OONF_LAYER2_INTEGER_DATA, .unit = "dBm", .fraction = 3 },
   [OONF_LAYER2_NEIGH_RX_SIGNAL]      = { .key = "rx_signal", .type = OONF_LAYER2_INTEGER_DATA, .unit = "dBm", .fraction = 3 },
-  [OONF_LAYER2_NEIGH_TX_BITRATE]     = { .key = "tx_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s", .binary = true },
-  [OONF_LAYER2_NEIGH_RX_BITRATE]     = { .key = "rx_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s", .binary = true },
-  [OONF_LAYER2_NEIGH_TX_MAX_BITRATE] = { .key = "tx_max_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s", .binary = true },
-  [OONF_LAYER2_NEIGH_RX_MAX_BITRATE] = { .key = "rx_max_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s", .binary = true },
-  [OONF_LAYER2_NEIGH_TX_BYTES]       = { .key = "tx_bytes", .type = OONF_LAYER2_INTEGER_DATA, .unit = "byte", .binary = true },
-  [OONF_LAYER2_NEIGH_RX_BYTES]       = { .key = "rx_bytes", .type = OONF_LAYER2_INTEGER_DATA, .unit = "byte", .binary = true },
+  [OONF_LAYER2_NEIGH_TX_BITRATE]     = { .key = "tx_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s" },
+  [OONF_LAYER2_NEIGH_RX_BITRATE]     = { .key = "rx_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s" },
+  [OONF_LAYER2_NEIGH_TX_MAX_BITRATE] = { .key = "tx_max_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s" },
+  [OONF_LAYER2_NEIGH_RX_MAX_BITRATE] = { .key = "rx_max_bitrate", .type = OONF_LAYER2_INTEGER_DATA, .unit = "bit/s" },
+  [OONF_LAYER2_NEIGH_TX_BYTES]       = { .key = "tx_bytes", .type = OONF_LAYER2_INTEGER_DATA, .unit = "byte" },
+  [OONF_LAYER2_NEIGH_RX_BYTES]       = { .key = "rx_bytes", .type = OONF_LAYER2_INTEGER_DATA, .unit = "byte" },
   [OONF_LAYER2_NEIGH_TX_FRAMES]      = { .key = "tx_frames", .type = OONF_LAYER2_INTEGER_DATA },
   [OONF_LAYER2_NEIGH_RX_FRAMES]      = { .key = "rx_frames", .type = OONF_LAYER2_INTEGER_DATA  },
-  [OONF_LAYER2_NEIGH_TX_THROUGHPUT]  = { .key = "tx_throughput", .type = OONF_LAYER2_INTEGER_DATA , .unit = "bit/s", .binary = true },
+  [OONF_LAYER2_NEIGH_TX_THROUGHPUT]  = { .key = "tx_throughput", .type = OONF_LAYER2_INTEGER_DATA , .unit = "bit/s" },
   [OONF_LAYER2_NEIGH_TX_RETRIES]     = { .key = "tx_retries", .type = OONF_LAYER2_INTEGER_DATA },
   [OONF_LAYER2_NEIGH_TX_FAILED]      = { .key = "tx_failed", .type = OONF_LAYER2_INTEGER_DATA  },
   [OONF_LAYER2_NEIGH_LATENCY]        = { .key = "latency", .type = OONF_LAYER2_INTEGER_DATA , .unit = "s", .fraction = 6 },
@@ -226,7 +226,7 @@ oonf_layer2_data_parse_string(union oonf_layer2_value *value,
   switch (meta->type) {
     case OONF_LAYER2_INTEGER_DATA:
       return isonumber_to_s64(
-          &value->integer, input, meta->fraction, meta->binary);
+          &value->integer, input, meta->fraction);
 
     case OONF_LAYER2_BOOLEAN_DATA:
         value->boolean = cfg_get_bool(input);
@@ -246,7 +246,7 @@ oonf_layer2_data_to_string(char *buffer, size_t length,
   switch (meta->type) {
     case OONF_LAYER2_INTEGER_DATA:
       if (!isonumber_from_s64(&iso_str, data->_value.integer,
-          meta->unit, meta->fraction, meta->binary, raw)) {
+          meta->unit, meta->fraction, raw)) {
         return -1;
       }
       strscpy(buffer, iso_str.buf, length);
index af33d94..d630076 100644 (file)
@@ -136,9 +136,6 @@ struct oonf_layer2_metadata {
 
   /*! number of fractional digits of the data */
   const int fraction;
-
-  /*! true if data is "base" 1024 instead of "base" 1000 */
-  const bool binary;
 };
 
 /**
index 86024ad..e656877 100644 (file)
@@ -177,9 +177,9 @@ static struct oonf_timer_class _aggregation_timer = {
 /* configuration settings for handler */
 static struct cfg_schema_entry _rfc5444_entries[] = {
   CFG_MAP_INT32_MINMAX(_rfc5444_config, port, "port", RFC5444_MANET_UDP_PORT_TXT,
-    "UDP port for RFC5444 interface", 0, false, 1, 65535),
+    "UDP port for RFC5444 interface", 0, 1, 65535),
   CFG_MAP_INT32_MINMAX(_rfc5444_config, ip_proto, "ip_proto", RFC5444_MANET_IPPROTO_TXT,
-    "IP protocol for RFC5444 interface", 0, false, 1, 255),
+    "IP protocol for RFC5444 interface", 0, 1, 255),
 };
 
 static struct cfg_schema_section _rfc5444_section = {
@@ -201,11 +201,11 @@ static struct cfg_schema_entry _interface_entries[] = {
   CFG_MAP_NETADDR_V6(_rfc5444_if_config, sock.multicast_v6, "multicast_v6", RFC5444_MANET_MULTICAST_V6_TXT,
     "ipv6 multicast address of this socket", false, true),
   CFG_MAP_INT32_MINMAX(_rfc5444_if_config, sock.dscp, "dscp", "192",
-    "DSCP field for outgoing UDP protocol traffic", 0, false, 0, 255),
+    "DSCP field for outgoing UDP protocol traffic", 0, 0, 255),
   CFG_MAP_BOOL(_rfc5444_if_config, sock.rawip, "rawip", "false",
     "True if a raw IP socket should be used, false to use UDP"),
   CFG_MAP_INT32_MINMAX(_rfc5444_if_config, sock.ttl_multicast, "multicast_ttl", "1",
-    "TTL value of outgoing multicast traffic", 0, false, 1, 255),
+    "TTL value of outgoing multicast traffic", 0, 1, 255),
   CFG_MAP_CLOCK(_rfc5444_if_config, aggregation_interval, "aggregation_interval", "0.100",
     "Interval in seconds for message aggregation"),
 
index ca1dc13..199691a 100644 (file)
@@ -101,9 +101,9 @@ static struct cfg_schema_entry _telnet_entries[] = {
   CFG_MAP_ACL(_telnet_config, osmc.bindto,
       "bindto", "127.0.0.1\0" "::1\0" ACL_DEFAULT_REJECT, "Allowed addressed to bind telnet socket to"),
   CFG_MAP_INT32_MINMAX(_telnet_config, osmc.port,
-      "port", "2009", "Network port for telnet interface", 0, false, 1, 65535),
+      "port", "2009", "Network port for telnet interface", 0, 1, 65535),
   CFG_MAP_INT32_MINMAX(_telnet_config, allowed_sessions,
-      "allowed_sessions", "3", "Maximum number of allowed simultaneous sessions",0, false, 3, 1024),
+      "allowed_sessions", "3", "Maximum number of allowed simultaneous sessions",0, 3, 1024),
   CFG_MAP_CLOCK(_telnet_config, timeout,
       "timeout", "120000", "Time until a telnet session is closed when idle"),
 };
index 85ff637..4475658 100644 (file)
@@ -57,23 +57,15 @@ clear_elements(void) {
 }
 
 static void
-test_str_to_isonumber_u64(void) {
-  static const char *results[2][3][5] = {
-    {
+test_str_from_isonumber_u64(void) {
+  static const char *results[3][5] = {
       { "999", "1.023k", "999.999k", "1.023M",  "1.048M" },
       { "1k", "1.024k", "1M", "1.024M", "1.048M" },
       { "1.001k", "1.025k", "1M", "1.024M", "1.048M" }
-    },
-    {
-      { "999", "1023", "976.561k", "999.999k", "1023.999k" },
-      { "1000", "1k",  "976.562k", "1000k", "1M" },
-      { "1001", "1k", "976.563k", "1000k", "1M" }
-    }
   };
   static uint64_t tests[] = { 1000, 1024, 1000*1000, 1000*1024, 1024*1024 };
   struct isonumber_str buf;
   uint64_t diff;
-  int binary;
   size_t i;
 
   const char *tmp;
@@ -81,42 +73,87 @@ test_str_to_isonumber_u64(void) {
 
   START_TEST();
 
-  for (binary=0; binary < 2; binary++) {
-    for (diff=0; diff < 3; diff++) {
-      for (i=0; i<ARRAYSIZE(tests); i++) {
-       tmp = isonumber_from_u64(&buf, tests[i]+diff-1, NULL, 0, binary==1, false);
-       correct = tmp != NULL && strcmp(tmp, results[binary][diff][i]) == 0;
-
-       CHECK_TRUE(tmp != NULL, "str_to_isonumber_u64(%"PRIu64", %s) is not null",
-                       tests[i]+diff-1, binary == 1 ? "binary" : "normal");
-       CHECK_TRUE(correct, "str_to_isonumber_u64(%"PRIu64", %s) = %s should be %s",
-                       tests[i]+diff-1, binary == 1 ? "binary" : "normal",
-                       tmp, results[binary][diff][i]);
-      }
-       }
+  for (diff=0; diff < 3; diff++) {
+    for (i=0; i<5; i++) {
+      tmp = isonumber_from_u64(&buf, tests[i]+diff-1, NULL, 0, false);
+      correct = tmp != NULL && strcmp(tmp, results[diff][i]) == 0;
+
+      CHECK_TRUE(tmp != NULL, "isonumber_from_u64(%"PRIu64") is not null",
+          tests[i]+diff-1);
+       CHECK_TRUE(correct, "isonumber_from_u64(%"PRIu64") = %s should be %s",
+                       tests[i]+diff-1, tmp, results[diff][i]);
+    }
+  }
+
+  END_TEST();
+}
+
+static void
+test_isonumber_to_u64_to_string(void) {
+  static const char *tests[] = {
+      "1k", "1.024k", "1M", "1.024M", "1.023k"
+  };
+  static uint64_t results[] = { 1000, 1024, 1000*1000, 1000*1024, 1023 };
+
+  size_t i;
+
+  uint64_t result;
+  int tmp;
+
+  START_TEST();
+
+  for (i=0; i<ARRAYSIZE(tests); i++) {
+    result = 0;
+    tmp = isonumber_to_u64(&result, tests[i], 0);
+    CHECK_TRUE(tmp == 0, "isonumber_to_u64(\"%s\") failed", tests[i]);
+    if (!tmp) {
+      CHECK_TRUE(result== results[i], "isonumber_to_u64(\"%s\") != %"PRIu64" (was %"PRIu64")",
+          tests[i], results[i], result);
+    }
   }
+  END_TEST();
+}
+
+static void
+test_isonumber_to_s64_to_string(void) {
+  static const char *tests[] = {
+       "1k",  "1.024k",  "1M",  "1.024M",  "1.023k",
+      "-1k", "-1.024k", "-1M", "-1.024M", "-1.023k"
+  };
+  static int64_t results[] = {
+       1000,  1024,  1000*1000,  1000*1024,  1023,
+      -1000, -1024, -1000*1000, -1000*1024, -1023
+  };
+
+  size_t i;
+
+  int64_t result;
+  int tmp;
 
+  START_TEST();
+
+  for (i=0; i<ARRAYSIZE(tests); i++) {
+    result = 0;
+    tmp = isonumber_to_s64(&result, tests[i], 0);
+    CHECK_TRUE(tmp == 0, "isonumber_to_u64(\"%s\") failed", tests[i]);
+    if (!tmp) {
+      CHECK_TRUE(result== results[i], "isonumber_to_u64(\"%s\") != %"PRId64" (was %"PRId64")",
+          tests[i], results[i], result);
+    }
+  }
   END_TEST();
 }
 
 static void
-test_str_to_isonumber_s64(void) {
-  static const char *results[2][3][5] = {
-    {
+test_str_from_isonumber_s64(void) {
+  static const char *results[3][5] = {
       { "-999", "-1.023k", "-999.999k", "-1.023M",  "-1.048M" },
       { "-1k", "-1.024k", "-1M", "-1.024M", "-1.048M" },
       { "-1.001k", "-1.025k", "-1M", "-1.024M", "-1.048M" }
-    },
-    {
-      { "-999", "-1023", "-976.561k", "-999.999k", "-1023.999k" },
-      { "-1000", "-1k",  "-976.562k", "-1000k", "-1M" },
-      { "-1001", "-1k", "-976.563k", "-1000k", "-1M" }
-    }
   };
   static int64_t tests[] = { -1000, -1024, -1000*1000, -1000*1024, -1024*1024 };
   struct isonumber_str buf;
   uint64_t diff;
-  int binary;
   size_t i;
 
   const char *tmp;
@@ -124,32 +161,30 @@ test_str_to_isonumber_s64(void) {
 
   START_TEST();
 
-  for (binary=0; binary < 2; binary++) {
-    for (diff=0; diff < 3; diff++) {
-      for (i=0; i<ARRAYSIZE(tests); i++) {
-       tmp = isonumber_from_s64(&buf, tests[i]-diff+1, NULL, 0, binary==1, false);
-       correct = tmp != NULL && strcmp(tmp, results[binary][diff][i]) == 0;
-
-       CHECK_TRUE(tmp != NULL, "str_to_isonumber_s64(%"PRId64", %s) is not null",
-                       tests[i]-diff+1, binary == 1 ? "binary" : "normal");
-       CHECK_TRUE(correct, "str_to_isonumber_s64(%"PRId64", %s) = %s should be %s",
-                       tests[i]-diff+1, binary == 1 ? "binary" : "normal",
-                       tmp, results[binary][diff][i]);
-      }
-       }
+  for (diff=0; diff < 3; diff++) {
+    for (i=0; i<5; i++) {
+      tmp = isonumber_from_s64(&buf, tests[i]-diff+1, NULL, 0, false);
+      correct = tmp != NULL && strcmp(tmp, results[diff][i]) == 0;
+
+      CHECK_TRUE(tmp != NULL, "str_to_isonumber_s64(%"PRId64") is not null",
+          tests[i]-diff+1);
+      CHECK_TRUE(correct, "str_to_isonumber_s64(%"PRId64") = %s should be %s",
+          tests[i]-diff+1,
+               tmp, results[diff][i]);
+    }
   }
 
   END_TEST();
 }
 
 static void
-test_str_to_isonumber_s64_2(void) {
+test_str_from_isonumber_s64_2(void) {
   struct isonumber_str buf;
   START_TEST();
 
   CHECK_TRUE(
       isonumber_from_s64(&buf,
-          5185050545986994176ll, "bit/s", 0, true, false) != NULL, "test");
+          5185050545986994176ll, "bit/s", 0, false) != NULL, "test");
   END_TEST();
 }
 
@@ -157,9 +192,12 @@ int
 main(int argc __attribute__ ((unused)), char **argv __attribute__ ((unused))) {
   BEGIN_TESTING(clear_elements);
 
-  test_str_to_isonumber_u64();
-  test_str_to_isonumber_s64();
-  test_str_to_isonumber_s64_2();
+  test_str_from_isonumber_u64();
+  test_isonumber_to_u64_to_string();
+
+  test_str_from_isonumber_s64();
+  test_isonumber_to_s64_to_string();
+  test_str_from_isonumber_s64_2();
 
   return FINISH_TESTING();
 }
index bf78b17..55fa247 100644 (file)
@@ -87,8 +87,8 @@ static struct cfg_schema_entry entries[] = {
   CFG_MAP_STRING(bin_data, string, "string", "a string", "help string"),
   CFG_MAP_STRING_ARRAY(bin_data, string_array, "string_array", "test", "help string array", 5),
   CFG_MAP_CHOICE(bin_data, choice, "choice", "choice1", "help choice", choices),
-  CFG_MAP_INT32(bin_data, integer, "integer", "3", "help int", 0, false),
-  CFG_MAP_INT32(bin_data, fractional, "fractional", "2.718", "help frac", 4, false),
+  CFG_MAP_INT32(bin_data, integer, "integer", "3", "help int", 0),
+  CFG_MAP_INT32(bin_data, fractional, "fractional", "2.718", "help frac", 4),
   CFG_MAP_NETADDR(bin_data, address, "address", "10.0.0.1", "help ip", false, false),
   CFG_MAP_BOOL(bin_data, boolean, "boolean", "0", "help bool")
 };
@@ -161,7 +161,7 @@ test_binary_mapping(void) {
       CHECK_TRUE(data.choice == 1, "Choice is not '1' but '%d'", data.choice);
       CHECK_TRUE(data.integer == 42, "Integer is not '42' but '%d'", data.integer);
       CHECK_TRUE(data.fractional == -31415, "Integer is not '-3.1415' but '%s'",
-          isonumber_from_s64(&fbuf, data.fractional, "", 4, false, true));
+          isonumber_from_s64(&fbuf, data.fractional, "", 4, true));
       CHECK_TRUE(memcmp(netaddr_get_binptr(&data.address), IP_10_coloncolon_1, 16) == 0,
           "Netaddr Address part is not consistent");
       CHECK_TRUE(netaddr_get_prefix_length(&data.address) == 128,