diff --git a/Makefile.dep b/Makefile.dep
index e0f0641169df1fb615f71c7685d888472b58d72e..4011310d126be4d53da0c9e0a42ed585baf3d527 100644
--- a/Makefile.dep
+++ b/Makefile.dep
@@ -789,6 +789,7 @@ endif
ifneq (,$(filter uuid,$(USEMODULE)))
USEMODULE += hashes
USEMODULE += random
+ USEMODULE += fmt
endif
# Enable periph_gpio when periph_gpio_irq is enabled
diff --git a/sys/fmt/fmt.c b/sys/fmt/fmt.c
index 58aa01483b45a4cc13ef744371e622d09a4af3af..df79a40f4e50a5c377c9e6d86cdc8832e0e23b1f 100644
--- a/sys/fmt/fmt.c
+++ b/sys/fmt/fmt.c
@@ -53,6 +53,16 @@ static inline int _is_digit(char c)
return (c >= '0' && c <= '9');
}
+static inline int _is_upper(char c)
+{
+ return (c >= 'A' && c <= 'Z');
+}
+
+static inline char _to_lower(char c)
+{
+ return 'a' + (c - 'A');
+}
+
size_t fmt_byte_hex(char *out, uint8_t byte)
{
if (out) {
@@ -153,6 +163,11 @@ size_t fmt_hex_bytes(uint8_t *out, const char *hex)
return final_len;
}
+size_t fmt_u16_hex(char *out, uint16_t val)
+{
+ return fmt_bytes_hex_reverse(out, (uint8_t*) &val, 2);
+}
+
size_t fmt_u32_hex(char *out, uint32_t val)
{
return fmt_bytes_hex_reverse(out, (uint8_t*) &val, 4);
@@ -400,6 +415,35 @@ size_t fmt_lpad(char *out, size_t in_len, size_t pad_len, char pad_char)
return pad_len;
}
+size_t fmt_char(char *out, char c)
+{
+ if (out) {
+ *out = c;
+ }
+
+ return 1;
+}
+
+size_t fmt_to_lower(char *out, const char *str)
+{
+ size_t len = 0;
+
+ while (str && *str) {
+ if (_is_upper(*str)) {
+ if (out) {
+ *out++ = _to_lower(*str);
+ }
+ }
+ else if (out) {
+ *out++ = *str;
+ }
+ str++;
+ len++;
+ }
+
+ return len;
+}
+
uint32_t scn_u32_dec(const char *str, size_t n)
{
uint32_t res = 0;
@@ -416,6 +460,30 @@ uint32_t scn_u32_dec(const char *str, size_t n)
return res;
}
+uint32_t scn_u32_hex(const char *str, size_t n)
+{
+ uint32_t res = 0;
+
+ while (n--) {
+ char c = *str++;
+ if (!_is_digit(c)) {
+ if (_is_upper(c)) {
+ c = _to_lower(c);
+ }
+ if (c == '\0' || c > 'f') {
+ break;
+ }
+ res <<= 4;
+ res |= c - 'a' + 0xa;
+ }
+ else {
+ res <<= 4;
+ res |= c - '0';
+ }
+ }
+ return res;
+}
+
void print(const char *s, size_t n)
{
#ifdef __WITH_AVRLIBC__
diff --git a/sys/include/fmt.h b/sys/include/fmt.h
index 7176494d3098f6071807d8d75e69f8071f5a718f..b1e0a286bb2f8beffb8fa14bf19cbb6bf70d91ca 100644
--- a/sys/include/fmt.h
+++ b/sys/include/fmt.h
@@ -119,6 +119,20 @@ uint8_t fmt_hex_byte(const char *hex);
*/
size_t fmt_hex_bytes(uint8_t *out, const char *hex);
+/**
+ * @brief Convert a uint16 value to hex string.
+ *
+ * Will write 4 bytes to @p out.
+ * If @p out is NULL, will only return the number of bytes that would have
+ * been written.
+ *
+ * @param[out] out Pointer to output buffer, or NULL
+ * @param[in] val Value to convert
+ *
+ * @return 4
+ */
+size_t fmt_u16_hex(char *out, uint16_t val);
+
/**
* @brief Convert a uint32 value to hex string.
*
@@ -296,6 +310,19 @@ size_t fmt_s32_dfp(char *out, int32_t val, int fp_digits);
*/
size_t fmt_float(char *out, float f, unsigned precision);
+/**
+ * @brief Copy @p in char to string (without terminating '\0')
+ *
+ * If @p out is NULL, will only return the number of bytes that would have
+ * been written.
+ *
+ * @param[out] out string to write to (or NULL)
+ * @param[in] c char value to append
+ *
+ * @return nr of bytes the function did or would write to out
+ */
+size_t fmt_char(char *out, char c);
+
/**
* @brief Count characters until '\0' (exclusive) in @p str
*
@@ -329,6 +356,14 @@ size_t fmt_strnlen(const char *str, size_t maxlen);
*/
size_t fmt_str(char *out, const char *str);
+/**
+ * @brief Copy null-terminated string to a lowercase string (excluding terminating \0)
+ *
+ * @param[out] out Pointer to output buffer, or NULL
+ * @param[in] str Pointer to null-terminated source string
+ */
+size_t fmt_to_lower(char *out, const char *str);
+
/**
* @brief Convert digits to uint32
*
@@ -341,6 +376,18 @@ size_t fmt_str(char *out, const char *str);
*/
uint32_t scn_u32_dec(const char *str, size_t n);
+/**
+ * @brief Convert hexadecimal characters to uin32_t
+ *
+ * Will convert up to @p n char. Stop at any non-hexadecimal or '\0' character
+ *
+ * @param[in] str Pointer to tring to read from
+ * @param[in] n Maximum number of characters to consider
+ *
+ * @return converted uint32_t value
+ */
+uint32_t scn_u32_hex(const char *str, size_t n);
+
/**
* @brief Print string to stdout
*
diff --git a/sys/include/uuid.h b/sys/include/uuid.h
index 2616ebd3b4beab5f77afa2c10b61dd442a64dfd5..ac050278aa5c0983dbb55620ce2ceefc6db60c89 100644
--- a/sys/include/uuid.h
+++ b/sys/include/uuid.h
@@ -38,6 +38,8 @@ extern "C" {
#define UUID_NODE_LEN (6U) /**< Size of the node identifier in bytes */
+#define UUID_STR_LEN (36U) /**< Size of a string UUID without null character */
+
/**
* @name UUID version identifiers
* @{
@@ -120,7 +122,7 @@ void uuid_v5(uuid_t *uuid, const uuid_t *ns, const uint8_t *name, size_t len);
*
* @return Version number
*/
-static inline unsigned uuid_version(uuid_t *uuid)
+static inline unsigned uuid_version(const uuid_t *uuid)
{
uint16_t time_hi_vers = byteorder_ntohs(uuid->time_hi);
@@ -135,11 +137,29 @@ static inline unsigned uuid_version(uuid_t *uuid)
*
* @return True when equal
*/
-static inline bool uuid_equal(uuid_t *uuid1, uuid_t *uuid2)
+static inline bool uuid_equal(const uuid_t *uuid1, const uuid_t *uuid2)
{
return (memcmp(uuid1, uuid2, sizeof(uuid_t)) == 0);
}
+/**
+ * @brief Generate an UUID string from an UUID structure
+ *
+ * @param[in] uuid UUID
+ * @param[out] str null-terminated UUID string, must be at least UUID_STR_LEN + 1 bytes
+ */
+void uuid_to_string(const uuid_t *uuid, char *str);
+
+/**
+ * @brief Populate an UUID structure from an UUID string
+ *
+ * @param[out] uuid out UUID
+ * @param[in] str null-terminated input UUID string, must be UUID_STR_LEN bytes
+ *
+ * @return 0 on succes, < 0 if @p str is not valid
+ */
+int uuid_from_string(uuid_t *uuid, const char *str);
+
#ifdef __cplusplus
}
#endif
diff --git a/sys/uuid/uuid.c b/sys/uuid/uuid.c
index a7c9c95e4073c5413c414c627d25328bc881dba3..464586dcbefcd84b1bd35f48229476485bd1f5e4 100644
--- a/sys/uuid/uuid.c
+++ b/sys/uuid/uuid.c
@@ -23,6 +23,7 @@
#include "hashes/sha1.h"
#include "random.h"
#include "uuid.h"
+#include "fmt.h"
const uuid_t uuid_namespace_dns = { /* 6ba7b810-9dad-11d1-80b4-00c04fd430c8 */
.time_low.u8 = { 0x6b, 0xa7, 0xb8, 0x10 },
@@ -110,3 +111,59 @@ void uuid_v5(uuid_t *uuid, const uuid_t *ns, const uint8_t *name, size_t len)
_set_version(uuid, UUID_V5);
_set_reserved(uuid);
}
+
+void uuid_to_string(const uuid_t *uuid, char *str)
+{
+ char *p = str;
+ p += fmt_u32_hex(p, byteorder_ntohl(uuid->time_low));
+ p += fmt_char(p, '-');
+ p += fmt_u16_hex(p, byteorder_ntohs(uuid->time_mid));
+ p += fmt_char(p, '-');
+ p += fmt_u16_hex(p, byteorder_ntohs(uuid->time_hi));
+ p += fmt_char(p, '-');
+ p += fmt_byte_hex(p, uuid->clk_seq_hi_res);
+ p += fmt_byte_hex(p, uuid->clk_seq_low);
+ p += fmt_char(p, '-');
+ p += fmt_bytes_hex(p, uuid->node, UUID_NODE_LEN);
+ *p = '\0';
+ fmt_to_lower(str, str);
+}
+
+int uuid_from_string(uuid_t *uuid, const char *str)
+{
+ uint32_t tmp;
+ if (fmt_strlen(str) < UUID_STR_LEN) {
+ return -1;
+ }
+ tmp = scn_u32_hex(str, 8);
+ uuid->time_low = byteorder_htonl(tmp);
+ str += 8;
+ if (*str++ != '-') {
+ return -2;
+ }
+ tmp = scn_u32_hex(str, 4);
+ uuid->time_mid = byteorder_htons(tmp);
+ str += 4;
+ if (*str++ != '-') {
+ return -2;
+ }
+ tmp = scn_u32_hex(str, 4);
+ uuid->time_hi = byteorder_htons(tmp);
+ str += 4;
+ if (*str++ != '-') {
+ return -2;
+ }
+ uuid->clk_seq_hi_res = scn_u32_hex(str, 2);
+ str += 2;
+ uuid->clk_seq_low = scn_u32_hex(str, 2);
+ str += 2;
+ if (*str++ != '-') {
+ return -2;
+ }
+ for (unsigned i = 0; i < UUID_NODE_LEN; i++) {
+ uuid->node[i] = scn_u32_hex(str, 2);
+ str += 2;
+ }
+
+ return 0;
+}
diff --git a/tests/unittests/tests-fmt/tests-fmt.c b/tests/unittests/tests-fmt/tests-fmt.c
index 0a7d537828c19432d58f74bee427413fbd907cd6..8126beafccd3ced62edb818e8ce4325cc071f846 100644
--- a/tests/unittests/tests-fmt/tests-fmt.c
+++ b/tests/unittests/tests-fmt/tests-fmt.c
@@ -749,6 +749,26 @@ static void test_fmt_str(void)
TEST_ASSERT_EQUAL_STRING(string1, &string2[0]);
}
+static void test_fmt_char(void)
+{
+ char string[] = "zzzzzzzzz";
+
+ TEST_ASSERT_EQUAL_INT(1, fmt_char(NULL, 'c'));
+ TEST_ASSERT_EQUAL_INT(1, fmt_char(string, 'c'));
+ string[1] = '\0';
+ TEST_ASSERT_EQUAL_STRING("c", &string[0]);
+}
+
+static void test_fmt_to_lower(void)
+{
+ const char string_up[] = "AbCdeFGHijkLM";
+ char string[] = "zzzzzzzzzzzzzzz";
+
+ TEST_ASSERT_EQUAL_INT(fmt_strlen(string_up), fmt_to_lower(string, string_up));
+ string[fmt_strlen(string_up)] = '\0';
+ TEST_ASSERT_EQUAL_STRING("abcdefghijklm", &string[0]);
+}
+
static void test_scn_u32_dec(void)
{
const char *string1 = "123456789";
@@ -759,6 +779,17 @@ static void test_scn_u32_dec(void)
TEST_ASSERT_EQUAL_INT(val2, scn_u32_dec(string1, 5));
}
+static void test_scn_u32_hex(void)
+{
+ const char *string1 = "aB12cE4F";
+ uint32_t val1 = 0xab12ce4f;
+ uint32_t val2 = 0xab1;
+
+ TEST_ASSERT_EQUAL_INT(val1, scn_u32_hex(string1, 8));
+ TEST_ASSERT_EQUAL_INT(val2, scn_u32_hex(string1, 3));
+ TEST_ASSERT_EQUAL_INT(val1, scn_u32_hex(string1, 9));
+}
+
static void test_fmt_lpad(void)
{
const char base[] = "abcd";
@@ -817,7 +848,10 @@ Test *tests_fmt_tests(void)
new_TestFixture(test_fmt_strlen),
new_TestFixture(test_fmt_strnlen),
new_TestFixture(test_fmt_str),
+ new_TestFixture(test_fmt_char),
+ new_TestFixture(test_fmt_to_lower),
new_TestFixture(test_scn_u32_dec),
+ new_TestFixture(test_scn_u32_hex),
new_TestFixture(test_fmt_lpad),
};
diff --git a/tests/unittests/tests-uuid/tests-uuid.c b/tests/unittests/tests-uuid/tests-uuid.c
index 0552d24ae877ed175d31f26f21bcfedde12539da..f0b98bd8c9cc74740e7a350db167e9cb9826808b 100644
--- a/tests/unittests/tests-uuid/tests-uuid.c
+++ b/tests/unittests/tests-uuid/tests-uuid.c
@@ -95,12 +95,46 @@ void test_uuid_v5(void)
TEST_ASSERT_EQUAL_INT(uuid_version(&uuid_next), UUID_V5);
}
+void test_uuid_str(void)
+{
+ char str[40];
+ const char dns[] = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+ uuid_to_string(&uuid_namespace_dns, str);
+ TEST_ASSERT_EQUAL_INT(0, memcmp(dns, str, sizeof(dns)));
+
+ const char url[] = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+ uuid_to_string(&uuid_namespace_url, str);
+ TEST_ASSERT_EQUAL_INT(0, memcmp(url, str, sizeof(dns)));
+
+ const char iso[] = "6ba7b812-9dad-11d1-80b4-00c04fd430c8";
+ uuid_to_string(&uuid_namespace_iso, str);
+ TEST_ASSERT_EQUAL_INT(0, memcmp(iso, str, sizeof(dns)));
+
+ const char x500[] = "6ba7b814-9dad-11d1-80b4-00c04fd430c8";
+ uuid_to_string(&uuid_namespace_x500, str);
+ TEST_ASSERT_EQUAL_INT(0, memcmp(x500, str, sizeof(dns)));
+
+ uuid_t uuid;
+ TEST_ASSERT_EQUAL_INT(0, uuid_from_string(&uuid, dns));
+ TEST_ASSERT_EQUAL_INT(true, uuid_equal(&uuid, &uuid_namespace_dns));
+
+ TEST_ASSERT_EQUAL_INT(0, uuid_from_string(&uuid, url));
+ TEST_ASSERT_EQUAL_INT(true, uuid_equal(&uuid, &uuid_namespace_url));
+
+ TEST_ASSERT_EQUAL_INT(0, uuid_from_string(&uuid, iso));
+ TEST_ASSERT_EQUAL_INT(true, uuid_equal(&uuid, &uuid_namespace_iso));
+
+ TEST_ASSERT_EQUAL_INT(0, uuid_from_string(&uuid, x500));
+ TEST_ASSERT_EQUAL_INT(true, uuid_equal(&uuid, &uuid_namespace_x500));
+}
+
Test *tests_uuid_all(void)
{
EMB_UNIT_TESTFIXTURES(fixtures) {
new_TestFixture(test_uuid_v3),
new_TestFixture(test_uuid_v4),
new_TestFixture(test_uuid_v5),
+ new_TestFixture(test_uuid_str),
};
EMB_UNIT_TESTCALLER(uuid_tests, NULL, NULL, fixtures);