mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2026-05-17 15:48:10 +02:00
322 lines
9.6 KiB
C
322 lines
9.6 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2017 - 2019 Red Hat, Inc.
|
|
*/
|
|
|
|
#ifndef __NM_JSON_AUX_H__
|
|
#define __NM_JSON_AUX_H__
|
|
|
|
#include "nm-value-type.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
static inline GString *
|
|
nm_json_gstr_append_delimiter (GString *gstr)
|
|
{
|
|
g_string_append (gstr, ", ");
|
|
return gstr;
|
|
}
|
|
|
|
void nm_json_gstr_append_string_len (GString *gstr,
|
|
const char *str,
|
|
gsize n);
|
|
|
|
void nm_json_gstr_append_string (GString *gstr,
|
|
const char *str);
|
|
|
|
static inline void
|
|
nm_json_gstr_append_bool (GString *gstr,
|
|
gboolean v)
|
|
{
|
|
g_string_append (gstr, v ? "true" : "false");
|
|
}
|
|
|
|
static inline void
|
|
nm_json_gstr_append_int64 (GString *gstr,
|
|
gint64 v)
|
|
{
|
|
g_string_append_printf (gstr, "%"G_GINT64_FORMAT, v);
|
|
}
|
|
|
|
void nm_json_gstr_append_obj_name (GString *gstr,
|
|
const char *key,
|
|
char start_container);
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define NM_JSON_REJECT_DUPLICATES 0x1
|
|
|
|
typedef enum {
|
|
NM_JSON_OBJECT,
|
|
NM_JSON_ARRAY,
|
|
NM_JSON_STRING,
|
|
NM_JSON_INTEGER,
|
|
NM_JSON_REAL,
|
|
NM_JSON_TRUE,
|
|
NM_JSON_FALSE,
|
|
NM_JSON_NULL,
|
|
} nm_json_type;
|
|
|
|
typedef struct nm_json_t {
|
|
nm_json_type type;
|
|
volatile size_t refcount;
|
|
} nm_json_t;
|
|
|
|
typedef long long nm_json_int_t;
|
|
|
|
#define NM_JSON_ERROR_TEXT_LENGTH 160
|
|
#define NM_JSON_ERROR_SOURCE_LENGTH 80
|
|
|
|
typedef struct nm_json_error_t {
|
|
int line;
|
|
int column;
|
|
int position;
|
|
char source[NM_JSON_ERROR_SOURCE_LENGTH];
|
|
char text[NM_JSON_ERROR_TEXT_LENGTH];
|
|
} nm_json_error_t;
|
|
|
|
typedef struct {
|
|
gboolean loaded;
|
|
char *(*nm_json_dumps) (const nm_json_t *json, size_t flags);
|
|
const char *(*nm_json_object_iter_key) (void *iter);
|
|
const char *(*nm_json_string_value) (const nm_json_t *json);
|
|
int (*nm_json_array_append_new) (nm_json_t *json, nm_json_t *value);
|
|
int (*nm_json_object_del) (nm_json_t *json, const char *key);
|
|
int (*nm_json_object_set_new) (nm_json_t *json, const char *key, nm_json_t *value);
|
|
nm_json_int_t (*nm_json_integer_value) (const nm_json_t *json);
|
|
nm_json_t *(*nm_json_array) (void);
|
|
nm_json_t *(*nm_json_array_get) (const nm_json_t *json, size_t index);
|
|
nm_json_t *(*nm_json_false) (void);
|
|
nm_json_t *(*nm_json_integer) (nm_json_int_t value);
|
|
nm_json_t *(*nm_json_loads) (const char *string, size_t flags, nm_json_error_t *error);
|
|
nm_json_t *(*nm_json_object) (void);
|
|
nm_json_t *(*nm_json_object_get) (const nm_json_t *json, const char *key);
|
|
nm_json_t *(*nm_json_object_iter_value) (void *);
|
|
nm_json_t *(*nm_json_string) (const char *value);
|
|
nm_json_t *(*nm_json_true) (void);
|
|
size_t (*nm_json_array_size) (const nm_json_t *json);
|
|
size_t (*nm_json_object_size) (const nm_json_t *json);
|
|
void (*nm_json_delete) (nm_json_t *json);
|
|
void *(*nm_json_object_iter) (nm_json_t *json);
|
|
void *(*nm_json_object_iter_next) (nm_json_t *json, void *iter);
|
|
void *(*nm_json_object_key_to_iter) (const char *key);
|
|
} NMJsonVt;
|
|
|
|
extern const NMJsonVt *_nm_json_vt_ptr;
|
|
|
|
const NMJsonVt *_nm_json_vt_init (void);
|
|
|
|
static inline const NMJsonVt *
|
|
_nm_json_vt (void)
|
|
{
|
|
const NMJsonVt *vt;
|
|
|
|
vt = g_atomic_pointer_get ((gpointer *) &_nm_json_vt_ptr);
|
|
if (G_UNLIKELY (!vt)) {
|
|
vt = _nm_json_vt_init ();
|
|
nm_assert (vt);
|
|
}
|
|
return vt;
|
|
}
|
|
|
|
static inline const NMJsonVt *
|
|
nm_json_vt (void)
|
|
{
|
|
const NMJsonVt *vt;
|
|
|
|
vt = _nm_json_vt();
|
|
return vt->loaded ? vt : NULL;
|
|
}
|
|
|
|
static inline const NMJsonVt *
|
|
nm_json_vt_assert (void)
|
|
{
|
|
const NMJsonVt *vt;
|
|
|
|
vt = _nm_json_vt();
|
|
nm_assert (vt->loaded);
|
|
return vt;
|
|
}
|
|
|
|
const NMJsonVt *nmtst_json_vt_reset (gboolean loaded);
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define nm_json_boolean(vt, val) \
|
|
((val) ? (vt)->nm_json_true () : (vt)->nm_json_false ())
|
|
|
|
static inline void
|
|
nm_json_decref (const NMJsonVt *vt, nm_json_t *json)
|
|
{
|
|
/* Our ref-counting is not threadsafe, unlike libjansson's. But we never
|
|
* share one json_t instance between threads, and if we would, we would very likely
|
|
* wrap a mutex around it. */
|
|
if ( json
|
|
&& json->refcount != (size_t) -1
|
|
&& --json->refcount == 0)
|
|
vt->nm_json_delete (json);
|
|
}
|
|
|
|
static inline void
|
|
_nm_auto_decref_json (nm_json_t **p_json)
|
|
{
|
|
if ( *p_json
|
|
&& (*p_json)->refcount != (size_t) -1
|
|
&& --(*p_json)->refcount == 0)
|
|
nm_json_vt ()->nm_json_delete (*p_json);
|
|
}
|
|
|
|
#define nm_auto_decref_json nm_auto(_nm_auto_decref_json)
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* the following are implemented as pure macros in jansson.h.
|
|
* They can be used directly, however, add a nm_json* variant,
|
|
* to make it explict we don't accidentally use jansson ABI. */
|
|
|
|
#define nm_json_typeof(json) ((json)->type)
|
|
#define nm_json_is_object(json) ((json) && nm_json_typeof(json) == NM_JSON_OBJECT)
|
|
#define nm_json_is_array(json) ((json) && nm_json_typeof(json) == NM_JSON_ARRAY)
|
|
#define nm_json_is_string(json) ((json) && nm_json_typeof(json) == NM_JSON_STRING)
|
|
#define nm_json_is_integer(json) ((json) && nm_json_typeof(json) == NM_JSON_INTEGER)
|
|
#define nm_json_is_real(json) ((json) && nm_json_typeof(json) == NM_JSON_REAL)
|
|
#define nm_json_is_number(json) (nm_json_is_integer(json) || nm_json_is_real(json))
|
|
#define nm_json_is_true(json) ((json) && nm_json_typeof(json) == NM_JSON_TRUE)
|
|
#define nm_json_is_false(json) ((json) && nm_json_typeof(json) == NM_JSON_FALSE)
|
|
#define nm_json_boolean_value nm_json_is_true
|
|
#define nm_json_is_boolean(json) (nm_json_is_true(json) || nm_json_is_false(json))
|
|
#define nm_json_is_null(json) ((json) && nm_json_typeof(json) == NM_JSON_NULL)
|
|
|
|
#define nm_json_array_foreach(vt, array, index, value) \
|
|
for(index = 0; \
|
|
index < vt->nm_json_array_size (array) && (value = vt->nm_json_array_get (array, index)); \
|
|
index++)
|
|
|
|
#define nm_json_object_foreach(vt, object, key, value) \
|
|
for(key = vt->nm_json_object_iter_key (vt->nm_json_object_iter (object)); \
|
|
key && (value = vt->nm_json_object_iter_value (vt->nm_json_object_key_to_iter (key))); \
|
|
key = vt->nm_json_object_iter_key (vt->nm_json_object_iter_next (object, vt->nm_json_object_key_to_iter (key))))
|
|
|
|
/*****************************************************************************/
|
|
|
|
static inline int
|
|
nm_jansson_json_as_bool (const nm_json_t *elem,
|
|
bool *out_val)
|
|
{
|
|
if (!elem)
|
|
return 0;
|
|
|
|
if (!nm_json_is_boolean (elem))
|
|
return -EINVAL;
|
|
|
|
NM_SET_OUT (out_val, nm_json_boolean_value (elem));
|
|
return 1;
|
|
}
|
|
|
|
static inline int
|
|
nm_jansson_json_as_int32 (const NMJsonVt *vt,
|
|
const nm_json_t *elem,
|
|
gint32 *out_val)
|
|
{
|
|
nm_json_int_t v;
|
|
|
|
if (!elem)
|
|
return 0;
|
|
|
|
if (!nm_json_is_integer (elem))
|
|
return -EINVAL;
|
|
|
|
v = vt->nm_json_integer_value (elem);
|
|
if ( v < (gint64) G_MININT32
|
|
|| v > (gint64) G_MAXINT32)
|
|
return -ERANGE;
|
|
|
|
NM_SET_OUT (out_val, v);
|
|
return 1;
|
|
}
|
|
|
|
static inline int
|
|
nm_jansson_json_as_int (const NMJsonVt *vt,
|
|
const nm_json_t *elem,
|
|
int *out_val)
|
|
{
|
|
nm_json_int_t v;
|
|
|
|
if (!elem)
|
|
return 0;
|
|
|
|
if (!nm_json_is_integer (elem))
|
|
return -EINVAL;
|
|
|
|
v = vt->nm_json_integer_value (elem);
|
|
if ( v < (gint64) G_MININT
|
|
|| v > (gint64) G_MAXINT)
|
|
return -ERANGE;
|
|
|
|
NM_SET_OUT (out_val, v);
|
|
return 1;
|
|
}
|
|
|
|
static inline int
|
|
nm_jansson_json_as_string (const NMJsonVt *vt,
|
|
const nm_json_t *elem,
|
|
const char **out_val)
|
|
{
|
|
if (!elem)
|
|
return 0;
|
|
|
|
if (!nm_json_is_string (elem))
|
|
return -EINVAL;
|
|
|
|
NM_SET_OUT (out_val, vt->nm_json_string_value (elem));
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
#ifdef NM_VALUE_TYPE_DEFINE_FUNCTIONS
|
|
|
|
static inline void
|
|
nm_value_type_to_json (NMValueType value_type,
|
|
GString *gstr,
|
|
gconstpointer p_field)
|
|
{
|
|
nm_assert (p_field);
|
|
nm_assert (gstr);
|
|
|
|
switch (value_type) {
|
|
case NM_VALUE_TYPE_BOOL: nm_json_gstr_append_bool (gstr, *((const bool *) p_field)); return;
|
|
case NM_VALUE_TYPE_INT32: nm_json_gstr_append_int64 (gstr, *((const gint32 *) p_field)); return;
|
|
case NM_VALUE_TYPE_INT: nm_json_gstr_append_int64 (gstr, *((const int *) p_field)); return;
|
|
case NM_VALUE_TYPE_STRING: nm_json_gstr_append_string (gstr, *((const char *const *) p_field)); return;
|
|
case NM_VALUE_TYPE_UNSPEC:
|
|
break;
|
|
}
|
|
nm_assert_not_reached ();
|
|
}
|
|
|
|
static inline gboolean
|
|
nm_value_type_from_json (const NMJsonVt *vt,
|
|
NMValueType value_type,
|
|
const nm_json_t *elem,
|
|
gpointer out_val)
|
|
{
|
|
switch (value_type) {
|
|
case NM_VALUE_TYPE_BOOL: return (nm_jansson_json_as_bool (elem, out_val) > 0);
|
|
case NM_VALUE_TYPE_INT32: return (nm_jansson_json_as_int32 (vt, elem, out_val) > 0);
|
|
case NM_VALUE_TYPE_INT: return (nm_jansson_json_as_int (vt, elem, out_val) > 0);
|
|
|
|
/* warning: this overwrites/leaks the previous value. You better have *out_val
|
|
* point to uninitialized memory or NULL. */
|
|
case NM_VALUE_TYPE_STRING: return (nm_jansson_json_as_string (vt, elem, out_val) > 0);
|
|
|
|
case NM_VALUE_TYPE_UNSPEC:
|
|
break;
|
|
}
|
|
nm_assert_not_reached ();
|
|
return FALSE;
|
|
}
|
|
|
|
#endif /* NM_VALUE_TYPE_DEFINE_FUNCTIONS */
|
|
|
|
#endif /* __NM_JSON_AUX_H__ */
|