From 083e415a4908e2cdf7a9bf627d0aa637a7f2b04f Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Thu, 27 Sep 2018 15:39:29 +0200

Subject: [PATCH 1/7] all/trivial: rename hexstr<>bin conversion functions

"bin2str" and "str2bin" are not very clear. These strings are

hex-strings. Rename.

(cherry picked from commit 6714440669d27a59a6e0bcadd642c28f0c9d5737)

(cherry picked from commit cc93cf46adb8957ff21eb295c7680954ee1aabc2)

---

 libnm-core/nm-core-internal.h                 | 18 +++++------

 libnm-core/nm-utils.c                         | 32 +++++++++----------

 src/devices/nm-device.c                       | 12 +++----

 src/dhcp/nm-dhcp-utils.c                      |  2 +-

 .../plugins/ifcfg-rh/nms-ifcfg-rh-reader.c    |  2 +-

 5 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h

index cd2a77a71..be95ba0e1 100644

--- a/libnm-core/nm-core-internal.h

+++ b/libnm-core/nm-core-internal.h

@@ -212,15 +212,15 @@ guint nm_setting_ethtool_init_features (NMSettingEthtool *setting,

 guint8 *_nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize buffer_length, gsize *out_length);

 const char *nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_case, char *buf, gsize buf_len);

-char *_nm_utils_bin2str (gconstpointer addr, gsize length, gboolean upper_case);

-void _nm_utils_bin2str_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

-

-guint8 *_nm_utils_str2bin_full (const char *asc,

-                                gboolean delimiter_required,

-                                const char *delimiter_candidates,

-                                guint8 *buffer,

-                                gsize buffer_length,

-                                gsize *out_len);

+char *_nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case);

+void _nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

+

+guint8 *_nm_utils_hexstr2bin_full (const char *asc,

+                                   gboolean delimiter_required,

+                                   const char *delimiter_candidates,

+                                   guint8 *buffer,

+                                   gsize buffer_length,

+                                   gsize *out_len);

 GSList *    _nm_utils_hash_values_to_slist (GHashTable *hash);

diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c

index d4cbde1df..962cf8b8f 100644

--- a/libnm-core/nm-utils.c

+++ b/libnm-core/nm-utils.c

@@ -3613,12 +3613,12 @@ nm_utils_hwaddr_len (int type)

 }

 guint8 *

-_nm_utils_str2bin_full (const char *asc,

-                        gboolean delimiter_required,

-                        const char *delimiter_candidates,

-                        guint8 *buffer,

-                        gsize buffer_length,

-                        gsize *out_len)

+_nm_utils_hexstr2bin_full (const char *asc,

+                           gboolean delimiter_required,

+                           const char *delimiter_candidates,

+                           guint8 *buffer,

+                           gsize buffer_length,

+                           gsize *out_len)

 {

 	const char *in = asc;

 	guint8 *out = buffer;

@@ -3688,7 +3688,7 @@ _nm_utils_str2bin_full (const char *asc,

 	return buffer;

 }

-#define hwaddr_aton(asc, buffer, buffer_length, out_len) _nm_utils_str2bin_full ((asc), TRUE, ":-", (buffer), (buffer_length), (out_len))

+#define hwaddr_aton(asc, buffer, buffer_length, out_len) _nm_utils_hexstr2bin_full ((asc), TRUE, ":-", (buffer), (buffer_length), (out_len))

 /**

  * nm_utils_hexstr2bin:

@@ -3714,7 +3714,7 @@ nm_utils_hexstr2bin (const char *hex)

 	buffer_length = strlen (hex) / 2 + 3;

 	buffer = g_malloc (buffer_length);

-	if (!_nm_utils_str2bin_full (hex, FALSE, ":", buffer, buffer_length, &len)) {

+	if (!_nm_utils_hexstr2bin_full (hex, FALSE, ":", buffer, buffer_length, &len)) {

 		g_free (buffer);

 		return NULL;

 	}

@@ -3815,7 +3815,7 @@ nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize length)

 }

 void

-_nm_utils_bin2str_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out)

+_nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out)

 {

 	const guint8 *in = addr;

 	const char *LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef";

@@ -3865,7 +3865,7 @@ nm_utils_bin2hexstr (gconstpointer src, gsize len, int final_len)

 	g_return_val_if_fail (final_len < 0 || (gsize) final_len < buflen, NULL);

 	result = g_malloc (buflen);

-	_nm_utils_bin2str_full (src, len, '\0', FALSE, result);

+	_nm_utils_bin2hexstr_full (src, len, '\0', FALSE, result);

 	/* Cut converted key off at the correct length for this cipher type */

 	if (final_len >= 0 && (gsize) final_len < buflen)

@@ -3892,7 +3892,7 @@ nm_utils_hwaddr_ntoa (gconstpointer addr, gsize length)

 	g_return_val_if_fail (length > 0, g_strdup (""));

 	result = g_malloc (length * 3);

-	_nm_utils_bin2str_full (addr, length, ':', TRUE, result);

+	_nm_utils_bin2hexstr_full (addr, length, ':', TRUE, result);

 	return result;

 }

@@ -3905,12 +3905,12 @@ nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_cas

 	if (buf_len < addr_len * 3)

 		g_return_val_if_reached (NULL);

-	_nm_utils_bin2str_full (addr, addr_len, ':', upper_case, buf);

+	_nm_utils_bin2hexstr_full (addr, addr_len, ':', upper_case, buf);

 	return buf;

 }

 /**

- * _nm_utils_bin2str:

+ * _nm_utils_bin2hexstr:

  * @addr: (type guint8) (array length=length): a binary hardware address

  * @length: the length of @addr

  * @upper_case: the case for the hexadecimal digits.

@@ -3920,7 +3920,7 @@ nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_cas

  * Return value: (transfer full): the textual form of @addr

  */

 char *

-_nm_utils_bin2str (gconstpointer addr, gsize length, gboolean upper_case)

+_nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case)

 {

 	char *result;

@@ -3928,7 +3928,7 @@ _nm_utils_bin2str (gconstpointer addr, gsize length, gboolean upper_case)

 	g_return_val_if_fail (length > 0, g_strdup (""));

 	result = g_malloc (length * 3);

-	_nm_utils_bin2str_full (addr, length, ':', upper_case, result);

+	_nm_utils_bin2hexstr_full (addr, length, ':', upper_case, result);

 	return result;

 }

@@ -4596,7 +4596,7 @@ _nm_utils_dhcp_duid_valid (const char *duid, GBytes **out_duid_bin)

 		return TRUE;

 	}

-	if (_nm_utils_str2bin_full (duid, FALSE, ":", duid_arr, sizeof (duid_arr), &duid_len)) {

+	if (_nm_utils_hexstr2bin_full (duid, FALSE, ":", duid_arr, sizeof (duid_arr), &duid_len)) {

 		/* MAX DUID length is 128 octects + the type code (2 octects). */

 		if (   duid_len > 2

 		    && duid_len <= (128 + 2)) {

diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c

index 51751ecf3..2de575cff 100644

--- a/src/devices/nm-device.c

+++ b/src/devices/nm-device.c

@@ -14349,9 +14349,9 @@ nm_device_spawn_iface_helper (NMDevice *self)

 			if (client_id) {

 				g_ptr_array_add (argv, g_strdup ("--dhcp4-clientid"));

 				g_ptr_array_add (argv,

-				                 _nm_utils_bin2str (g_bytes_get_data (client_id, NULL),

-				                                    g_bytes_get_size (client_id),

-				                                    FALSE));

+				                 _nm_utils_bin2hexstr (g_bytes_get_data (client_id, NULL),

+				                                       g_bytes_get_size (client_id),

+				                                       FALSE));

 			}

 			hostname = nm_dhcp_client_get_hostname (priv->dhcp4.client);

@@ -14389,9 +14389,9 @@ nm_device_spawn_iface_helper (NMDevice *self)

 		if (nm_device_get_ip_iface_identifier (self, &iid, FALSE)) {

 			g_ptr_array_add (argv, g_strdup ("--iid"));

 			g_ptr_array_add (argv,

-			                 _nm_utils_bin2str (iid.id_u8,

-			                                    sizeof (NMUtilsIPv6IfaceId),

-			                                    FALSE));

+			                 _nm_utils_bin2hexstr (iid.id_u8,

+			                                       sizeof (NMUtilsIPv6IfaceId),

+			                                       FALSE));

 		}

 		g_ptr_array_add (argv, g_strdup ("--addr-gen-mode"));

diff --git a/src/dhcp/nm-dhcp-utils.c b/src/dhcp/nm-dhcp-utils.c

index 6bbc670b2..f6d97b5ff 100644

--- a/src/dhcp/nm-dhcp-utils.c

+++ b/src/dhcp/nm-dhcp-utils.c

@@ -729,7 +729,7 @@ nm_dhcp_utils_duid_to_string (GBytes *duid)

 	g_return_val_if_fail (duid != NULL, NULL);

 	data = g_bytes_get_data (duid, &len;;

-	return _nm_utils_bin2str (data, len, FALSE);

+	return _nm_utils_bin2hexstr (data, len, FALSE);

 }

 /**

diff --git a/src/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c b/src/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c

index 09a379914..f8c4d18d4 100644

--- a/src/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c

+++ b/src/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c

@@ -189,7 +189,7 @@ _secret_password_raw_to_bytes (const char *ifcfg_key,

 		password_raw += 2;

 	secret = nm_secret_buf_new (strlen (password_raw) / 2 + 3);

-	if (!_nm_utils_str2bin_full (password_raw, FALSE, ":", secret->bin, secret->len, &len)) {

+	if (!_nm_utils_hexstr2bin_full (password_raw, FALSE, ":", secret->bin, secret->len, &len)) {

 		g_set_error (error, NM_SETTINGS_ERROR, NM_SETTINGS_ERROR_INVALID_CONNECTION,

 		             "Invalid hex password in %s",

 		             ifcfg_key);

-- 

2.19.1

From 3305ae13a18b39b3cde94ee80e882a48610b677e Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Thu, 27 Sep 2018 15:47:35 +0200

Subject: [PATCH 2/7] libnm: return output buffer from

 _nm_utils_bin2hexstr_full()

It's just more convenient, as it allows better chaining.

Also, allow passing %NULL as @out buffer. It's clear how

large the output buffer must be, so for convenience let the

function (optionally) allocate a new buffer.

This behavior of whether to

  - take @out, fill it, and return @out

  - take no @out, allocate new buffer, fill and and return it

is slightly error prone. But it was already error prone before, when

it would accept an input buffer without explicit buffer length. I think

this makes it more safe, because in the common case the caller can avoid

pre-allocating a buffer of the right size and the function gets it

right.

(cherry picked from commit 21df8d38effc8d9a36d7f2ac5fb674ddbf848a25)

(cherry picked from commit f4973558dc7036b54b23c69ae57123ef26ba8d0c)

---

 libnm-core/nm-core-internal.h |  2 +-

 libnm-core/nm-utils.c         | 53 +++++++++++++++++++++++++----------

 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h

index be95ba0e1..c3be9acef 100644

--- a/libnm-core/nm-core-internal.h

+++ b/libnm-core/nm-core-internal.h

@@ -213,7 +213,7 @@ guint8 *_nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize buffer_le

 const char *nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_case, char *buf, gsize buf_len);

 char *_nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case);

-void _nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

+char *_nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

 guint8 *_nm_utils_hexstr2bin_full (const char *asc,

                                    gboolean delimiter_required,

diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c

index 962cf8b8f..ef0fd4084 100644

--- a/libnm-core/nm-utils.c

+++ b/libnm-core/nm-utils.c

@@ -3814,16 +3814,46 @@ nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize length)

 	return buffer;

 }

-void

-_nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out)

+/**

+ * _nm_utils_bin2hexstr_full:

+ * @addr: pointer of @length bytes.

+ * @length: number of bytes in @addr

+ * @delimiter: either '\0', otherwise the output string will have the

+ *   given delimiter character between each two hex numbers.

+ * @upper_case: if TRUE, use upper case ASCII characters for hex.

+ * @out: if %NULL, the function will allocate a new buffer of

+ *   either (@length*2+1) or (@length*3) bytes, depending on whether

+ *   a @delimiter is specified. In that case, the allocated buffer will

+ *   be returned and must be freed by the caller.

+ *   If not %NULL, the buffer must already be preallocated and contain

+ *   at least (@length*2+1) or (@length*3) bytes, depending on the delimiter.

+ *

+ * Returns: the binary value converted to a hex string. If @out is given,

+ *   this always returns @out. If @out is %NULL, a newly allocated string

+ *   is returned.

+ */

+char *

+_nm_utils_bin2hexstr_full (gconstpointer addr,

+                           gsize length,

+                           char delimiter,

+                           gboolean upper_case,

+                           char *out)

 {

 	const guint8 *in = addr;

 	const char *LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef";

+	char *out0;

 	nm_assert (addr);

-	nm_assert (out);

 	nm_assert (length > 0);

+	if (out)

+		out0 = out;

+	else {

+		out0 = out = g_new (char, delimiter == '\0'

+		                          ? length * 2 + 1

+		                          : length * 3);

+	}

+

 	/* @out must contain at least @length*3 bytes if @delimiter is set,

 	 * otherwise, @length*2+1. */

@@ -3840,6 +3870,7 @@ _nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimite

 	}

 	*out = 0;

+	return out0;

 }

 /**

@@ -3865,6 +3896,7 @@ nm_utils_bin2hexstr (gconstpointer src, gsize len, int final_len)

 	g_return_val_if_fail (final_len < 0 || (gsize) final_len < buflen, NULL);

 	result = g_malloc (buflen);

+

 	_nm_utils_bin2hexstr_full (src, len, '\0', FALSE, result);

 	/* Cut converted key off at the correct length for this cipher type */

@@ -3886,14 +3918,10 @@ nm_utils_bin2hexstr (gconstpointer src, gsize len, int final_len)

 char *

 nm_utils_hwaddr_ntoa (gconstpointer addr, gsize length)

 {

-	char *result;

-

 	g_return_val_if_fail (addr, g_strdup (""));

 	g_return_val_if_fail (length > 0, g_strdup (""));

-	result = g_malloc (length * 3);

-	_nm_utils_bin2hexstr_full (addr, length, ':', TRUE, result);

-	return result;

+	return _nm_utils_bin2hexstr_full (addr, length, ':', TRUE, NULL);

 }

 const char *

@@ -3905,8 +3933,7 @@ nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_cas

 	if (buf_len < addr_len * 3)

 		g_return_val_if_reached (NULL);

-	_nm_utils_bin2hexstr_full (addr, addr_len, ':', upper_case, buf);

-	return buf;

+	return _nm_utils_bin2hexstr_full (addr, addr_len, ':', upper_case, buf);

 }

 /**

@@ -3922,14 +3949,10 @@ nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_cas

 char *

 _nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case)

 {

-	char *result;

-

 	g_return_val_if_fail (addr, g_strdup (""));

 	g_return_val_if_fail (length > 0, g_strdup (""));

-	result = g_malloc (length * 3);

-	_nm_utils_bin2hexstr_full (addr, length, ':', upper_case, result);

-	return result;

+	return _nm_utils_bin2hexstr_full (addr, length, ':', upper_case, NULL);

 }

 /**

-- 

2.19.1

From 10792c768f1074f4803cba9840d2662793d69c38 Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Thu, 27 Sep 2018 16:05:29 +0200

Subject: [PATCH 3/7] all: drop _nm_utils_bin2hexstr()

We already have nm_utils_bin2hexstr() and _nm_utils_bin2hexstr_full().

This is confusing.

  - nm_utils_bin2hexstr() is public API of libnm. Also, it has

    a last argument @final_len to truncate the string at that

    length.

    It uses no delimiter and lower-case characters.

  - _nm_utils_bin2hexstr_full() does not do any truncation, but

    it has options to specify a delimiter, the character case,

    and to update a given buffer in-place. Also, like

    nm_utils_bin2hexstr() and _nm_utils_bin2hexstr() it can

    allocate a new buffer on demand.

  - _nm_utils_bin2hexstr() would use ':' as delimiter and make

    the case configurable. Also, it would always allocate the returned

    buffer.

It's too much and confusing. Drop _nm_utils_bin2hexstr() which is internal

API and just a wrapper around _nm_utils_bin2hexstr_full().

(cherry picked from commit b537c0388a0ca7320d01c9ba2c6b5b4fe45f267f)

(cherry picked from commit 2a8bef4454d6b1e8aeded8bbd2122538a5da41a4)

---

 libnm-core/nm-core-internal.h |  1 -

 libnm-core/nm-utils.c         | 19 -------------------

 src/devices/nm-device.c       | 16 ++++++++++------

 src/dhcp/nm-dhcp-utils.c      |  4 ++--

 4 files changed, 12 insertions(+), 28 deletions(-)

diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h

index c3be9acef..9edd332d5 100644

--- a/libnm-core/nm-core-internal.h

+++ b/libnm-core/nm-core-internal.h

@@ -212,7 +212,6 @@ guint nm_setting_ethtool_init_features (NMSettingEthtool *setting,

 guint8 *_nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize buffer_length, gsize *out_length);

 const char *nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_case, char *buf, gsize buf_len);

-char *_nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case);

 char *_nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

 guint8 *_nm_utils_hexstr2bin_full (const char *asc,

diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c

index ef0fd4084..457189698 100644

--- a/libnm-core/nm-utils.c

+++ b/libnm-core/nm-utils.c

@@ -3936,25 +3936,6 @@ nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_cas

 	return _nm_utils_bin2hexstr_full (addr, addr_len, ':', upper_case, buf);

 }

-/**

- * _nm_utils_bin2hexstr:

- * @addr: (type guint8) (array length=length): a binary hardware address

- * @length: the length of @addr

- * @upper_case: the case for the hexadecimal digits.

- *

- * Converts @addr to textual form.

- *

- * Return value: (transfer full): the textual form of @addr

- */

-char *

-_nm_utils_bin2hexstr (gconstpointer addr, gsize length, gboolean upper_case)

-{

-	g_return_val_if_fail (addr, g_strdup (""));

-	g_return_val_if_fail (length > 0, g_strdup (""));

-

-	return _nm_utils_bin2hexstr_full (addr, length, ':', upper_case, NULL);

-}

-

 /**

  * nm_utils_hwaddr_valid:

  * @asc: the ASCII representation of a hardware address

diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c

index 2de575cff..c6d591db8 100644

--- a/src/devices/nm-device.c

+++ b/src/devices/nm-device.c

@@ -14349,9 +14349,11 @@ nm_device_spawn_iface_helper (NMDevice *self)

 			if (client_id) {

 				g_ptr_array_add (argv, g_strdup ("--dhcp4-clientid"));

 				g_ptr_array_add (argv,

-				                 _nm_utils_bin2hexstr (g_bytes_get_data (client_id, NULL),

-				                                       g_bytes_get_size (client_id),

-				                                       FALSE));

+				                 _nm_utils_bin2hexstr_full (g_bytes_get_data (client_id, NULL),

+				                                            g_bytes_get_size (client_id),

+				                                            ':',

+				                                            FALSE,

+				                                            NULL));

 			}

 			hostname = nm_dhcp_client_get_hostname (priv->dhcp4.client);

@@ -14389,9 +14391,11 @@ nm_device_spawn_iface_helper (NMDevice *self)

 		if (nm_device_get_ip_iface_identifier (self, &iid, FALSE)) {

 			g_ptr_array_add (argv, g_strdup ("--iid"));

 			g_ptr_array_add (argv,

-			                 _nm_utils_bin2hexstr (iid.id_u8,

-			                                       sizeof (NMUtilsIPv6IfaceId),

-			                                       FALSE));

+			                 _nm_utils_bin2hexstr_full (iid.id_u8,

+			                                            sizeof (NMUtilsIPv6IfaceId),

+			                                            ':',

+			                                            FALSE,

+			                                            NULL));

 		}

 		g_ptr_array_add (argv, g_strdup ("--addr-gen-mode"));

diff --git a/src/dhcp/nm-dhcp-utils.c b/src/dhcp/nm-dhcp-utils.c

index f6d97b5ff..9b1653b8f 100644

--- a/src/dhcp/nm-dhcp-utils.c

+++ b/src/dhcp/nm-dhcp-utils.c

@@ -726,10 +726,10 @@ nm_dhcp_utils_duid_to_string (GBytes *duid)

 	gconstpointer data;

 	gsize len;

-	g_return_val_if_fail (duid != NULL, NULL);

+	g_return_val_if_fail (duid, NULL);

 	data = g_bytes_get_data (duid, &len;;

-	return _nm_utils_bin2hexstr (data, len, FALSE);

+	return _nm_utils_bin2hexstr_full (data, len, ':', FALSE, NULL);

 }

 /**

-- 

2.19.1

From 7135449107363ab356db4d4e2afc45bab4952978 Mon Sep 17 00:00:00 2001

From: Thomas Haller <thaller@redhat.com>

Date: Thu, 27 Sep 2018 16:29:55 +0200

Subject: [PATCH 4/7] libnm: cleanup _nm_utils_hexstr2bin*() helper

Add 3 variants of _nm_utils_hexstr2bin*():

  - _nm_utils_hexstr2bin_full(), which takes a preallocated

    buffer and fills it.

  - _nm_utils_hexstr2bin_alloc() which returns a malloc'ed

    buffer

  - _nm_utils_hexstr2bin_buf(), which fills a preallocated

    buffer of a specific size.

(cherry picked from commit be6c7fa5f66c0fa155d703996a5a858c88b8230c)

(cherry picked from commit 5dc8a14576d2ea9732518586027df6b0c3c8784f)

---

 libnm-core/nm-core-internal.h                 |  16 ++-

 libnm-core/nm-utils.c                         | 123 +++++++++++++-----

 .../plugins/ifcfg-rh/nms-ifcfg-rh-reader.c    |   2 +-

 3 files changed, 105 insertions(+), 36 deletions(-)

diff --git a/libnm-core/nm-core-internal.h b/libnm-core/nm-core-internal.h

index 9edd332d5..761461084 100644

--- a/libnm-core/nm-core-internal.h

+++ b/libnm-core/nm-core-internal.h

@@ -214,13 +214,25 @@ const char *nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboole

 char *_nm_utils_bin2hexstr_full (gconstpointer addr, gsize length, const char delimiter, gboolean upper_case, char *out);

-guint8 *_nm_utils_hexstr2bin_full (const char *asc,

+guint8 *_nm_utils_hexstr2bin_full (const char *hexstr,

+                                   gboolean allow_0x_prefix,

                                    gboolean delimiter_required,

                                    const char *delimiter_candidates,

+                                   gsize required_len,

                                    guint8 *buffer,

-                                   gsize buffer_length,

+                                   gsize buffer_len,

                                    gsize *out_len);

+#define _nm_utils_hexstr2bin_buf(hexstr, allow_0x_prefix, delimiter_required, delimiter_candidates, buffer) \

+    _nm_utils_hexstr2bin_full ((hexstr), (allow_0x_prefix), (delimiter_required), (delimiter_candidates), G_N_ELEMENTS (buffer), (buffer), G_N_ELEMENTS (buffer), NULL)

+

+guint8 *_nm_utils_hexstr2bin_alloc (const char *hexstr,

+                                    gboolean allow_0x_prefix,

+                                    gboolean delimiter_required,

+                                    const char *delimiter_candidates,

+                                    gsize required_len,

+                                    gsize *out_len);

+

 GSList *    _nm_utils_hash_values_to_slist (GHashTable *hash);

 GHashTable *_nm_utils_copy_strdict (GHashTable *strdict);

diff --git a/libnm-core/nm-utils.c b/libnm-core/nm-utils.c

index 457189698..59b7f0432 100644

--- a/libnm-core/nm-utils.c

+++ b/libnm-core/nm-utils.c

@@ -3613,60 +3613,68 @@ nm_utils_hwaddr_len (int type)

 }

 guint8 *

-_nm_utils_hexstr2bin_full (const char *asc,

+_nm_utils_hexstr2bin_full (const char *hexstr,

+                           gboolean allow_0x_prefix,

                            gboolean delimiter_required,

                            const char *delimiter_candidates,

+                           gsize required_len,

                            guint8 *buffer,

-                           gsize buffer_length,

+                           gsize buffer_len,

                            gsize *out_len)

 {

-	const char *in = asc;

+	const char *in = hexstr;

 	guint8 *out = buffer;

 	gboolean delimiter_has = TRUE;

 	guint8 delimiter = '\0';

+	gsize len;

-	nm_assert (asc);

+	nm_assert (hexstr);

 	nm_assert (buffer);

-	nm_assert (buffer_length);

-	nm_assert (out_len);

+	nm_assert (required_len > 0 || out_len);

+

+	if (   allow_0x_prefix

+	    && in[0] == '0'

+	    && in[1] == 'x')

+		in += 2;

 	while (TRUE) {

 		const guint8 d1 = in[0];

 		guint8 d2;

+		int i1, i2;

-		if (!g_ascii_isxdigit (d1))

-			return NULL;

-

-#define HEXVAL(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - ('A' - 10))

+		i1 = nm_utils_hexchar_to_int (d1);

+		if (i1 < 0)

+			goto fail;

 		/* If there's no leading zero (ie "aa:b:cc") then fake it */

 		d2 = in[1];

-		if (d2 && g_ascii_isxdigit (d2)) {

-			*out++ = (HEXVAL (d1) << 4) + HEXVAL (d2);

+		if (   d2

+		    && (i2 = nm_utils_hexchar_to_int (d2)) >= 0) {

+			*out++ = (i1 << 4) + i2;

 			d2 = in[2];

 			if (!d2)

 				break;

 			in += 2;

 		} else {

 			/* Fake leading zero */

-			*out++ = HEXVAL (d1);

+			*out++ = i1;

 			if (!d2) {

 				if (!delimiter_has) {

 					/* when using no delimiter, there must be pairs of hex chars */

-					return NULL;

+					goto fail;

 				}

 				break;

 			}

 			in += 1;

 		}

-		if (--buffer_length == 0)

-			return NULL;

+		if (--buffer_len == 0)

+			goto fail;

 		if (delimiter_has) {

 			if (d2 != delimiter) {

 				if (delimiter)

-					return NULL;

+					goto fail;

 				if (delimiter_candidates) {

 					while (delimiter_candidates[0]) {

 						if (delimiter_candidates++[0] == d2)

@@ -3675,7 +3683,7 @@ _nm_utils_hexstr2bin_full (const char *asc,

 				}

 				if (!delimiter) {

 					if (delimiter_required)

-						return NULL;

+						goto fail;

 					delimiter_has = FALSE;

 					continue;

 				}

@@ -3684,11 +3692,66 @@ _nm_utils_hexstr2bin_full (const char *asc,

 		}

 	}

-	*out_len = out - buffer;

-	return buffer;

+	len = out - buffer;

+	if (   required_len == 0

+	    || len == required_len) {

+		NM_SET_OUT (out_len, len);

+		return buffer;

+	}

+

+fail:

+	NM_SET_OUT (out_len, 0);

+	return NULL;

 }

-#define hwaddr_aton(asc, buffer, buffer_length, out_len) _nm_utils_hexstr2bin_full ((asc), TRUE, ":-", (buffer), (buffer_length), (out_len))

+guint8 *

+_nm_utils_hexstr2bin_alloc (const char *hexstr,

+                            gboolean allow_0x_prefix,

+                            gboolean delimiter_required,

+                            const char *delimiter_candidates,

+                            gsize required_len,

+                            gsize *out_len)

+{

+	guint8 *buffer;

+	gsize buffer_len, len;

+

+	g_return_val_if_fail (hexstr, NULL);

+

+	nm_assert (required_len > 0 || out_len);

+

+	if (   allow_0x_prefix

+	    && hexstr[0] == '0'

+	    && hexstr[1] == 'x')

+		hexstr += 2;

+

+	if (!hexstr[0])

+		goto fail;

+

+	if (required_len > 0)

+		buffer_len = required_len;

+	else

+		buffer_len = strlen (hexstr) / 2 + 3;

+

+	buffer = g_malloc (buffer_len);

+

+	if (_nm_utils_hexstr2bin_full (hexstr,

+	                               FALSE,

+	                               delimiter_required,

+	                               delimiter_candidates,

+	                               required_len,

+	                               buffer,

+	                               buffer_len,

+	                               &len)) {

+		NM_SET_OUT (out_len, len);

+		return buffer;

+	}