util: Add simple UUID type

Provide our own UUID type as there is no point to have a dependency on
libuuid just for a couple function we use.

Signed-off-by: Daniel Wagner <[email protected]>

Author: dwsuse

meson.build

@@ -52,10 +52,6 @@ conf.set('PROJECT_VERSION', '"@0@"'.format(meson.project_version()))
 
 conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir))
 
-# Check for libuuid availability
-libuuid_dep = dependency('uuid', required: true, fallback : ['uuid', 'uuid_dep'])
-conf.set('CONFIG_LIBUUID', libuuid_dep.found(), description: 'Is libuuid required?')
-
 # Check for json-c availability
 json_c_dep = dependency('json-c',
 			version: '>=0.13',

src/libnvme.map

@@ -7,6 +7,9 @@ LIBNVME_1_2 {
 		nvmf_get_discovery_wargs;
 		nvme_get_feature_length2;
 		nvme_ctrl_is_persistent;
+		nvme_uuid_from_string;
+		nvme_uuid_to_string;
+		nvme_uuid_random;
 };
 
 LIBNVME_1_1 {

src/meson.build

@@ -28,13 +28,11 @@ if conf.get('CONFIG_JSONC')
 endif
 
 deps = [
-    libuuid_dep,
     json_c_dep,
     openssl_dep,
 ]
 
 mi_deps = [
-    libuuid_dep,
     libsystemd_dep,
 ]
 
@@ -68,7 +66,6 @@ pkg.generate(libnvme,
 libnvme_dep = declare_dependency(
     include_directories: ['.'],
     dependencies: [
-      libuuid_dep.partial_dependency(compile_args: true, includes: true),
       json_c_dep.partial_dependency(compile_args: true, includes: true),
     ],
     link_with: libnvme,
@@ -88,9 +85,6 @@ libnvme_mi = library(
 
 libnvme_mi_dep = declare_dependency(
     include_directories: ['.'],
-    dependencies: [
-      libuuid_dep.partial_dependency(compile_args: true, includes: true),
-    ],
     link_with: libnvme_mi,
 )
 
@@ -107,9 +101,6 @@ libnvme_mi_test = library(
 
 libnvme_mi_test_dep = declare_dependency(
     include_directories: ['.'],
-    dependencies: [
-      libuuid_dep.partial_dependency(compile_args: true, includes: true),
-    ],
     link_with: libnvme_mi_test,
 )
 

src/nvme/fabrics.c

@@ -39,7 +39,6 @@
 #include "private.h"
 
 #define NVMF_HOSTID_SIZE	37
-#define UUID_SIZE		37  /* 1b4e28ba-2fa1-11d2-883f-0016d3cca427 + \0 */
 
 #define NVMF_HOSTNQN_FILE	SYSCONFDIR "/nvme/hostnqn"
 #define NVMF_HOSTID_FILE	SYSCONFDIR "/nvme/hostid"
@@ -929,8 +928,8 @@ static int uuid_from_device_tree(char *system_uuid)
 	if (f < 0)
 		return -ENXIO;
 
-	memset(system_uuid, 0, UUID_SIZE);
-	len = read(f, system_uuid, UUID_SIZE - 1);
+	memset(system_uuid, 0, NVME_UUID_LEN_STRING);
+	len = read(f, system_uuid, NVME_UUID_LEN_STRING - 1);
 	close(f);
 	if (len < 0)
 		return -ENXIO;
@@ -1018,16 +1017,16 @@ static int uuid_from_product_uuid(char *system_uuid)
 	system_uuid[0] = '\0';
 
 	nread = getline(&line, &len, stream);
-	if (nread != UUID_SIZE) {
+	if (nread != NVME_UUID_LEN_STRING) {
 		ret = -ENXIO;
 		goto out;
 	}
 
 	/* The kernel is handling the byte swapping according DMTF
 	 * SMBIOS 3.0 Section 7.2.1 System UUID */
 
-	memcpy(system_uuid, line, UUID_SIZE - 1);
-	system_uuid[UUID_SIZE - 1] = '\0';
+	memcpy(system_uuid, line, NVME_UUID_LEN_STRING - 1);
+	system_uuid[NVME_UUID_LEN_STRING - 1] = '\0';
 
 	ret = 0;
 
@@ -1063,16 +1062,17 @@ char *nvmf_hostnqn_generate()
 {
 	char *hostnqn;
 	int ret;
-	char uuid_str[UUID_SIZE];
-	uuid_t uuid;
+	char uuid_str[NVME_UUID_LEN_STRING];
+	unsigned char uuid[NVME_UUID_LEN];
 
 	ret = uuid_from_dmi(uuid_str);
 	if (ret < 0) {
 		ret = uuid_from_device_tree(uuid_str);
 	}
 	if (ret < 0) {
-		uuid_generate_random(uuid);
-		uuid_unparse_lower(uuid, uuid_str);
+		if (nvme_uuid_random(uuid) < 0)
+			memset(uuid, 0, NVME_UUID_LEN);
+		nvme_uuid_to_string(uuid, uuid_str);
 	}
 
 	if (asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", uuid_str) < 0)
@@ -1125,7 +1125,7 @@ static __u32 nvmf_get_tel(const char *hostsymname)
 	__u16 len;
 
 	/* Host ID is mandatory */
-	tel += nvmf_exat_size(sizeof(uuid_t));
+	tel += nvmf_exat_size(NVME_UUID_LEN_STRING);
 
 	/* Symbolic name is optional */
 	len = hostsymname ? strlen(hostsymname) : 0;
@@ -1169,8 +1169,8 @@ static void nvmf_fill_die(struct nvmf_ext_die *die, struct nvme_host *h,
 	numexat++;
 	exat = die->exat;
 	exat->exattype = cpu_to_le16(NVMF_EXATTYPE_HOSTID);
-	exat->exatlen  = cpu_to_le16(nvmf_exat_len(sizeof(uuid_t)));
-	uuid_parse(h->hostid, exat->exatval);
+	exat->exatlen  = cpu_to_le16(nvmf_exat_len(NVME_UUID_LEN));
+	nvme_uuid_from_string(h->hostid, exat->exatval);
 
 	/* Extended Attribute for the Symbolic Name (optional) */
 	symname_len = h->hostsymname ? strlen(h->hostsymname) : 0;

src/nvme/private.h

@@ -16,8 +16,6 @@
 #include "fabrics.h"
 #include "mi.h"
 
-#include <uuid.h>
-
 
 extern const char *nvme_ctrl_sysfs_dir;
 extern const char *nvme_subsys_sysfs_dir;
@@ -57,7 +55,7 @@ struct nvme_ns {
 
 	uint8_t eui64[8];
 	uint8_t nguid[16];
-	uuid_t  uuid;
+	unsigned char uuid[NVME_UUID_LEN];
 	enum nvme_csi csi;
 };
 

src/nvme/tree.c

@@ -1551,9 +1551,9 @@ const uint8_t *nvme_ns_get_nguid(nvme_ns_t n)
 	return n->nguid;
 }
 
-void nvme_ns_get_uuid(nvme_ns_t n, uuid_t out)
+void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN])
 {
-	uuid_copy(out, n->uuid);
+	memcpy(out, n->uuid, NVME_UUID_LEN);
 }
 
 int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns)

src/nvme/tree.h

@@ -15,7 +15,6 @@
 #include <stddef.h>
 
 #include <sys/types.h>
-#include <uuid.h>
 
 #include "ioctl.h"
 #include "util.h"
@@ -521,7 +520,7 @@ const uint8_t *nvme_ns_get_nguid(nvme_ns_t n);
  *
  * Copies the namespace's uuid into @out
  */
-void nvme_ns_get_uuid(nvme_ns_t n, uuid_t out);
+void nvme_ns_get_uuid(nvme_ns_t n, unsigned char out[NVME_UUID_LEN]);
 
 /**
  * nvme_ns_get_sysfs_dir() - sysfs directory of a namespace

src/nvme/util.c

@@ -11,6 +11,8 @@
 #include <string.h>
 #include <errno.h>
 
+#include <sys/stat.h>
+#include <fcntl.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <arpa/inet.h>
@@ -833,3 +835,57 @@ const char *nvme_get_version(enum nvme_version type)
 		return "n/a";
 	}
 }
+
+int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str)
+{
+	int n;
+	n = snprintf(str, NVME_UUID_LEN_STRING,
+		     "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
+		     "%02x%02x-%02x%02x%02x%02x%02x%02x",
+		     uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5],
+		     uuid[6], uuid[7], uuid[8], uuid[9], uuid[10], uuid[11],
+		     uuid[12], uuid[13], uuid[14], uuid[15]);
+	return n != NVME_UUID_LEN_STRING - 1 ? -EINVAL : 0;
+}
+
+int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN])
+{
+	int n;
+
+	n = sscanf(str,
+		   "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-"
+		   "%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
+		   &uuid[0], &uuid[1], &uuid[2], &uuid[3], &uuid[4], &uuid[5],
+		   &uuid[6], &uuid[7], &uuid[8], &uuid[9], &uuid[10], &uuid[11],
+		   &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
+	return n != NVME_UUID_LEN ? -EINVAL : 0;
+
+}
+
+int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN])
+{
+	int f;
+	ssize_t n;
+
+	f = open("/dev/urandom", O_RDONLY);
+	if (f < 0)
+		return -errno;
+	n = read(f, uuid, NVME_UUID_LEN);
+	if (n < 0) {
+		close(f);
+		return -errno;
+	} else if (n != NVME_UUID_LEN) {
+		close(f);
+		return -EIO;
+	}
+
+	/*
+	 * See https://www.rfc-editor.org/rfc/rfc4122#section-4.4
+	 * Algorithms for Creating a UUID from Truly Random
+	 * or Pseudo-Random Numbers
+	 */
+	uuid[6] = (uuid[6] & 0x0f) | 0x40;
+	uuid[8] = (uuid[8] & 0x3f) | 0x80;
+
+	return 0;
+}

src/nvme/util.h

@@ -606,4 +606,36 @@ enum nvme_version {
  */
 const char *nvme_get_version(enum nvme_version type);
 
+#define NVME_UUID_LEN_STRING	37  /* 1b4e28ba-2fa1-11d2-883f-0016d3cca427 + \0 */
+#define NVME_UUID_LEN		16
+
+/**
+ * nvme_uuid_to_string - Return string represenation of encoded UUID
+ * @uuid:	Binary encoded input UUID
+ * @str:	Output string represenation of UUID
+ *
+ * Return: Returns error code if type conversion fails.
+ */
+int nvme_uuid_to_string(unsigned char uuid[NVME_UUID_LEN], char *str);
+
+/**
+ * nvme_uuid_from_string - Return encoded UUID represenation of string UUID
+ * @uuid:	Binary encoded input UUID
+ * @str:	Output string represenation of UUID
+ *
+ * Return: Returns error code if type conversion fails.
+ */
+int nvme_uuid_from_string(const char *str, unsigned char uuid[NVME_UUID_LEN]);
+
+/**
+ * nvme_uuid_random - Generate random UUID
+ * @uuid:       Generated random UUID
+ *
+ * Generate random number according
+ * https://www.rfc-editor.org/rfc/rfc4122#section-4.4
+ *
+ * Return: Returns error code if generating of random number fails.
+ */
+int nvme_uuid_random(unsigned char uuid[NVME_UUID_LEN]);
+
 #endif /* _LIBNVME_UTIL_H */

test/meson.build

@@ -12,7 +12,7 @@
 main = executable(
     'main-test',
     ['test.c'],
-    dependencies: [libnvme_dep, libuuid_dep],
+    dependencies: [libnvme_dep],
     include_directories: [incdir, internal_incdir]
 )
 
@@ -56,3 +56,12 @@ mi_mctp = executable(
 )
 
 test('mi-mctp', mi_mctp)
+
+uuid = executable(
+    'test-uuid',
+    ['uuid.c'],
+    dependencies: libnvme_dep,
+    include_directories: [incdir, internal_incdir]
+)
+
+test('uuid', uuid)