From 9a710e5108f259eb5fe4da83cb74f3cf48e9933f Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Tue, 30 Oct 2018 13:07:25 +0100 Subject: [PATCH 1/6] libnm: expose UUID utils as internal API We link against libuuid.so, but it was entirely internal to libnm-core. We only exposed UUIDs in string form. Add API to also handle UUIDs in binary form. Note that libuuid already defines a type "uuid_t". However, don't use it and instead use our own typedef NMUuid. Reasons: - uuid.h should be internal to libnm-core (nm-utils.c specifically), and not be used by or exposed it other parts of the code. - uuid_t is a typedef for a guchar[16] array. Typedefs for arrays are confusing, because depending on whether it's an automatic variable or a pointer in a function argument, they behave differently regarding whether to take their address or not and usage of "sizeof()". (cherry picked from commit 88b081fce4d1dd1093dd3413ed7462f6d4fc7962) --- libnm-core/nm-core-internal.h | 12 +++++++ libnm-core/nm-utils.c | 67 ++++++++++++++++++++++++++--------- 2 files changed, 62 insertions(+), 17 deletions(-) diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h index 6a59d5be73..b694b2b49a 100644 --- a/libnm-core/nm-core-internal.h +++ b/libnm-core/nm-core-internal.h @@ -279,6 +279,18 @@ gboolean _nm_utils_check_module_file (const char *name, gpointer user_data, GError **error); +/*****************************************************************************/ + +typedef struct _NMUuid { + guchar uuid[16]; +} NMUuid; + +NMUuid *_nm_utils_uuid_parse (const char *str, + NMUuid *uuid); +char *_nm_utils_uuid_unparse (const NMUuid *uuid, + char *out_str /*[37]*/); +NMUuid *_nm_utils_uuid_generate_random (NMUuid *out_uuid); + #define NM_UTILS_UUID_TYPE_LEGACY 0 #define NM_UTILS_UUID_TYPE_VARIANT3 1 diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c index 0f524e11be..a4b6c4f117 100644 --- a/libnm-core/nm-utils.c +++ b/libnm-core/nm-utils.c @@ -2785,6 +2785,42 @@ _nm_utils_sriov_vf_from_strparts (const char *index, const char *detail, GError /*****************************************************************************/ +NMUuid * +_nm_utils_uuid_parse (const char *str, + NMUuid *out_uuid) +{ + nm_assert (str); + nm_assert (out_uuid); + + if (uuid_parse (str, out_uuid->uuid) != 0) + return NULL; + return out_uuid; +} + +char * +_nm_utils_uuid_unparse (const NMUuid *uuid, + char *out_str /*[37]*/) +{ + nm_assert (uuid); + + if (!out_str) { + /* for convenience, allow %NULL to indicate that a new + * string should be allocated. */ + out_str = g_malloc (37); + } + uuid_unparse_lower (uuid->uuid, out_str); + return out_str; +} + +NMUuid * +_nm_utils_uuid_generate_random (NMUuid *out_uuid) +{ + nm_assert (out_uuid); + + uuid_generate_random (out_uuid->uuid); + return out_uuid; +} + /** * nm_utils_uuid_generate_buf_: * @buf: input buffer, must contain at least 37 bytes @@ -2794,11 +2830,12 @@ _nm_utils_sriov_vf_from_strparts (const char *index, const char *detail, GError char * nm_utils_uuid_generate_buf_ (char *buf) { - uuid_t uuid; + NMUuid uuid; - uuid_generate_random (uuid); - uuid_unparse_lower (uuid, buf); - return buf; + nm_assert (buf); + + _nm_utils_uuid_generate_random (&uuid); + return _nm_utils_uuid_unparse (&uuid, buf); } /** @@ -2830,8 +2867,7 @@ nm_utils_uuid_generate (void) char * nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, gpointer type_args) { - uuid_t uuid; - char *buf; + NMUuid uuid; g_return_val_if_fail (slen == 0 || s, FALSE); @@ -2847,37 +2883,34 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g 0, (guint8 *) s, slen, - (guint8 *) uuid, + (guint8 *) &uuid, sizeof (uuid)); break; case NM_UTILS_UUID_TYPE_VARIANT3: { - uuid_t ns_uuid = { 0 }; + NMUuid ns_uuid = { 0 }; if (type_args) { /* type_args can be a name space UUID. Interpret it as (char *) */ - if (uuid_parse ((char *) type_args, ns_uuid) != 0) + if (!_nm_utils_uuid_parse (type_args, &ns_uuid)) g_return_val_if_reached (NULL); } nm_crypto_md5_hash ((guint8 *) s, slen, - (guint8 *) ns_uuid, + (guint8 *) &ns_uuid, sizeof (ns_uuid), - (guint8 *) uuid, + (guint8 *) &uuid, sizeof (uuid)); - uuid[6] = (uuid[6] & 0x0F) | 0x30; - uuid[8] = (uuid[8] & 0x3F) | 0x80; + uuid.uuid[6] = (uuid.uuid[6] & 0x0F) | 0x30; + uuid.uuid[8] = (uuid.uuid[8] & 0x3F) | 0x80; break; } default: g_return_val_if_reached (NULL); } - buf = g_malloc (37); - uuid_unparse_lower (uuid, &buf[0]); - - return buf; + return _nm_utils_uuid_unparse (&uuid, NULL); } /** From 1a1d1bf7f32575df62ef94eba5fb0e0e46c08ba9 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 31 Oct 2018 07:32:23 +0100 Subject: [PATCH 2/6] libnm/trivial: rename uuid type VARIANT3 to VERSION3 In RFC 4122, this is called "version 3", not "variant 3". While for UUIDs there is also a concept of "variants", that is something else. Fix naming. (cherry picked from commit c150b0fa2924307810a54e62bd5232081bbef89f) --- libnm-core/nm-core-internal.h | 2 +- libnm-core/nm-utils.c | 10 +++++----- libnm-core/tests/test-general.c | 22 +++++++++++----------- 3 files changed, 17 insertions(+), 17 deletions(-) diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h index b694b2b49a..ca137fb158 100644 --- a/libnm-core/nm-core-internal.h +++ b/libnm-core/nm-core-internal.h @@ -292,7 +292,7 @@ char *_nm_utils_uuid_unparse (const NMUuid *uuid, NMUuid *_nm_utils_uuid_generate_random (NMUuid *out_uuid); #define NM_UTILS_UUID_TYPE_LEGACY 0 -#define NM_UTILS_UUID_TYPE_VARIANT3 1 +#define NM_UTILS_UUID_TYPE_VERSION3 1 char *nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, gpointer type_args); diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c index a4b6c4f117..d760a17dd5 100644 --- a/libnm-core/nm-utils.c +++ b/libnm-core/nm-utils.c @@ -2871,8 +2871,8 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g g_return_val_if_fail (slen == 0 || s, FALSE); - g_return_val_if_fail (uuid_type == NM_UTILS_UUID_TYPE_LEGACY || uuid_type == NM_UTILS_UUID_TYPE_VARIANT3, NULL); - g_return_val_if_fail (!type_args || uuid_type == NM_UTILS_UUID_TYPE_VARIANT3, NULL); + g_return_val_if_fail (uuid_type == NM_UTILS_UUID_TYPE_LEGACY || uuid_type == NM_UTILS_UUID_TYPE_VERSION3, NULL); + g_return_val_if_fail (!type_args || uuid_type == NM_UTILS_UUID_TYPE_VERSION3, NULL); if (slen < 0) slen = s ? strlen (s) : 0; @@ -2886,7 +2886,7 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g (guint8 *) &uuid, sizeof (uuid)); break; - case NM_UTILS_UUID_TYPE_VARIANT3: { + case NM_UTILS_UUID_TYPE_VERSION3: { NMUuid ns_uuid = { 0 }; if (type_args) { @@ -2935,7 +2935,7 @@ _nm_utils_uuid_generate_from_strings (const char *string1, ...) char *uuid; if (!string1) - return nm_utils_uuid_generate_from_string (NULL, 0, NM_UTILS_UUID_TYPE_VARIANT3, NM_UTILS_UUID_NS); + return nm_utils_uuid_generate_from_string (NULL, 0, NM_UTILS_UUID_TYPE_VERSION3, NM_UTILS_UUID_NS); str = g_string_sized_new (120); /* effectively allocates power of 2 (128)*/ @@ -2949,7 +2949,7 @@ _nm_utils_uuid_generate_from_strings (const char *string1, ...) } va_end (args); - uuid = nm_utils_uuid_generate_from_string (str->str, str->len, NM_UTILS_UUID_TYPE_VARIANT3, NM_UTILS_UUID_NS); + uuid = nm_utils_uuid_generate_from_string (str->str, str->len, NM_UTILS_UUID_TYPE_VERSION3, NM_UTILS_UUID_NS); g_string_free (str, TRUE); return uuid; diff --git a/libnm-core/tests/test-general.c b/libnm-core/tests/test-general.c index 5a95427030..fa63938bc8 100644 --- a/libnm-core/tests/test-general.c +++ b/libnm-core/tests/test-general.c @@ -5465,8 +5465,8 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl _test_uuid (uuid_type, expected_uuid, NULL, 0, type_args); } - if (uuid_type == NM_UTILS_UUID_TYPE_VARIANT3 && !type_args) { - /* For NM_UTILS_UUID_TYPE_VARIANT3, a missing @type_args is equal to UUID_NIL */ + if (uuid_type == NM_UTILS_UUID_TYPE_VERSION3 && !type_args) { + /* For NM_UTILS_UUID_TYPE_VERSION3, a missing @type_args is equal to UUID_NIL */ _test_uuid (uuid_type, expected_uuid, str, slen, UUID_NIL); } } @@ -5480,15 +5480,15 @@ test_nm_utils_uuid_generate_from_string (void) _test_uuid (NM_UTILS_UUID_TYPE_LEGACY, "70350f60-27bc-e371-3f6b-76473084309b", "a\0b", 3, NULL); _test_uuid (NM_UTILS_UUID_TYPE_LEGACY, "59c0547b-7fe2-1c15-2cce-e328e8bf6742", "/etc/NetworkManager/system-connections/em1", -1, NULL); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "4ae71336-e44b-39bf-b9d2-752e234818a5", "", -1, NULL); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "0531103a-d8fc-3dd4-b972-d98e4750994e", "a", -1, NULL); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "96e17d7a-ac89-38cf-95e1-bf5098da34e1", "test", -1, NULL); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "8156568e-4ae6-3f34-a93e-18e2c6cbbf78", "a\0b", 3, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "4ae71336-e44b-39bf-b9d2-752e234818a5", "", -1, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "0531103a-d8fc-3dd4-b972-d98e4750994e", "a", -1, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "96e17d7a-ac89-38cf-95e1-bf5098da34e1", "test", -1, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "8156568e-4ae6-3f34-a93e-18e2c6cbbf78", "a\0b", 3, NULL); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "c87ee674-4ddc-3efe-a74e-dfe25da5d7b3", "", -1, UUID_NS_DNS); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "4c104dd0-4821-30d5-9ce3-0e7a1f8b7c0d", "a", -1, UUID_NS_DNS); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "45a113ac-c7f2-30b0-90a5-a399ab912716", "test", -1, UUID_NS_DNS); - _test_uuid (NM_UTILS_UUID_TYPE_VARIANT3, "002a0ada-f547-375a-bab5-896a11d1927e", "a\0b", 3, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "c87ee674-4ddc-3efe-a74e-dfe25da5d7b3", "", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "4c104dd0-4821-30d5-9ce3-0e7a1f8b7c0d", "a", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "45a113ac-c7f2-30b0-90a5-a399ab912716", "test", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "002a0ada-f547-375a-bab5-896a11d1927e", "a\0b", 3, UUID_NS_DNS); } /*****************************************************************************/ @@ -5505,7 +5505,7 @@ __test_uuid (const char *expected_uuid, const char *str, gssize slen, char *uuid } g_free (uuid_test); - uuid_test = nm_utils_uuid_generate_from_string (str, slen, NM_UTILS_UUID_TYPE_VARIANT3, NM_UTILS_UUID_NS); + uuid_test = nm_utils_uuid_generate_from_string (str, slen, NM_UTILS_UUID_TYPE_VERSION3, NM_UTILS_UUID_NS); g_assert (uuid_test); g_assert (nm_utils_is_uuid (uuid_test)); From 91745d0ae96a529449ec49d6a798867f29b113a9 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 31 Oct 2018 08:25:28 +0100 Subject: [PATCH 3/6] libnm/tests: add more tests for generating UUIDs The expected values are checked with python's uuid module and OSSP uuid. (cherry picked from commit 2ce5347e4dac3564e80c7a8d6715be5307e91339) --- libnm-core/tests/test-general.c | 153 ++++++++++++++++++++++++++++++-- 1 file changed, 146 insertions(+), 7 deletions(-) diff --git a/libnm-core/tests/test-general.c b/libnm-core/tests/test-general.c index fa63938bc8..7847416df0 100644 --- a/libnm-core/tests/test-general.c +++ b/libnm-core/tests/test-general.c @@ -5439,8 +5439,11 @@ test_nm_strquote (void) /*****************************************************************************/ -#define UUID_NIL "00000000-0000-0000-0000-000000000000" +#define UUID_NS_ZERO "00000000-0000-0000-0000-000000000000" #define UUID_NS_DNS "6ba7b810-9dad-11d1-80b4-00c04fd430c8" +#define UUID_NS_URL "6ba7b811-9dad-11d1-80b4-00c04fd430c8" +#define UUID_NS_OID "6ba7b812-9dad-11d1-80b4-00c04fd430c8" +#define UUID_NS_X500 "6ba7b814-9dad-11d1-80b4-00c04fd430c8" static void _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize slen, gpointer type_args) @@ -5452,9 +5455,16 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl g_assert (uuid_test); g_assert (nm_utils_is_uuid (uuid_test)); - if (strcmp (uuid_test, expected_uuid)) { - g_error ("UUID test failed: type=%d; text=%s, len=%lld, uuid=%s, expected=%s", uuid_type, - str, (long long) slen, uuid_test, expected_uuid); + if (!nm_streq (uuid_test, expected_uuid)) { + g_error ("UUID test failed: type=%d; text=%s, len=%lld, ns=%s, uuid=%s, expected=%s", + uuid_type, + str, + (long long) slen, + NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3) + ? (((const char *) type_args) ?: "(all-zero)") + : (type_args ? "(unknown)" : "(null)"), + uuid_test, + expected_uuid); } if (slen < 0) { @@ -5465,15 +5475,127 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl _test_uuid (uuid_type, expected_uuid, NULL, 0, type_args); } - if (uuid_type == NM_UTILS_UUID_TYPE_VERSION3 && !type_args) { - /* For NM_UTILS_UUID_TYPE_VERSION3, a missing @type_args is equal to UUID_NIL */ - _test_uuid (uuid_type, expected_uuid, str, slen, UUID_NIL); + if ( NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3) + && !type_args) { + /* For version3 and version5, a missing @type_args is equal to UUID_NS_ZERO */ + _test_uuid (uuid_type, expected_uuid, str, slen, UUID_NS_ZERO); } } +typedef struct { + const char *uuid3; +} ExpectedUuids; + static void test_nm_utils_uuid_generate_from_string (void) { + const ExpectedUuids zero_uuids[] = { + { .uuid3 = "19826852-5007-3022-a72a-212f66e9fac3", }, + { .uuid3 = "9153af2e-fc8e-34f3-9e8b-81f73b33d0cb", }, + { .uuid3 = "2f06a3ae-d78d-30d7-b898-088a0e0b76f6", }, + { .uuid3 = "aca948e0-1468-3a51-9f2e-c688a484efd7", }, + { .uuid3 = "b74e537a-53e8-3808-9abd-58546a6542bd", }, + { .uuid3 = "1b00958a-7d76-3d08-8aba-c66c5828658c", }, + { .uuid3 = "7ba18f7d-c9cf-3b48-a89e-ad79243135cc", }, + { .uuid3 = "9baf0978-1a60-35c5-9e9b-bec8d259fd4e", }, + { .uuid3 = "588668c0-7631-39c7-9976-c7d414adf7ba", }, + { .uuid3 = "8edb3613-9612-3b32-9dd7-0a01aa8ed453", }, + { .uuid3 = "f3b34394-63a5-3773-9014-1f8a50d765b8", }, + { .uuid3 = "0572965f-05b8-342b-b225-d5c29d449eee", }, + { .uuid3 = "6f7177c3-77b0-3f42-82a8-7031e25fcccf", }, + { .uuid3 = "d1e0f845-bc1b-368c-b8c8-49ab0b9e486b", }, + { .uuid3 = "46371ea3-c8a3-34d8-b2cf-2fa90bda4378", }, + { .uuid3 = "f1e6b499-9b68-343b-a5c5-ece7acc49a68", }, + { .uuid3 = "9ed06458-c712-31dd-aba5-6cf79879fabe", }, + { .uuid3 = "4ddd5cd7-bc83-36aa-909c-4e660f57c830", }, + { .uuid3 = "335fa537-0909-395d-a696-6f41827dcbeb", }, + { .uuid3 = "dbd58444-05ad-3edd-adc7-4393ecbcb43c", }, + { .uuid3 = "a1c62d82-d13c-361b-8f4e-ca91bc2f7fc5", }, + { .uuid3 = "e943d83e-3f82-307f-81ed-b7a7bcd0743e", }, + { .uuid3 = "cabf46dd-9f09-375c-8f6e-f2a8cf114709", }, + { .uuid3 = "19beddf3-f2fb-340f-96ac-4f394960b7a7", }, + { .uuid3 = "08d835c2-f4ca-394c-ba7f-2494d8b60c6c", }, + { .uuid3 = "3b8c6847-5331-35bf-9cd9-ced50e53cd7c", }, + { .uuid3 = "e601f160-484b-3254-8f3b-0a25c7203d8a", }, + { .uuid3 = "e5e492ed-5349-379d-b7de-a370a51e44a3", }, + { .uuid3 = "c40111f6-fe97-305e-bfce-7db730c3d2ec", }, + { .uuid3 = "21e18ea8-95c2-362b-9ca9-25d6a0ff2dff", }, + { .uuid3 = "adab623b-1343-307f-80d8-58d005376ad9", }, + { .uuid3 = "67e9fc7c-dafe-356d-ac1a-a63ce3f44813", }, + { .uuid3 = "36cc7f20-126c-3e40-94e7-737ac7486547", }, + { .uuid3 = "fe282996-ac5e-3d13-b478-5def30007a8e", }, + { .uuid3 = "3bfe339c-05ae-3233-a1a5-ebf1ead589db", }, + { .uuid3 = "d1d90bc7-da4a-3cd7-a7c8-a1a89765d8ee", }, + { .uuid3 = "10b88a02-0102-359b-81e9-7e3b0ff7d25e", }, + { .uuid3 = "7da5e4f2-6df0-3aca-a1b0-b7f8b1340e1d", }, + { .uuid3 = "cbe24d98-ca20-3058-86b6-24a6b36ceff0", }, + { .uuid3 = "04d84e6a-b793-3993-afbf-bae7cfc42b49", }, + { .uuid3 = "fdd157d8-a537-350a-9cc9-1930e8666c63", }, + { .uuid3 = "0bea36bb-24a7-3ee6-a98d-116433c14cd4", }, + { .uuid3 = "52b040a4-1b84-32d2-b758-f82386f7e0f0", }, + { .uuid3 = "0f0a4e26-e034-3021-acf2-4e886af43092", }, + { .uuid3 = "819d3cd1-afe5-3e4a-9f0c-945e25d09879", }, + { .uuid3 = "e7df1a3b-c9f8-3e5a-88d6-ba72b2a0f27b", }, + { .uuid3 = "0854bedf-74ba-3f2b-b823-dc2c90d27c76", }, + { .uuid3 = "a1b8c3ba-f821-32ef-a3fd-b97b3855efa8", }, + { .uuid3 = "9458f819-079b-3033-9430-ba10f576c067", }, + { .uuid3 = "8e1f240a-e386-3e00-866a-6f9da1e3503f", }, + }; + const ExpectedUuids dns_uuids[] = { + { .uuid3 = "4385125b-dd1e-3025-880f-3311517cc8d5", }, + { .uuid3 = "afd0b036-625a-3aa8-b639-9dc8c8fff0ff", }, + { .uuid3 = "9c45c2f1-1761-3daa-ad31-1ff8703ae846", }, + { .uuid3 = "15e0ba07-10e4-3d7f-aaff-c00fed873c88", }, + { .uuid3 = "bc27b4db-bc0f-34f9-ae8e-4b72f2d51b60", }, + { .uuid3 = "7586bfed-b8b8-3bb3-9c95-09a4a79dc0f7", }, + { .uuid3 = "881430b6-8d28-3175-b87d-e81f2f5978c6", }, + { .uuid3 = "24075675-98ae-354e-89ca-0126a9ad36e3", }, + { .uuid3 = "2c269ea4-dbfd-32dd-9bd7-a5c22677d18b", }, + { .uuid3 = "44eb0948-118f-3f28-87e4-f61c8f889aba", }, + { .uuid3 = "fc72beeb-f790-36ee-a73d-33888c9d8880", }, + { .uuid3 = "1e46afa2-6176-3cd3-9750-3015846723df", }, + { .uuid3 = "0042b01d-95bd-343f-bd9f-3186bfd63508", }, + { .uuid3 = "115ff52f-d605-3b4b-98fe-c0ea57f4930c", }, + { .uuid3 = "ed0221e8-ac7d-393b-821d-25183567885b", }, + { .uuid3 = "508ef333-85a6-314c-bcf3-17ddc32b2216", }, + { .uuid3 = "a4715ee0-524a-37cc-beb2-a0b5030757b7", }, + { .uuid3 = "d1c72756-aaec-3470-a2f2-97415f44d72f", }, + { .uuid3 = "7aec2f01-586e-3d53-b8f3-6cf7e6b649a4", }, + { .uuid3 = "3d234b88-8d6f-319a-91ea-edb6059fc825", }, + { .uuid3 = "d2568554-93ec-30c7-9e15-f383be19e5bb", }, + { .uuid3 = "800e59a7-dd0f-3114-8e58-ab7e213895ca", }, + { .uuid3 = "3b7d03f0-e067-3d72-84f4-e410ac36ef57", }, + { .uuid3 = "8762be68-de95-391a-94a0-c5fd0446e037", }, + { .uuid3 = "2bd8b4c9-01af-3cd0-aced-94ee6e2004b8", }, + { .uuid3 = "a627d6a4-394a-33f5-b68e-22bfb6488d01", }, + { .uuid3 = "6a592510-17d9-3925-b321-4a8d4927f8d0", }, + { .uuid3 = "9ee72491-59c4-333c-bb93-fe733a842fdb", }, + { .uuid3 = "2591c62c-0a9d-3c28-97bc-fa0401556a3c", }, + { .uuid3 = "7912be1e-4562-373b-92e2-3d6d2123bc8e", }, + { .uuid3 = "09370cda-89a4-3a48-b592-9c0486e0d5e4", }, + { .uuid3 = "de5980d3-a137-373c-850b-ca3e5f100779", }, + { .uuid3 = "9441501d-f633-365a-8955-9df443edc762", }, + { .uuid3 = "434ada18-13ce-3c08-8b40-a1a1ae030569", }, + { .uuid3 = "a13b6160-bd23-3710-a150-41d800dd30b4", }, + { .uuid3 = "73a67c12-c5f0-3288-ad6a-c78aea0917b0", }, + { .uuid3 = "a126ee4f-a222-357d-b71b-7d3f226c559f", }, + { .uuid3 = "48f4f36b-b015-3137-9b6e-351bb175c7f7", }, + { .uuid3 = "3fe8f6a3-fe4a-3487-89d6-dd06c6ad02e3", }, + { .uuid3 = "d68fa2d4-adc9-3b20-ac77-42585cd1d59f", }, + { .uuid3 = "819f86a3-31d5-3e72-a83e-142c3a3e4832", }, + { .uuid3 = "9957b433-ddc8-3113-a3e6-5512cf13dab1", }, + { .uuid3 = "5aab6e0c-b7d3-379c-92e3-2bfbb5572511", }, + { .uuid3 = "11c8ff30-3a7d-3547-80a7-d61b8abeeda8", }, + { .uuid3 = "98799b9f-1c5e-30b3-930f-e412b862cbe4", }, + { .uuid3 = "9bdf2544-31d8-3555-94b0-6a749118a996", }, + { .uuid3 = "ddcfb9b3-e990-3985-9021-546a2711e7e5", }, + { .uuid3 = "190d7a78-1484-3136-80a6-40f28852785c", }, + { .uuid3 = "6ed693e4-7dc0-3210-856b-a6eb4cc73e13", }, + { .uuid3 = "b6a14b21-e73a-3ce2-9076-a804c434f5c6", }, + }; + char i_str[30]; + guint i; + _test_uuid (NM_UTILS_UUID_TYPE_LEGACY, "d41d8cd9-8f00-b204-e980-0998ecf8427e", "", -1, NULL); _test_uuid (NM_UTILS_UUID_TYPE_LEGACY, "0cc175b9-c0f1-b6a8-31c3-99e269772661", "a", -1, NULL); _test_uuid (NM_UTILS_UUID_TYPE_LEGACY, "098f6bcd-4621-d373-cade-4e832627b4f6", "test", -1, NULL); @@ -5489,6 +5611,23 @@ test_nm_utils_uuid_generate_from_string (void) _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "4c104dd0-4821-30d5-9ce3-0e7a1f8b7c0d", "a", -1, UUID_NS_DNS); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "45a113ac-c7f2-30b0-90a5-a399ab912716", "test", -1, UUID_NS_DNS); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "002a0ada-f547-375a-bab5-896a11d1927e", "a\0b", 3, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "9a75f5f2-195e-31a9-9d07-8c18b5d3b285", "test123", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "ec794efe-a384-3b11-a0b6-ec8995bc6acc", "x", -1, UUID_NS_DNS); + + for (i = 0; i < G_N_ELEMENTS (zero_uuids); i++) { + nm_sprintf_buf (i_str, "%u", i), + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, zero_uuids[i].uuid3, i_str, -1, NULL); + } + for (i = 0; i < G_N_ELEMENTS (dns_uuids); i++) { + nm_sprintf_buf (i_str, "%u", i), + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, dns_uuids[i].uuid3, i_str, -1, UUID_NS_DNS); + } + + /* examples from cpython unit tests: */ + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "6fa459ea-ee8a-3ca4-894e-db77e160355e", "python.org", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "9fe8e8c4-aaa8-32a9-a55c-4535a88b748d", "http://python.org/", -1, UUID_NS_URL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "dd1a1cef-13d5-368a-ad82-eca71acd4cd1", "1.3.6.1", -1, UUID_NS_OID); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "658d3002-db6b-3040-a1d1-8ddd7d189a4d", "c=ca", -1, UUID_NS_X500); } /*****************************************************************************/ From 9da5c5989ebde5fb32cee83b8f59cac5362aa59b Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 31 Oct 2018 08:27:41 +0100 Subject: [PATCH 4/6] libnm: add support for SHA1 based version 5 UUIDs The entire point of using version 3/5 UUIDs is to generate stable UUIDs based on a string. It's usually important that we don't change the UUID generation algorithm later on. Since we didn't have a version 5 implementation, we would always resort to the MD5 based version 3. Version 5 is recommended by RFC 4122: o Choose either MD5 [4] or SHA-1 [8] as the hash algorithm; If backward compatibility is not an issue, SHA-1 is preferred. Add a version 5 implementation so we can use it in the future. All test values are generated with python's uuid module or OSSP uuid. (cherry picked from commit 070a4d935504ee8f9be79ff3c25e650fa695fb2b) --- libnm-core/nm-core-internal.h | 3 +- libnm-core/nm-utils.c | 37 ++++-- libnm-core/tests/test-general.c | 220 +++++++++++++++++--------------- 3 files changed, 146 insertions(+), 114 deletions(-) diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h index ca137fb158..1121a4727a 100644 --- a/libnm-core/nm-core-internal.h +++ b/libnm-core/nm-core-internal.h @@ -292,7 +292,8 @@ char *_nm_utils_uuid_unparse (const NMUuid *uuid, NMUuid *_nm_utils_uuid_generate_random (NMUuid *out_uuid); #define NM_UTILS_UUID_TYPE_LEGACY 0 -#define NM_UTILS_UUID_TYPE_VERSION3 1 +#define NM_UTILS_UUID_TYPE_VERSION3 3 +#define NM_UTILS_UUID_TYPE_VERSION5 5 char *nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, gpointer type_args); diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c index d760a17dd5..562461a49c 100644 --- a/libnm-core/nm-utils.c +++ b/libnm-core/nm-utils.c @@ -2871,14 +2871,12 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g g_return_val_if_fail (slen == 0 || s, FALSE); - g_return_val_if_fail (uuid_type == NM_UTILS_UUID_TYPE_LEGACY || uuid_type == NM_UTILS_UUID_TYPE_VERSION3, NULL); - g_return_val_if_fail (!type_args || uuid_type == NM_UTILS_UUID_TYPE_VERSION3, NULL); - if (slen < 0) slen = s ? strlen (s) : 0; switch (uuid_type) { case NM_UTILS_UUID_TYPE_LEGACY: + g_return_val_if_fail (!type_args, NULL); nm_crypto_md5_hash (NULL, 0, (guint8 *) s, @@ -2886,7 +2884,8 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g (guint8 *) &uuid, sizeof (uuid)); break; - case NM_UTILS_UUID_TYPE_VERSION3: { + case NM_UTILS_UUID_TYPE_VERSION3: + case NM_UTILS_UUID_TYPE_VERSION5: { NMUuid ns_uuid = { 0 }; if (type_args) { @@ -2895,14 +2894,30 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g g_return_val_if_reached (NULL); } - nm_crypto_md5_hash ((guint8 *) s, - slen, - (guint8 *) &ns_uuid, - sizeof (ns_uuid), - (guint8 *) &uuid, - sizeof (uuid)); + if (uuid_type == NM_UTILS_UUID_TYPE_VERSION3) { + nm_crypto_md5_hash ((guint8 *) s, + slen, + (guint8 *) &ns_uuid, + sizeof (ns_uuid), + (guint8 *) &uuid, + sizeof (uuid)); + } else { + nm_auto_free_checksum GChecksum *sum = NULL; + guint8 buf[20]; + gsize len; - uuid.uuid[6] = (uuid.uuid[6] & 0x0F) | 0x30; + sum = g_checksum_new (G_CHECKSUM_SHA1); + g_checksum_update (sum, (guchar *) &ns_uuid, sizeof (ns_uuid)); + g_checksum_update (sum, (guchar *) s, slen); + len = sizeof (buf); + g_checksum_get_digest (sum, buf, &len); + nm_assert (len == sizeof (buf)); + + G_STATIC_ASSERT_EXPR (sizeof (uuid) <= sizeof (buf)); + memcpy (&uuid, buf, sizeof (uuid)); + } + + uuid.uuid[6] = (uuid.uuid[6] & 0x0F) | (uuid_type << 4); uuid.uuid[8] = (uuid.uuid[8] & 0x3F) | 0x80; break; } diff --git a/libnm-core/tests/test-general.c b/libnm-core/tests/test-general.c index 7847416df0..0f0b1c5278 100644 --- a/libnm-core/tests/test-general.c +++ b/libnm-core/tests/test-general.c @@ -5460,7 +5460,8 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl uuid_type, str, (long long) slen, - NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3) + NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3, + NM_UTILS_UUID_TYPE_VERSION5) ? (((const char *) type_args) ?: "(all-zero)") : (type_args ? "(unknown)" : "(null)"), uuid_test, @@ -5475,7 +5476,8 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl _test_uuid (uuid_type, expected_uuid, NULL, 0, type_args); } - if ( NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3) + if ( NM_IN_SET (uuid_type, NM_UTILS_UUID_TYPE_VERSION3, + NM_UTILS_UUID_TYPE_VERSION5) && !type_args) { /* For version3 and version5, a missing @type_args is equal to UUID_NS_ZERO */ _test_uuid (uuid_type, expected_uuid, str, slen, UUID_NS_ZERO); @@ -5484,114 +5486,115 @@ _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize sl typedef struct { const char *uuid3; + const char *uuid5; } ExpectedUuids; static void test_nm_utils_uuid_generate_from_string (void) { const ExpectedUuids zero_uuids[] = { - { .uuid3 = "19826852-5007-3022-a72a-212f66e9fac3", }, - { .uuid3 = "9153af2e-fc8e-34f3-9e8b-81f73b33d0cb", }, - { .uuid3 = "2f06a3ae-d78d-30d7-b898-088a0e0b76f6", }, - { .uuid3 = "aca948e0-1468-3a51-9f2e-c688a484efd7", }, - { .uuid3 = "b74e537a-53e8-3808-9abd-58546a6542bd", }, - { .uuid3 = "1b00958a-7d76-3d08-8aba-c66c5828658c", }, - { .uuid3 = "7ba18f7d-c9cf-3b48-a89e-ad79243135cc", }, - { .uuid3 = "9baf0978-1a60-35c5-9e9b-bec8d259fd4e", }, - { .uuid3 = "588668c0-7631-39c7-9976-c7d414adf7ba", }, - { .uuid3 = "8edb3613-9612-3b32-9dd7-0a01aa8ed453", }, - { .uuid3 = "f3b34394-63a5-3773-9014-1f8a50d765b8", }, - { .uuid3 = "0572965f-05b8-342b-b225-d5c29d449eee", }, - { .uuid3 = "6f7177c3-77b0-3f42-82a8-7031e25fcccf", }, - { .uuid3 = "d1e0f845-bc1b-368c-b8c8-49ab0b9e486b", }, - { .uuid3 = "46371ea3-c8a3-34d8-b2cf-2fa90bda4378", }, - { .uuid3 = "f1e6b499-9b68-343b-a5c5-ece7acc49a68", }, - { .uuid3 = "9ed06458-c712-31dd-aba5-6cf79879fabe", }, - { .uuid3 = "4ddd5cd7-bc83-36aa-909c-4e660f57c830", }, - { .uuid3 = "335fa537-0909-395d-a696-6f41827dcbeb", }, - { .uuid3 = "dbd58444-05ad-3edd-adc7-4393ecbcb43c", }, - { .uuid3 = "a1c62d82-d13c-361b-8f4e-ca91bc2f7fc5", }, - { .uuid3 = "e943d83e-3f82-307f-81ed-b7a7bcd0743e", }, - { .uuid3 = "cabf46dd-9f09-375c-8f6e-f2a8cf114709", }, - { .uuid3 = "19beddf3-f2fb-340f-96ac-4f394960b7a7", }, - { .uuid3 = "08d835c2-f4ca-394c-ba7f-2494d8b60c6c", }, - { .uuid3 = "3b8c6847-5331-35bf-9cd9-ced50e53cd7c", }, - { .uuid3 = "e601f160-484b-3254-8f3b-0a25c7203d8a", }, - { .uuid3 = "e5e492ed-5349-379d-b7de-a370a51e44a3", }, - { .uuid3 = "c40111f6-fe97-305e-bfce-7db730c3d2ec", }, - { .uuid3 = "21e18ea8-95c2-362b-9ca9-25d6a0ff2dff", }, - { .uuid3 = "adab623b-1343-307f-80d8-58d005376ad9", }, - { .uuid3 = "67e9fc7c-dafe-356d-ac1a-a63ce3f44813", }, - { .uuid3 = "36cc7f20-126c-3e40-94e7-737ac7486547", }, - { .uuid3 = "fe282996-ac5e-3d13-b478-5def30007a8e", }, - { .uuid3 = "3bfe339c-05ae-3233-a1a5-ebf1ead589db", }, - { .uuid3 = "d1d90bc7-da4a-3cd7-a7c8-a1a89765d8ee", }, - { .uuid3 = "10b88a02-0102-359b-81e9-7e3b0ff7d25e", }, - { .uuid3 = "7da5e4f2-6df0-3aca-a1b0-b7f8b1340e1d", }, - { .uuid3 = "cbe24d98-ca20-3058-86b6-24a6b36ceff0", }, - { .uuid3 = "04d84e6a-b793-3993-afbf-bae7cfc42b49", }, - { .uuid3 = "fdd157d8-a537-350a-9cc9-1930e8666c63", }, - { .uuid3 = "0bea36bb-24a7-3ee6-a98d-116433c14cd4", }, - { .uuid3 = "52b040a4-1b84-32d2-b758-f82386f7e0f0", }, - { .uuid3 = "0f0a4e26-e034-3021-acf2-4e886af43092", }, - { .uuid3 = "819d3cd1-afe5-3e4a-9f0c-945e25d09879", }, - { .uuid3 = "e7df1a3b-c9f8-3e5a-88d6-ba72b2a0f27b", }, - { .uuid3 = "0854bedf-74ba-3f2b-b823-dc2c90d27c76", }, - { .uuid3 = "a1b8c3ba-f821-32ef-a3fd-b97b3855efa8", }, - { .uuid3 = "9458f819-079b-3033-9430-ba10f576c067", }, - { .uuid3 = "8e1f240a-e386-3e00-866a-6f9da1e3503f", }, + { .uuid3 = "19826852-5007-3022-a72a-212f66e9fac3", .uuid5 = "b6c54489-38a0-5f50-a60a-fd8d76219cae", }, + { .uuid3 = "9153af2e-fc8e-34f3-9e8b-81f73b33d0cb", .uuid5 = "11116e73-1c03-5de6-9130-5f9925ae8ab4", }, + { .uuid3 = "2f06a3ae-d78d-30d7-b898-088a0e0b76f6", .uuid5 = "1087ebe8-1ef8-5d97-8873-735b4949004d", }, + { .uuid3 = "aca948e0-1468-3a51-9f2e-c688a484efd7", .uuid5 = "7e57d004-2b97-5e7a-b45f-5387367791cd", }, + { .uuid3 = "b74e537a-53e8-3808-9abd-58546a6542bd", .uuid5 = "1dd80df1-492c-5dc5-aec2-6bf0e104f923", }, + { .uuid3 = "1b00958a-7d76-3d08-8aba-c66c5828658c", .uuid5 = "f797f61e-a392-5acf-af25-b46057f1c8e8", }, + { .uuid3 = "7ba18f7d-c9cf-3b48-a89e-ad79243135cc", .uuid5 = "e02c9780-2fc5-5d57-b92f-4cc3a64bff16", }, + { .uuid3 = "9baf0978-1a60-35c5-9e9b-bec8d259fd4e", .uuid5 = "94167980-f909-527e-a4af-bc3155f586d3", }, + { .uuid3 = "588668c0-7631-39c7-9976-c7d414adf7ba", .uuid5 = "9e3eefda-b56e-56bd-8a3a-0b8009d4a536", }, + { .uuid3 = "8edb3613-9612-3b32-9dd7-0a01aa8ed453", .uuid5 = "9b75648e-d38c-54e8-adee-1fb295a079c9", }, + { .uuid3 = "f3b34394-63a5-3773-9014-1f8a50d765b8", .uuid5 = "dd56b598-9e74-58c3-b3e8-2c623780b8ed", }, + { .uuid3 = "0572965f-05b8-342b-b225-d5c29d449eee", .uuid5 = "5666449a-fb7e-55b7-ae9f-0552e6513a10", }, + { .uuid3 = "6f7177c3-77b0-3f42-82a8-7031e25fcccf", .uuid5 = "10b38db9-82fc-528e-9ddb-1f09b7dbf907", }, + { .uuid3 = "d1e0f845-bc1b-368c-b8c8-49ab0b9e486b", .uuid5 = "85492596-9468-5845-9c7f-d4ae999cb751", }, + { .uuid3 = "46371ea3-c8a3-34d8-b2cf-2fa90bda4378", .uuid5 = "22b1c0dd-aa5d-54a4-8768-5adfd0d112bd", }, + { .uuid3 = "f1e6b499-9b68-343b-a5c5-ece7acc49a68", .uuid5 = "9cc429f8-200e-52a3-9e3b-ef134afa1e29", }, + { .uuid3 = "9ed06458-c712-31dd-aba5-6cf79879fabe", .uuid5 = "3949f95c-5d76-5ee2-af60-8e2d8fcf649d", }, + { .uuid3 = "4ddd5cd7-bc83-36aa-909c-4e660f57c830", .uuid5 = "0e994a02-069b-58fb-b3a4-d7dc94e90fca", }, + { .uuid3 = "335fa537-0909-395d-a696-6f41827dcbeb", .uuid5 = "17db3a41-de9b-5c6b-904d-833943209b3c", }, + { .uuid3 = "dbd58444-05ad-3edd-adc7-4393ecbcb43c", .uuid5 = "1bd906f2-05f9-5ab5-a39a-4c17a188f886", }, + { .uuid3 = "a1c62d82-d13c-361b-8f4e-ca91bc2f7fc5", .uuid5 = "ce6550fd-95b7-57e4-9aa7-461522666be4", }, + { .uuid3 = "e943d83e-3f82-307f-81ed-b7a7bcd0743e", .uuid5 = "04aa09ee-b420-57ac-8a23-5d99907fb0a1", }, + { .uuid3 = "cabf46dd-9f09-375c-8f6e-f2a8cf114709", .uuid5 = "8ece2c62-0c31-5c55-b7c6-155381e3780e", }, + { .uuid3 = "19beddf3-f2fb-340f-96ac-4f394960b7a7", .uuid5 = "5762a9f9-9a21-59ab-b0d2-2cb90027ef7f", }, + { .uuid3 = "08d835c2-f4ca-394c-ba7f-2494d8b60c6c", .uuid5 = "23c8409d-4b5f-5b6a-b946-41e49bad6c78", }, + { .uuid3 = "3b8c6847-5331-35bf-9cd9-ced50e53cd7c", .uuid5 = "e8e396be-95d5-5569-8edc-e0b64c2b7613", }, + { .uuid3 = "e601f160-484b-3254-8f3b-0a25c7203d8a", .uuid5 = "bc8b3cbc-ad5b-5808-a1b0-e0f7a1ad68a3", }, + { .uuid3 = "e5e492ed-5349-379d-b7de-a370a51e44a3", .uuid5 = "62c5ed3f-9afa-59ad-874f-a9dd8afc69d4", }, + { .uuid3 = "c40111f6-fe97-305e-bfce-7db730c3d2ec", .uuid5 = "66877a72-7243-59ed-b9e3-b5023b6da9c2", }, + { .uuid3 = "21e18ea8-95c2-362b-9ca9-25d6a0ff2dff", .uuid5 = "49a49eee-7e86-5d66-837a-8a8810cb5562", }, + { .uuid3 = "adab623b-1343-307f-80d8-58d005376ad9", .uuid5 = "e4a2a7ed-3bf3-53cf-a2bb-154dbb39a38c", }, + { .uuid3 = "67e9fc7c-dafe-356d-ac1a-a63ce3f44813", .uuid5 = "50cacfc9-f5d2-52dd-897c-a25a0927b816", }, + { .uuid3 = "36cc7f20-126c-3e40-94e7-737ac7486547", .uuid5 = "ca629991-3f2b-5e86-9bb7-37a335f7d809", }, + { .uuid3 = "fe282996-ac5e-3d13-b478-5def30007a8e", .uuid5 = "c1adf8a7-f72a-58ae-82d5-d18807f12e2e", }, + { .uuid3 = "3bfe339c-05ae-3233-a1a5-ebf1ead589db", .uuid5 = "6120c3cd-24e1-5ce4-987b-f8bfee2e4633", }, + { .uuid3 = "d1d90bc7-da4a-3cd7-a7c8-a1a89765d8ee", .uuid5 = "433d6a26-c319-5fcf-9a30-5ec6ad59d109", }, + { .uuid3 = "10b88a02-0102-359b-81e9-7e3b0ff7d25e", .uuid5 = "77d228d9-1b96-59e2-a07e-a8fdd4f62884", }, + { .uuid3 = "7da5e4f2-6df0-3aca-a1b0-b7f8b1340e1d", .uuid5 = "698259bf-a32b-5e00-9ec6-88b12278c4ad", }, + { .uuid3 = "cbe24d98-ca20-3058-86b6-24a6b36ceff0", .uuid5 = "60dbca63-704f-5666-9f64-f4e1a630c4aa", }, + { .uuid3 = "04d84e6a-b793-3993-afbf-bae7cfc42b49", .uuid5 = "79d63ec0-a39d-557d-8299-f4c97acfadc3", }, + { .uuid3 = "fdd157d8-a537-350a-9cc9-1930e8666c63", .uuid5 = "7df7f75e-a146-5a76-828b-bac052db312b", }, + { .uuid3 = "0bea36bb-24a7-3ee6-a98d-116433c14cd4", .uuid5 = "2bcca2e9-2879-53e3-b09d-cbbfd58771b2", }, + { .uuid3 = "52b040a4-1b84-32d2-b758-f82386f7e0f0", .uuid5 = "cb7bdca3-e9f7-50cd-b72e-73cb9ff24f62", }, + { .uuid3 = "0f0a4e26-e034-3021-acf2-4e886af43092", .uuid5 = "8e428e2b-5da3-5368-b760-5ca07ccbd819", }, + { .uuid3 = "819d3cd1-afe5-3e4a-9f0c-945e25d09879", .uuid5 = "f340ef4d-139c-567a-b0fc-7c495336674e", }, + { .uuid3 = "e7df1a3b-c9f8-3e5a-88d6-ba72b2a0f27b", .uuid5 = "7e3f5fd2-3c93-58d6-9f35-6e0192445b11", }, + { .uuid3 = "0854bedf-74ba-3f2b-b823-dc2c90d27c76", .uuid5 = "bc112b6b-c5de-5ee9-b816-808792743a20", }, + { .uuid3 = "a1b8c3ba-f821-32ef-a3fd-b97b3855efa8", .uuid5 = "47f8f82d-9fcd-553c-90c5-3f3cb3ad00ad", }, + { .uuid3 = "9458f819-079b-3033-9430-ba10f576c067", .uuid5 = "bee5c091-5f01-51fa-86bb-e9488fd3b4da", }, + { .uuid3 = "8e1f240a-e386-3e00-866a-6f9da1e3503f", .uuid5 = "8ea92cea-d741-566f-a44a-d51e65b4c5e4", }, }; const ExpectedUuids dns_uuids[] = { - { .uuid3 = "4385125b-dd1e-3025-880f-3311517cc8d5", }, - { .uuid3 = "afd0b036-625a-3aa8-b639-9dc8c8fff0ff", }, - { .uuid3 = "9c45c2f1-1761-3daa-ad31-1ff8703ae846", }, - { .uuid3 = "15e0ba07-10e4-3d7f-aaff-c00fed873c88", }, - { .uuid3 = "bc27b4db-bc0f-34f9-ae8e-4b72f2d51b60", }, - { .uuid3 = "7586bfed-b8b8-3bb3-9c95-09a4a79dc0f7", }, - { .uuid3 = "881430b6-8d28-3175-b87d-e81f2f5978c6", }, - { .uuid3 = "24075675-98ae-354e-89ca-0126a9ad36e3", }, - { .uuid3 = "2c269ea4-dbfd-32dd-9bd7-a5c22677d18b", }, - { .uuid3 = "44eb0948-118f-3f28-87e4-f61c8f889aba", }, - { .uuid3 = "fc72beeb-f790-36ee-a73d-33888c9d8880", }, - { .uuid3 = "1e46afa2-6176-3cd3-9750-3015846723df", }, - { .uuid3 = "0042b01d-95bd-343f-bd9f-3186bfd63508", }, - { .uuid3 = "115ff52f-d605-3b4b-98fe-c0ea57f4930c", }, - { .uuid3 = "ed0221e8-ac7d-393b-821d-25183567885b", }, - { .uuid3 = "508ef333-85a6-314c-bcf3-17ddc32b2216", }, - { .uuid3 = "a4715ee0-524a-37cc-beb2-a0b5030757b7", }, - { .uuid3 = "d1c72756-aaec-3470-a2f2-97415f44d72f", }, - { .uuid3 = "7aec2f01-586e-3d53-b8f3-6cf7e6b649a4", }, - { .uuid3 = "3d234b88-8d6f-319a-91ea-edb6059fc825", }, - { .uuid3 = "d2568554-93ec-30c7-9e15-f383be19e5bb", }, - { .uuid3 = "800e59a7-dd0f-3114-8e58-ab7e213895ca", }, - { .uuid3 = "3b7d03f0-e067-3d72-84f4-e410ac36ef57", }, - { .uuid3 = "8762be68-de95-391a-94a0-c5fd0446e037", }, - { .uuid3 = "2bd8b4c9-01af-3cd0-aced-94ee6e2004b8", }, - { .uuid3 = "a627d6a4-394a-33f5-b68e-22bfb6488d01", }, - { .uuid3 = "6a592510-17d9-3925-b321-4a8d4927f8d0", }, - { .uuid3 = "9ee72491-59c4-333c-bb93-fe733a842fdb", }, - { .uuid3 = "2591c62c-0a9d-3c28-97bc-fa0401556a3c", }, - { .uuid3 = "7912be1e-4562-373b-92e2-3d6d2123bc8e", }, - { .uuid3 = "09370cda-89a4-3a48-b592-9c0486e0d5e4", }, - { .uuid3 = "de5980d3-a137-373c-850b-ca3e5f100779", }, - { .uuid3 = "9441501d-f633-365a-8955-9df443edc762", }, - { .uuid3 = "434ada18-13ce-3c08-8b40-a1a1ae030569", }, - { .uuid3 = "a13b6160-bd23-3710-a150-41d800dd30b4", }, - { .uuid3 = "73a67c12-c5f0-3288-ad6a-c78aea0917b0", }, - { .uuid3 = "a126ee4f-a222-357d-b71b-7d3f226c559f", }, - { .uuid3 = "48f4f36b-b015-3137-9b6e-351bb175c7f7", }, - { .uuid3 = "3fe8f6a3-fe4a-3487-89d6-dd06c6ad02e3", }, - { .uuid3 = "d68fa2d4-adc9-3b20-ac77-42585cd1d59f", }, - { .uuid3 = "819f86a3-31d5-3e72-a83e-142c3a3e4832", }, - { .uuid3 = "9957b433-ddc8-3113-a3e6-5512cf13dab1", }, - { .uuid3 = "5aab6e0c-b7d3-379c-92e3-2bfbb5572511", }, - { .uuid3 = "11c8ff30-3a7d-3547-80a7-d61b8abeeda8", }, - { .uuid3 = "98799b9f-1c5e-30b3-930f-e412b862cbe4", }, - { .uuid3 = "9bdf2544-31d8-3555-94b0-6a749118a996", }, - { .uuid3 = "ddcfb9b3-e990-3985-9021-546a2711e7e5", }, - { .uuid3 = "190d7a78-1484-3136-80a6-40f28852785c", }, - { .uuid3 = "6ed693e4-7dc0-3210-856b-a6eb4cc73e13", }, - { .uuid3 = "b6a14b21-e73a-3ce2-9076-a804c434f5c6", }, + { .uuid3 = "4385125b-dd1e-3025-880f-3311517cc8d5", .uuid5 = "6af613b6-569c-5c22-9c37-2ed93f31d3af", }, + { .uuid3 = "afd0b036-625a-3aa8-b639-9dc8c8fff0ff", .uuid5 = "b04965e6-a9bb-591f-8f8a-1adcb2c8dc39", }, + { .uuid3 = "9c45c2f1-1761-3daa-ad31-1ff8703ae846", .uuid5 = "4b166dbe-d99d-5091-abdd-95b83330ed3a", }, + { .uuid3 = "15e0ba07-10e4-3d7f-aaff-c00fed873c88", .uuid5 = "98123fde-012f-5ff3-8b50-881449dac91a", }, + { .uuid3 = "bc27b4db-bc0f-34f9-ae8e-4b72f2d51b60", .uuid5 = "6ed955c6-506a-5343-9be4-2c0afae02eef", }, + { .uuid3 = "7586bfed-b8b8-3bb3-9c95-09a4a79dc0f7", .uuid5 = "c8691da2-158a-5ed6-8537-0e6f140801f2", }, + { .uuid3 = "881430b6-8d28-3175-b87d-e81f2f5978c6", .uuid5 = "a6c4fc8f-6950-51de-a9ae-2c519c465071", }, + { .uuid3 = "24075675-98ae-354e-89ca-0126a9ad36e3", .uuid5 = "a9f96b98-dd44-5216-ab0d-dbfc6b262edf", }, + { .uuid3 = "2c269ea4-dbfd-32dd-9bd7-a5c22677d18b", .uuid5 = "e99caacd-6c45-5906-bd9f-b79e62f25963", }, + { .uuid3 = "44eb0948-118f-3f28-87e4-f61c8f889aba", .uuid5 = "e4d80b30-151e-51b5-9f4f-18a3b82718e6", }, + { .uuid3 = "fc72beeb-f790-36ee-a73d-33888c9d8880", .uuid5 = "0159d6c7-973f-5e7a-a9a0-d195d0ea6fe2", }, + { .uuid3 = "1e46afa2-6176-3cd3-9750-3015846723df", .uuid5 = "7fef88f7-411d-5669-b42d-bf5fc7f9b58b", }, + { .uuid3 = "0042b01d-95bd-343f-bd9f-3186bfd63508", .uuid5 = "52524d6e-10dc-5261-aa36-8b2efcbaa5f0", }, + { .uuid3 = "115ff52f-d605-3b4b-98fe-c0ea57f4930c", .uuid5 = "91c274f2-9a0d-5ce6-ac3d-7529f452df21", }, + { .uuid3 = "ed0221e8-ac7d-393b-821d-25183567885b", .uuid5 = "0ff1e264-520d-543a-87dd-181a491e667e", }, + { .uuid3 = "508ef333-85a6-314c-bcf3-17ddc32b2216", .uuid5 = "23986425-d3a5-5e13-8bab-299745777a8d", }, + { .uuid3 = "a4715ee0-524a-37cc-beb2-a0b5030757b7", .uuid5 = "c15b38c9-9a3e-543c-a703-dd742f25b4d5", }, + { .uuid3 = "d1c72756-aaec-3470-a2f2-97415f44d72f", .uuid5 = "db680066-c83d-5ed7-89a4-1d79466ea62d", }, + { .uuid3 = "7aec2f01-586e-3d53-b8f3-6cf7e6b649a4", .uuid5 = "cadb7952-2bba-5609-88d4-8e47ec4e7920", }, + { .uuid3 = "3d234b88-8d6f-319a-91ea-edb6059fc825", .uuid5 = "35140057-a2a4-5adb-a500-46f8ed8b66a9", }, + { .uuid3 = "d2568554-93ec-30c7-9e15-f383be19e5bb", .uuid5 = "66e549b7-01e2-5d07-98d5-430f74d8d3b2", }, + { .uuid3 = "800e59a7-dd0f-3114-8e58-ab7e213895ca", .uuid5 = "292c8e99-2378-55aa-83d8-350e0ac3f1cc", }, + { .uuid3 = "3b7d03f0-e067-3d72-84f4-e410ac36ef57", .uuid5 = "0e3b230a-0509-55d8-96a0-9875f387a2be", }, + { .uuid3 = "8762be68-de95-391a-94a0-c5fd0446e037", .uuid5 = "4c507660-a83b-55c0-9b2b-83eccb07723d", }, + { .uuid3 = "2bd8b4c9-01af-3cd0-aced-94ee6e2004b8", .uuid5 = "a1b9b633-da11-58be-b1a9-5cfa2848f186", }, + { .uuid3 = "a627d6a4-394a-33f5-b68e-22bfb6488d01", .uuid5 = "c2708a8b-120a-56f5-a30d-990048af87cc", }, + { .uuid3 = "6a592510-17d9-3925-b321-4a8d4927f8d0", .uuid5 = "e7263999-68b6-5a23-b530-af25b7efd632", }, + { .uuid3 = "9ee72491-59c4-333c-bb93-fe733a842fdb", .uuid5 = "ce1ae2d5-3454-5952-97ff-36ff935bcfe9", }, + { .uuid3 = "2591c62c-0a9d-3c28-97bc-fa0401556a3c", .uuid5 = "33677b87-bc8d-5ff6-9a25-fe60225e4bf0", }, + { .uuid3 = "7912be1e-4562-373b-92e2-3d6d2123bc8e", .uuid5 = "ed2305ae-e8f9-5387-b860-3d80ae6c02f7", }, + { .uuid3 = "09370cda-89a4-3a48-b592-9c0486e0d5e4", .uuid5 = "604ed872-ae2d-5d91-8e3e-572f3a3aaaa5", }, + { .uuid3 = "de5980d3-a137-373c-850b-ca3e5f100779", .uuid5 = "8f8173d9-2f8d-5636-a693-24d9f79ba651", }, + { .uuid3 = "9441501d-f633-365a-8955-9df443edc762", .uuid5 = "36eb8d4d-b854-51f1-9fdf-3735964225d5", }, + { .uuid3 = "434ada18-13ce-3c08-8b40-a1a1ae030569", .uuid5 = "3493b6ca-f84b-56a9-97cc-c0bd1c46c4c0", }, + { .uuid3 = "a13b6160-bd23-3710-a150-41d800dd30b4", .uuid5 = "f413ea13-fcd9-5b44-9d22-1fa1f7b063a5", }, + { .uuid3 = "73a67c12-c5f0-3288-ad6a-c78aea0917b0", .uuid5 = "f468d924-d23b-56c2-b90f-3d1cf4b45337", }, + { .uuid3 = "a126ee4f-a222-357d-b71b-7d3f226c559f", .uuid5 = "8828c9d6-ed76-5c09-bf64-ba9e9cd90896", }, + { .uuid3 = "48f4f36b-b015-3137-9b6e-351bb175c7f7", .uuid5 = "facb7618-55ca-5c30-9cba-fd567b6c0611", }, + { .uuid3 = "3fe8f6a3-fe4a-3487-89d6-dd06c6ad02e3", .uuid5 = "96f3de0e-6412-5434-b406-67ef3352ab85", }, + { .uuid3 = "d68fa2d4-adc9-3b20-ac77-42585cd1d59f", .uuid5 = "9ebacb89-40ab-52b3-93a2-9054611d8f55", }, + { .uuid3 = "819f86a3-31d5-3e72-a83e-142c3a3e4832", .uuid5 = "681046ff-9129-5ade-b11c-769864e02184", }, + { .uuid3 = "9957b433-ddc8-3113-a3e6-5512cf13dab1", .uuid5 = "c13d0b5d-1ca3-57b6-a23f-8586bca44928", }, + { .uuid3 = "5aab6e0c-b7d3-379c-92e3-2bfbb5572511", .uuid5 = "7c411b5e-9d3f-50b5-9c28-62096e41c4ed", }, + { .uuid3 = "11c8ff30-3a7d-3547-80a7-d61b8abeeda8", .uuid5 = "f825aafe-6696-5121-b263-6b2c408b7f43", }, + { .uuid3 = "98799b9f-1c5e-30b3-930f-e412b862cbe4", .uuid5 = "f2b4caea-61c3-5bed-8ce7-d8b9d16e129e", }, + { .uuid3 = "9bdf2544-31d8-3555-94b0-6a749118a996", .uuid5 = "3593855a-6557-5736-8cab-172c6987f949", }, + { .uuid3 = "ddcfb9b3-e990-3985-9021-546a2711e7e5", .uuid5 = "36392431-d554-5385-b876-7bc6e1cb26b3", }, + { .uuid3 = "190d7a78-1484-3136-80a6-40f28852785c", .uuid5 = "7e645493-0898-5501-8155-e8578b4f5224", }, + { .uuid3 = "6ed693e4-7dc0-3210-856b-a6eb4cc73e13", .uuid5 = "14dc6a81-0491-5683-baaf-7582a61c5798", }, + { .uuid3 = "b6a14b21-e73a-3ce2-9076-a804c434f5c6", .uuid5 = "883e0a9c-e3b3-5f9c-8073-2913cbbb99ec", }, }; char i_str[30]; guint i; @@ -5614,20 +5617,33 @@ test_nm_utils_uuid_generate_from_string (void) _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "9a75f5f2-195e-31a9-9d07-8c18b5d3b285", "test123", -1, UUID_NS_DNS); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "ec794efe-a384-3b11-a0b6-ec8995bc6acc", "x", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "a7650b9f-f19f-5300-8a13-91160ea8de2c", "a\0b", 3, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "4f3f2898-69e3-5a0d-820a-c4e87987dbce", "a", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "05b16a01-46c6-56dd-bd6e-c6dfb4a1427a", "x", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "c9ed566a-6b79-5d3a-b2b7-96a936b48cf3", "test123", -1, UUID_NS_DNS); + for (i = 0; i < G_N_ELEMENTS (zero_uuids); i++) { nm_sprintf_buf (i_str, "%u", i), _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, zero_uuids[i].uuid3, i_str, -1, NULL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, zero_uuids[i].uuid5, i_str, -1, NULL); } for (i = 0; i < G_N_ELEMENTS (dns_uuids); i++) { nm_sprintf_buf (i_str, "%u", i), _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, dns_uuids[i].uuid3, i_str, -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, dns_uuids[i].uuid5, i_str, -1, UUID_NS_DNS); } /* examples from cpython unit tests: */ _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "6fa459ea-ee8a-3ca4-894e-db77e160355e", "python.org", -1, UUID_NS_DNS); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "886313e1-3b8a-5372-9b90-0c9aee199e5d", "python.org", -1, UUID_NS_DNS); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "9fe8e8c4-aaa8-32a9-a55c-4535a88b748d", "http://python.org/", -1, UUID_NS_URL); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "4c565f0d-3f5a-5890-b41b-20cf47701c5e", "http://python.org/", -1, UUID_NS_URL); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "dd1a1cef-13d5-368a-ad82-eca71acd4cd1", "1.3.6.1", -1, UUID_NS_OID); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "1447fa61-5277-5fef-a9b3-fbc6e44f4af3", "1.3.6.1", -1, UUID_NS_OID); _test_uuid (NM_UTILS_UUID_TYPE_VERSION3, "658d3002-db6b-3040-a1d1-8ddd7d189a4d", "c=ca", -1, UUID_NS_X500); + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "cc957dd1-a972-5349-98cd-874190002798", "c=ca", -1, UUID_NS_X500); + + _test_uuid (NM_UTILS_UUID_TYPE_VERSION5, "74738ff5-5367-5958-9aee-98fffdcd1876", "www.example.org", -1, UUID_NS_DNS); } /*****************************************************************************/ From b9d2503843511d67d465610ef0c58dcb9f569ab1 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 31 Oct 2018 10:14:54 +0100 Subject: [PATCH 5/6] libnm: add nm_utils_uuid_generate_from_string_bin() function (cherry picked from commit 4db431191cd095ab0584212b59f1c2b9d9201fd2) --- libnm-core/nm-core-internal.h | 2 + libnm-core/nm-utils.c | 135 ++++++++++++++++++++-------------- 2 files changed, 81 insertions(+), 56 deletions(-) diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h index 1121a4727a..7acf273b25 100644 --- a/libnm-core/nm-core-internal.h +++ b/libnm-core/nm-core-internal.h @@ -295,6 +295,8 @@ NMUuid *_nm_utils_uuid_generate_random (NMUuid *out_uuid); #define NM_UTILS_UUID_TYPE_VERSION3 3 #define NM_UTILS_UUID_TYPE_VERSION5 5 +NMUuid *nm_utils_uuid_generate_from_string_bin (NMUuid *uuid, const char *s, gssize slen, int uuid_type, gpointer type_args); + char *nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, gpointer type_args); /* arbitrarily chosen namespace UUID for _nm_utils_uuid_generate_from_strings() */ diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c index 562461a49c..1e1f2b88f6 100644 --- a/libnm-core/nm-utils.c +++ b/libnm-core/nm-utils.c @@ -2850,6 +2850,84 @@ nm_utils_uuid_generate (void) return nm_utils_uuid_generate_buf_ (g_malloc (37)); } +/** + * nm_utils_uuid_generate_from_string_bin: + * @uuid: the UUID to update inplace. This function cannot + * fail to succeed. + * @s: a string to use as the seed for the UUID + * @slen: if negative, treat @s as zero terminated C string. + * Otherwise, assume the length as given (and allow @s to be + * non-null terminated or contain '\0'). + * @uuid_type: a type identifier which UUID format to generate. + * @type_args: additional arguments, depending on the uuid_type + * + * For a given @s, this function will always return the same UUID. + * + * Returns: the input @uuid. This function cannot fail. + **/ +NMUuid * +nm_utils_uuid_generate_from_string_bin (NMUuid *uuid, const char *s, gssize slen, int uuid_type, gpointer type_args) +{ + g_return_val_if_fail (uuid, FALSE); + g_return_val_if_fail (slen == 0 || s, FALSE); + + if (slen < 0) + slen = s ? strlen (s) : 0; + + switch (uuid_type) { + case NM_UTILS_UUID_TYPE_LEGACY: + g_return_val_if_fail (!type_args, NULL); + nm_crypto_md5_hash (NULL, + 0, + (guint8 *) s, + slen, + (guint8 *) uuid, + sizeof (*uuid)); + break; + case NM_UTILS_UUID_TYPE_VERSION3: + case NM_UTILS_UUID_TYPE_VERSION5: { + NMUuid ns_uuid = { 0 }; + + if (type_args) { + /* type_args can be a name space UUID. Interpret it as (char *) */ + if (!_nm_utils_uuid_parse (type_args, &ns_uuid)) + g_return_val_if_reached (NULL); + } + + if (uuid_type == NM_UTILS_UUID_TYPE_VERSION3) { + nm_crypto_md5_hash ((guint8 *) s, + slen, + (guint8 *) &ns_uuid, + sizeof (ns_uuid), + (guint8 *) uuid, + sizeof (*uuid)); + } else { + nm_auto_free_checksum GChecksum *sum = NULL; + guint8 buf[20]; + gsize len; + + sum = g_checksum_new (G_CHECKSUM_SHA1); + g_checksum_update (sum, (guchar *) &ns_uuid, sizeof (ns_uuid)); + g_checksum_update (sum, (guchar *) s, slen); + len = sizeof (buf); + g_checksum_get_digest (sum, buf, &len); + nm_assert (len == sizeof (buf)); + + G_STATIC_ASSERT_EXPR (sizeof (*uuid) <= sizeof (buf)); + memcpy (uuid, buf, sizeof (*uuid)); + } + + uuid->uuid[6] = (uuid->uuid[6] & 0x0F) | (uuid_type << 4); + uuid->uuid[8] = (uuid->uuid[8] & 0x3F) | 0x80; + break; + } + default: + g_return_val_if_reached (NULL); + } + + return uuid; +} + /** * nm_utils_uuid_generate_from_string: * @s: a string to use as the seed for the UUID @@ -2869,62 +2947,7 @@ nm_utils_uuid_generate_from_string (const char *s, gssize slen, int uuid_type, g { NMUuid uuid; - g_return_val_if_fail (slen == 0 || s, FALSE); - - if (slen < 0) - slen = s ? strlen (s) : 0; - - switch (uuid_type) { - case NM_UTILS_UUID_TYPE_LEGACY: - g_return_val_if_fail (!type_args, NULL); - nm_crypto_md5_hash (NULL, - 0, - (guint8 *) s, - slen, - (guint8 *) &uuid, - sizeof (uuid)); - break; - case NM_UTILS_UUID_TYPE_VERSION3: - case NM_UTILS_UUID_TYPE_VERSION5: { - NMUuid ns_uuid = { 0 }; - - if (type_args) { - /* type_args can be a name space UUID. Interpret it as (char *) */ - if (!_nm_utils_uuid_parse (type_args, &ns_uuid)) - g_return_val_if_reached (NULL); - } - - if (uuid_type == NM_UTILS_UUID_TYPE_VERSION3) { - nm_crypto_md5_hash ((guint8 *) s, - slen, - (guint8 *) &ns_uuid, - sizeof (ns_uuid), - (guint8 *) &uuid, - sizeof (uuid)); - } else { - nm_auto_free_checksum GChecksum *sum = NULL; - guint8 buf[20]; - gsize len; - - sum = g_checksum_new (G_CHECKSUM_SHA1); - g_checksum_update (sum, (guchar *) &ns_uuid, sizeof (ns_uuid)); - g_checksum_update (sum, (guchar *) s, slen); - len = sizeof (buf); - g_checksum_get_digest (sum, buf, &len); - nm_assert (len == sizeof (buf)); - - G_STATIC_ASSERT_EXPR (sizeof (uuid) <= sizeof (buf)); - memcpy (&uuid, buf, sizeof (uuid)); - } - - uuid.uuid[6] = (uuid.uuid[6] & 0x0F) | (uuid_type << 4); - uuid.uuid[8] = (uuid.uuid[8] & 0x3F) | 0x80; - break; - } - default: - g_return_val_if_reached (NULL); - } - + nm_utils_uuid_generate_from_string_bin (&uuid, s, slen, uuid_type, type_args); return _nm_utils_uuid_unparse (&uuid, NULL); } From 0e3f35edeb719202d2aeb98a91f6dec6c72ba8b9 Mon Sep 17 00:00:00 2001 From: Thomas Haller Date: Wed, 31 Oct 2018 10:38:01 +0100 Subject: [PATCH 6/6] libnm: add nm_utils_uuid_is_null() helper (cherry picked from commit 01239e99d7ded2279a82c6fbb9cb068804eaaf22) --- libnm-core/nm-core-internal.h | 2 ++ libnm-core/nm-utils.c | 15 +++++++++++++++ libnm-core/tests/test-general.c | 19 +++++++++++++++++++ 3 files changed, 36 insertions(+) diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h index 7acf273b25..e677f51cf8 100644 --- a/libnm-core/nm-core-internal.h +++ b/libnm-core/nm-core-internal.h @@ -291,6 +291,8 @@ char *_nm_utils_uuid_unparse (const NMUuid *uuid, char *out_str /*[37]*/); NMUuid *_nm_utils_uuid_generate_random (NMUuid *out_uuid); +gboolean nm_utils_uuid_is_null (const NMUuid *uuid); + #define NM_UTILS_UUID_TYPE_LEGACY 0 #define NM_UTILS_UUID_TYPE_VERSION3 3 #define NM_UTILS_UUID_TYPE_VERSION5 5 diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c index 1e1f2b88f6..d595b53a75 100644 --- a/libnm-core/nm-utils.c +++ b/libnm-core/nm-utils.c @@ -2821,6 +2821,21 @@ _nm_utils_uuid_generate_random (NMUuid *out_uuid) return out_uuid; } +gboolean +nm_utils_uuid_is_null (const NMUuid *uuid) +{ + int i; + + if (!uuid) + return TRUE; + + for (i = 0; i < G_N_ELEMENTS (uuid->uuid); i++) { + if (uuid->uuid[i]) + return FALSE; + } + return TRUE; +} + /** * nm_utils_uuid_generate_buf_: * @buf: input buffer, must contain at least 37 bytes diff --git a/libnm-core/tests/test-general.c b/libnm-core/tests/test-general.c index 0f0b1c5278..67b80098a6 100644 --- a/libnm-core/tests/test-general.c +++ b/libnm-core/tests/test-general.c @@ -5445,6 +5445,16 @@ test_nm_strquote (void) #define UUID_NS_OID "6ba7b812-9dad-11d1-80b4-00c04fd430c8" #define UUID_NS_X500 "6ba7b814-9dad-11d1-80b4-00c04fd430c8" +static const NMUuid * +_uuid (const char *str) +{ + static NMUuid u; + + g_assert (str); + g_assert (_nm_utils_uuid_parse (str, &u)); + return &u; +} + static void _test_uuid (int uuid_type, const char *expected_uuid, const char *str, gssize slen, gpointer type_args) { @@ -5677,6 +5687,15 @@ __test_uuid (const char *expected_uuid, const char *str, gssize slen, char *uuid static void test_nm_utils_uuid_generate_from_strings (void) { + const NMUuid uuid0 = { 0 }; + + g_assert_cmpmem (&uuid0, sizeof (uuid0), _uuid ("00000000-0000-0000-0000-000000000000"), 16); + + g_assert (nm_utils_uuid_is_null (NULL)); + g_assert (nm_utils_uuid_is_null (&uuid0)); + g_assert ( nm_utils_uuid_is_null (_uuid ("00000000-0000-0000-0000-000000000000"))); + g_assert (!nm_utils_uuid_is_null (_uuid ("10000000-0000-0000-0000-000000000000"))); + _test_uuid ("b07c334a-399b-32de-8d50-58e4e08f98e3", "", 0, NULL); _test_uuid ("b8a426cb-bcb5-30a3-bd8f-6786fea72df9", "\0", 1, ""); _test_uuid ("12a4a982-7aae-39e1-951e-41aeb1250959", "a\0", 2, "a");