NetworkManager/shared/nm-glib-aux/nm-ref-string.c

// 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);
}

/*****************************************************************************/