fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-18 11:38:32 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/libnm-core/nm-json.h
Thomas Haller 7df0229c62
libnm: don't include <jansson.h> in libnm but use own variants 
It's error prone to include the header and trying not to use it.
Don't include <jansson.h>. Instead, redefine our nm variants of
everything.

Note that we only redefine stuff that is in public headers (like
"json_t" typedef). libjansson anyway must not change the struct layout
and the like, without breaking all applications. That is because the
non-opaque code from the header anyway is part of the applications that
include it. Later we will add additional unit test that checks that our
redefinition matches to what we had at compile time.
2020-07-09 11:47:05 +02:00

264 lines
7.8 KiB
C
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1+
/*
* Copyright (C) 2017, 2018 Red Hat, Inc.
*/
#ifndef __NM_JSON_H__
#define __NM_JSON_H__
/*****************************************************************************/
#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_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
#include "nm-glib-aux/nm-value-type.h"
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_H__ */
Reference in a new issue View git blame Copy permalink