// SPDX-License-Identifier: LGPL-2.1+
/*
* Copyright (C) 2017 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-enum-utils.h"
#include "nm-str-buf.h"
/*****************************************************************************/
#define IS_FLAGS_SEPARATOR(ch) (NM_IN_SET ((ch), ' ', '\t', ',', '\n', '\r'))
static void
_ASSERT_enum_values_info (GType type,
const NMUtilsEnumValueInfo *value_infos)
{
#if NM_MORE_ASSERTS > 5
nm_auto_unref_gtypeclass GTypeClass *klass = NULL;
gs_unref_hashtable GHashTable *ht = NULL;
klass = g_type_class_ref (type);
g_assert (G_IS_ENUM_CLASS (klass) || G_IS_FLAGS_CLASS (klass));
if (!value_infos)
return;
ht = g_hash_table_new (g_str_hash, g_str_equal);
for (; value_infos->nick; value_infos++) {
g_assert (value_infos->nick[0]);
/* duplicate nicks make no sense!! */
g_assert (!g_hash_table_contains (ht, value_infos->nick));
g_hash_table_add (ht, (gpointer) value_infos->nick);
if (G_IS_ENUM_CLASS (klass)) {
GEnumValue *enum_value;
enum_value = g_enum_get_value_by_nick (G_ENUM_CLASS (klass), value_infos->nick);
if (enum_value) {
/* we do allow specifying the same name via @value_infos and @type.
* That might make sense, if @type comes from a library where older versions
* of the library don't yet support the value. In this case, the caller can
* provide the nick via @value_infos, to support the older library version.
* And then, when actually running against a newer library version where
* @type knows the nick, we have this situation.
*
* Another reason for specifying a nick both in @value_infos and @type,
* is to specify an alias which is not used with highest preference. For
* example, if you add an alias "disabled" for "none" (both numerically
* equal), then the first alias in @value_infos will be preferred over
* the name from @type. So, to still use "none" as preferred name, you may
* explicitly specify the "none" alias in @value_infos before "disabled".
*
* However, what never is allowed, is to use a name (nick) to re-number
* the value. That is, if both @value_infos and @type contain a particular
* nick, their numeric values must agree as well.
* Allowing this, would be very confusing, because the name would have a different
* value from the regular GLib GEnum API.
*/
g_assert (enum_value->value == value_infos->value);
}
} else {
GFlagsValue *flags_value;
flags_value = g_flags_get_value_by_nick (G_FLAGS_CLASS (klass), value_infos->nick);
if (flags_value) {
/* see ENUM case above. */
g_assert (flags_value->value == (guint) value_infos->value);
}
}
}
#endif
}
static gboolean
_is_hex_string (const char *str)
{
return str[0] == '0'
&& str[1] == 'x'
&& str[2]
&& NM_STRCHAR_ALL (&str[2], ch, g_ascii_isxdigit (ch));
}
static gboolean
_is_dec_string (const char *str)
{
return str[0]
&& NM_STRCHAR_ALL (&str[0], ch, g_ascii_isdigit (ch));
}
static gboolean
_enum_is_valid_enum_nick (const char *str)
{
return str[0]
&& !NM_STRCHAR_ANY (str, ch, g_ascii_isspace (ch))
&& !_is_dec_string (str)
&& !_is_hex_string (str);
}
static gboolean
_enum_is_valid_flags_nick (const char *str)
{
return str[0]
&& !NM_STRCHAR_ANY (str, ch, IS_FLAGS_SEPARATOR (ch))
&& !_is_dec_string (str)
&& !_is_hex_string (str);
}
char *
_nm_utils_enum_to_str_full (GType type,
int value,
const char *flags_separator,
const NMUtilsEnumValueInfo *value_infos)
{
nm_auto_unref_gtypeclass GTypeClass *klass = NULL;
_ASSERT_enum_values_info (type, value_infos);
if ( flags_separator
&& ( !flags_separator[0]
|| NM_STRCHAR_ANY (flags_separator, ch, !IS_FLAGS_SEPARATOR (ch))))
g_return_val_if_reached (NULL);
klass = g_type_class_ref (type);
if (G_IS_ENUM_CLASS (klass)) {
GEnumValue *enum_value;
for ( ; value_infos && value_infos->nick; value_infos++) {
if (value_infos->value == value)
return g_strdup (value_infos->nick);
}
enum_value = g_enum_get_value (G_ENUM_CLASS (klass), value);
if ( !enum_value
|| !_enum_is_valid_enum_nick (enum_value->value_nick))
return g_strdup_printf ("%d", value);
else
return g_strdup (enum_value->value_nick);
} else if (G_IS_FLAGS_CLASS (klass)) {
unsigned uvalue = (unsigned) value;
GFlagsValue *flags_value;
NMStrBuf strbuf;
flags_separator = flags_separator ?: " ";
nm_str_buf_init (&strbuf, 16, FALSE);
for ( ; value_infos && value_infos->nick; value_infos++) {
nm_assert (_enum_is_valid_flags_nick (value_infos->nick));
if (uvalue == 0) {
if (value_infos->value != 0)
continue;
} else {
if (!NM_FLAGS_ALL (uvalue, (unsigned) value_infos->value))
continue;
}
if (strbuf.len)
nm_str_buf_append (&strbuf, flags_separator);
nm_str_buf_append (&strbuf, value_infos->nick);
uvalue &= ~((unsigned) value_infos->value);
if (uvalue == 0) {
/* we printed all flags. Done. */
goto flags_done;
}
}
do {
flags_value = g_flags_get_first_value (G_FLAGS_CLASS (klass), uvalue);
if (strbuf.len)
nm_str_buf_append (&strbuf, flags_separator);
if ( !flags_value
|| !_enum_is_valid_flags_nick (flags_value->value_nick)) {
if (uvalue)
nm_str_buf_append_printf (&strbuf, "0x%x", uvalue);
break;
}
nm_str_buf_append (&strbuf, flags_value->value_nick);
uvalue &= ~flags_value->value;
} while (uvalue);
flags_done:
return nm_str_buf_finalize (&strbuf, NULL);
}
g_return_val_if_reached (NULL);
}
static const NMUtilsEnumValueInfo *
_find_value_info (const NMUtilsEnumValueInfo *value_infos, const char *needle)
{
if (value_infos) {
for (; value_infos->nick; value_infos++) {
if (nm_streq (needle, value_infos->nick))
return value_infos;
}
}
return NULL;
}
gboolean
_nm_utils_enum_from_str_full (GType type,
const char *str,
int *out_value,
char **err_token,
const NMUtilsEnumValueInfo *value_infos)
{
nm_auto_unref_gtypeclass GTypeClass *klass = NULL;
gboolean ret = FALSE;
int value = 0;
gs_free char *str_clone = NULL;
char *s;
gint64 v64;
const NMUtilsEnumValueInfo *nick;
g_return_val_if_fail (str, FALSE);
_ASSERT_enum_values_info (type, value_infos);
str_clone = strdup (str);
s = nm_str_skip_leading_spaces (str_clone);
g_strchomp (s);
klass = g_type_class_ref (type);
if (G_IS_ENUM_CLASS (klass)) {
GEnumValue *enum_value;
if (s[0]) {
if (_is_hex_string (s)) {
v64 = _nm_utils_ascii_str_to_int64 (s, 16, 0, G_MAXUINT, -1);
if (v64 != -1) {
value = (int) v64;
ret = TRUE;
}
} else if (_is_dec_string (s)) {
v64 = _nm_utils_ascii_str_to_int64 (s, 10, 0, G_MAXUINT, -1);
if (v64 != -1) {
value = (int) v64;
ret = TRUE;
}
} else if ((nick = _find_value_info (value_infos, s))) {
value = nick->value;
ret = TRUE;
} else if ((enum_value = g_enum_get_value_by_nick (G_ENUM_CLASS (klass), s))) {
value = enum_value->value;
ret = TRUE;
}
}
} else if (G_IS_FLAGS_CLASS (klass)) {
GFlagsValue *flags_value;
unsigned uvalue = 0;
ret = TRUE;
while (s[0]) {
char *s_end;
for (s_end = s; s_end[0]; s_end++) {
if (IS_FLAGS_SEPARATOR (s_end[0])) {
s_end[0] = '\0';
s_end++;
break;
}
}
if (s[0]) {
if (_is_hex_string (s)) {
v64 = _nm_utils_ascii_str_to_int64 (&s[2], 16, 0, G_MAXUINT, -1);
if (v64 == -1) {
ret = FALSE;
break;
}
uvalue |= (unsigned) v64;
} else if (_is_dec_string (s)) {
v64 = _nm_utils_ascii_str_to_int64 (s, 10, 0, G_MAXUINT, -1);
if (v64 == -1) {
ret = FALSE;
break;
}
uvalue |= (unsigned) v64;
} else if ((nick = _find_value_info (value_infos, s)))
uvalue |= (unsigned) nick->value;
else if ((flags_value = g_flags_get_value_by_nick (G_FLAGS_CLASS (klass), s)))
uvalue |= flags_value->value;
else {
ret = FALSE;
break;
}
}
s = s_end;
}
value = (int) uvalue;
} else
g_return_val_if_reached (FALSE);
NM_SET_OUT (err_token, !ret && s[0] ? g_strdup (s) : NULL);
NM_SET_OUT (out_value, ret ? value : 0);
return ret;
}
const char **
_nm_utils_enum_get_values (GType type, int from, int to)
{
GTypeClass *klass;
GPtrArray *array;
int i;
char sbuf[64];
klass = g_type_class_ref (type);
array = g_ptr_array_new ();
if (G_IS_ENUM_CLASS (klass)) {
GEnumClass *enum_class = G_ENUM_CLASS (klass);
GEnumValue *enum_value;
for (i = 0; i < enum_class->n_values; i++) {
enum_value = &enum_class->values[i];
if (enum_value->value >= from && enum_value->value <= to) {
if (_enum_is_valid_enum_nick (enum_value->value_nick))
g_ptr_array_add (array, (gpointer) enum_value->value_nick);
else
g_ptr_array_add (array, (gpointer) g_intern_string (nm_sprintf_buf (sbuf, "%d", enum_value->value)));
}
}
} else if (G_IS_FLAGS_CLASS (klass)) {
GFlagsClass *flags_class = G_FLAGS_CLASS (klass);
GFlagsValue *flags_value;
for (i = 0; i < flags_class->n_values; i++) {
flags_value = &flags_class->values[i];
if (flags_value->value >= (guint) from && flags_value->value <= (guint) to) {
if (_enum_is_valid_flags_nick (flags_value->value_nick))
g_ptr_array_add (array, (gpointer) flags_value->value_nick);
else
g_ptr_array_add (array, (gpointer) g_intern_string (nm_sprintf_buf (sbuf, "0x%x", (unsigned) flags_value->value)));
}
}
} else {
g_type_class_unref (klass);
g_ptr_array_free (array, TRUE);
g_return_val_if_reached (NULL);
}
g_type_class_unref (klass);
g_ptr_array_add (array, NULL);
return (const char **) g_ptr_array_free (array, FALSE);
}