utils: tests: Implement binary bytes conversion function

size_to_byte function just converts with 1000(K), 1000*K, 1000*M.
But this function converts with 1024(KiB), 1024*KiB(MiB), and
1024*MiB(GiB).

Signed-off-by: Hiroshi Hatake <[email protected]>

Author: cosmo0920

include/fluent-bit/flb_utils.h

@@ -49,6 +49,7 @@ void flb_utils_split_free_entry(struct flb_split_entry *entry);
 void flb_utils_split_free(struct mk_list *list);
 int flb_utils_timer_consume(flb_pipefd_t fd);
 int64_t flb_utils_size_to_bytes(const char *size);
+int64_t flb_utils_size_to_binary_bytes(const char *size);
 int64_t flb_utils_hex2int(char *hex, int len);
 int flb_utils_time_to_seconds(const char *time);
 int flb_utils_pipe_byte_consume(flb_pipefd_t fd);

src/flb_utils.c

@@ -607,6 +607,92 @@ int64_t flb_utils_size_to_bytes(const char *size)
     return (int64_t)val;
 }
 
+int64_t flb_utils_size_to_binary_bytes(const char *size)
+{
+    int i;
+    int len;
+    int plen = 0;
+    double val;
+    char tmp[4] = {0};
+    int64_t KiB = 1024;
+    int64_t MiB = 1024 * KiB;
+    int64_t GiB = 1024 * MiB;
+
+    if (!size) {
+        return -1;
+    }
+
+    if (strcasecmp(size, "false") == 0) {
+        return 0;
+    }
+
+    len = strlen(size);
+    val = atof(size);
+
+    if (len == 0) {
+        return -1;
+    }
+
+    for (i = len - 1; i >= 0; i--) {
+        if (isalpha(size[i])) {
+            plen++;
+        }
+        else {
+            break;
+        }
+    }
+
+    if (plen == 0) {
+        return (int64_t)val;
+    }
+    else if (plen > 3) {
+        return -1;
+    }
+
+    for (i = 0; i < plen; i++) {
+        tmp[i] = toupper(size[len - plen + i]);
+    }
+
+    if (plen == 2) {
+        if (tmp[1] != 'B') {
+            return -1;
+        }
+    }
+    if (plen == 3) {
+        if (tmp[1] != 'I' || tmp[2] != 'B') {
+            return -1;
+        }
+    }
+
+    if (tmp[0] == 'K') {
+        /* set upper bound (2**64/KiB)/2 to avoid overflows */
+        if (val >= 9223372036854775.0 || val <= -9223372036854774.0)
+        {
+            return -1;
+        }
+        return (int64_t)(val * KiB);
+    }
+    else if (tmp[0] == 'M') {
+        /* set upper bound (2**64/MiB)/2 to avoid overflows */
+        if (val >= 9223372036854.0 || val <= -9223372036853.0) {
+            return -1;
+        }
+        return (int64_t)(val * MiB);
+    }
+    else if (tmp[0] == 'G') {
+        /* set upper bound (2**64/GiB)/2 to avoid overflows */
+        if (val >= 9223372036.0 || val <= -9223372035.0) {
+            return -1;
+        }
+        return (int64_t)(val * GiB);
+    }
+    else {
+        return -1;
+    }
+
+    return (int64_t)val;
+}
+
 int64_t flb_utils_hex2int(char *hex, int len)
 {
     int i = 0;

tests/internal/utils.c

@@ -798,6 +798,45 @@ void test_size_to_bytes()
     }
 }
 
+struct size_to_bytes_check size_to_binary_bytes_checks[] = {
+    {"922337.63", 922337},
+    {"2K",2048},
+    {"5.7263K", 5863},
+    {"5.7263KB", 5863},
+    {"5.7263KiB", 5863},
+    {"9223372036854775.23K", -1},
+    {"1M", 1048576},
+    {"1.1M", 1153433},
+    {"1.1MB", 1153433},
+    {"1.1MiB", 1153433},
+    {"3.592M", 3766484},
+    {"52.752383M", 55314882},
+    {"52.752383MB", 55314882},
+    {"52.752383MiB", 55314882},
+    {"9223372036854.42M", -1},
+    {"492.364G",528671819431},
+    {"492.364GB",528671819431},
+    {"492.364GiB",528671819431},
+    {"1.2973G", 1392965268},
+    {"9223372036.78G", -1},
+};
+
+void test_size_to_binary_bytes()
+{
+    int i;
+    int size;
+    int64_t ret;
+    struct size_to_bytes_check *u;
+
+    size = sizeof(size_to_binary_bytes_checks) / sizeof(struct size_to_bytes_check);
+    for (i = 0; i < size; i++) {
+        u = &size_to_binary_bytes_checks[i];
+
+        ret = flb_utils_size_to_binary_bytes(u->size);
+        TEST_CHECK_(ret == u->ret, "ret = %zu, u->ret = %zu", ret, u->ret);
+    }
+}
+
 TEST_LIST = {
     /* JSON maps iteration */
     { "url_split", test_url_split },
@@ -815,5 +854,6 @@ TEST_LIST = {
     { "test_flb_utils_split_quoted_errors", test_flb_utils_split_quoted_errors},
     { "test_flb_utils_get_machine_id", test_flb_utils_get_machine_id },
     { "test_size_to_bytes", test_size_to_bytes },
+    { "test_size_to_bianry_bytes", test_size_to_binary_bytes },
     { 0 }
 };