1 files changed, 195 insertions, 0 deletions
diff --git a/shared/nm-glib-aux/nm-ref-string.c b/shared/nm-glib-aux/nm-ref-string.c
new file mode 100644
index 00000000..0a0b0d3a
--- /dev/null
+++ b/shared/nm-glib-aux/nm-ref-string.c
@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: LGPL-2.1+
+
+#include "nm-default.h"
+
+#include "nm-ref-string.h"
+
+/*****************************************************************************/
+
+typedef struct {
+	NMRefString r;
+	volatile int ref_count;
+	char str_data[];
+} RefString;
+
+G_LOCK_DEFINE_STATIC (gl_lock);
+static GHashTable *gl_hash;
+
+/* the first field of NMRefString is a pointer to the NUL terminated string.
+ * This also allows to compare strings with nm_pstr_equal(), although, pointer
+ * equality might be better. */
+G_STATIC_ASSERT (G_STRUCT_OFFSET (NMRefString, str) == 0);
+G_STATIC_ASSERT (G_STRUCT_OFFSET (RefString, r) == 0);
+G_STATIC_ASSERT (G_STRUCT_OFFSET (RefString, r.str) == 0);
+
+/*****************************************************************************/
+
+static guint
+_ref_string_hash (gconstpointer ptr)
+{
+	const RefString *a = ptr;
+	NMHashState h;
+
+	nm_hash_init (&h, 1463435489u);
+	nm_hash_update (&h, a->r.str, a->r.len);
+	return nm_hash_complete (&h);
+}
+
+static gboolean
+_ref_string_equal (gconstpointer pa, gconstpointer pb)
+{
+	const RefString *a = pa;
+	const RefString *b = pb;
+
+	return    a->r.len == b->r.len
+	       && memcmp (a->r.str, b->r.str, a->r.len) == 0;
+}
+
+/*****************************************************************************/
+
+static void
+_ASSERT (const RefString *rstr0)
+{
+#if NM_MORE_ASSERTS
+	int r;
+
+	nm_assert (rstr0);
+
+	G_LOCK (gl_lock);
+	r = g_atomic_int_get (&rstr0->ref_count);
+
+	nm_assert (r > 0);
+	nm_assert (r < G_MAXINT);
+
+	nm_assert (rstr0 == g_hash_table_lookup (gl_hash, rstr0));
+	G_UNLOCK (gl_lock);
+#endif
+}
+
+/**
+ * nm_ref_string_new_len:
+ * @cstr: the string to intern. Must contain @len bytes.
+ *   If @len is zero, @cstr may be %NULL. Note that it is
+ *   accetable that the string contains a NUL character
+ *   within the first @len bytes. That is, the string is
+ *   not treated as a NUL terminated string, but as binary.
+ *   Also, contrary to strncpy(), this will read all the
+ *   first @len bytes. It won't stop at the first NUL.
+ * @len: the length of the string (usually there is no NUL character
+ *   within the first @len bytes, but that would be acceptable as well
+ *   to add binary data).
+ *
+ * Note that the resulting NMRefString instance will always be NUL terminated
+ * (at position @len).
+ *
+ * Note that NMRefString are always interned/deduplicated. If such a string
+ * already exists, the existing instance will be refered and returned.
+ *
+ *
+ * Since all NMRefString are shared and interned, you may use
+ * pointer equality to compare them. Note that if a NMRefString contains
+ * a NUL character (meaning, if
+ *
+ *    strlen (nm_ref_string_get_str (str)) != nm_ref_string_get_len (str)
+ *
+ * ), then pointer in-equality does not mean that the NUL terminated strings
+ * are also unequal. In other words, for strings that contain NUL characters,
+ *
+ *    if (str1 != str2)
+ *       assert (!nm_streq0 (nm_ref_string_get_str (str1), nm_ref_string_get_str (str2)));
+ *
+ * might not hold!
+ *
+ *
+ * NMRefString is thread-safe.
+ *
+ * Returns: (transfer full): the interned string. This is
+ *   never %NULL, but note that %NULL is also a valid NMRefString.
+ *   The result must be unrefed with nm_ref_string_unref().
+ */
+NMRefString *
+nm_ref_string_new_len (const char *cstr, gsize len)
+{
+	RefString *rstr0;
+
+	G_LOCK (gl_lock);
+
+	if (G_UNLIKELY (!gl_hash)) {
+		gl_hash = g_hash_table_new_full (_ref_string_hash, _ref_string_equal, g_free, NULL);
+		rstr0 = NULL;
+	} else {
+		NMRefString rr_lookup = {
+			.len = len,
+			.str = cstr,
+		};
+
+		rstr0 = g_hash_table_lookup (gl_hash, &rr_lookup);
+	}
+
+	if (rstr0) {
+		nm_assert (({
+		               int r = g_atomic_int_get (&rstr0->ref_count);
+
+		               (r >= 0 && r < G_MAXINT);
+		            }));
+		g_atomic_int_inc (&rstr0->ref_count);
+	} else {
+		rstr0 = g_malloc (sizeof (RefString) + 1 + len);
+		rstr0->ref_count = 1;
+		*((gsize *) &rstr0->r.len) = len;
+		*((const char **) &rstr0->r.str) = rstr0->str_data;
+		if (len > 0)
+			memcpy (rstr0->str_data, cstr, len);
+		rstr0->str_data[len] = '\0';
+
+		if (!g_hash_table_add (gl_hash, rstr0))
+			nm_assert_not_reached ();
+	}
+
+	G_UNLOCK (gl_lock);
+
+	return &rstr0->r;
+}
+
+NMRefString *
+nm_ref_string_ref (NMRefString *rstr)
+{
+	RefString *const rstr0 = (RefString *) rstr;
+
+	if (!rstr)
+		return NULL;
+
+	_ASSERT (rstr0);
+
+	g_atomic_int_inc (&rstr0->ref_count);
+	return &rstr0->r;
+}
+
+void
+_nm_ref_string_unref_non_null (NMRefString *rstr)
+{
+	RefString *const rstr0 = (RefString *) rstr;
+
+	_ASSERT (rstr0);
+
+	if (G_LIKELY (!g_atomic_int_dec_and_test (&rstr0->ref_count)))
+		return;
+
+	G_LOCK (gl_lock);
+
+	/* in the fast-path above, we already decremented the ref-count to zero.
+	 * We need recheck that the ref-count is still zero. */
+
+	if (g_atomic_int_get (&rstr0->ref_count) == 0) {
+		if (!g_hash_table_remove (gl_hash, rstr0))
+			nm_assert_not_reached ();
+	} else {
+#if NM_MORE_ASSERTS > 5
+		nm_assert (g_hash_table_lookup (gl_hash, rstr0) == rstr0);
+#endif
+	}
+
+	G_UNLOCK (gl_lock);
+}
+
+/*****************************************************************************/