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