1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/**
* @file boolean.c
* @author Radek Krejci <rkrejci@cesnet.cz>
* @brief Built-in boolean type plugin.
*
* Copyright (c) 2019-2021 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*/
#include "plugins_types.h"
#include <stdint.h>
#include <stdlib.h>
#include "libyang.h"
/* additional internal headers for some useful simple macros */
#include "common.h"
#include "compat.h"
#include "plugins_internal.h" /* LY_TYPE_*_STR */
/**
* @page howtoDataLYB LYB Binary Format
* @subsection howtoDataLYBTypesBoolean boolean (built-in)
*
* | Size (B) | Mandatory | Type | Meaning |
* | :------ | :-------: | :--: | :-----: |
* | 1 | yes | `int8_t *` | 0 for false, otherwise true |
*/
LIBYANG_API_DEF LY_ERR
lyplg_type_store_boolean(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, size_t value_len,
uint32_t options, LY_VALUE_FORMAT format, void *UNUSED(prefix_data), uint32_t hints,
const struct lysc_node *UNUSED(ctx_node), struct lyd_value *storage, struct lys_glob_unres *UNUSED(unres),
struct ly_err_item **err)
{
LY_ERR ret = LY_SUCCESS;
int8_t i;
/* init storage */
memset(storage, 0, sizeof *storage);
storage->realtype = type;
if (format == LY_VALUE_LYB) {
/* validation */
if (value_len != 1) {
ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Invalid LYB boolean value size %zu (expected 1).",
value_len);
goto cleanup;
}
/* store value */
i = *(int8_t *)value;
storage->boolean = i ? 1 : 0;
/* store canonical value, it always is */
ret = lydict_insert(ctx, i ? "true" : "false", 0, &storage->_canonical);
LY_CHECK_GOTO(ret, cleanup);
/* success */
goto cleanup;
}
/* check hints */
ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err);
LY_CHECK_GOTO(ret, cleanup);
/* validate and store the value */
if ((value_len == ly_strlen_const("true")) && !strncmp(value, "true", ly_strlen_const("true"))) {
i = 1;
} else if ((value_len == ly_strlen_const("false")) && !strncmp(value, "false", ly_strlen_const("false"))) {
i = 0;
} else {
ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Invalid boolean value \"%.*s\".", (int)value_len,
(char *)value);
goto cleanup;
}
storage->boolean = i;
/* store canonical value, it always is */
if (options & LYPLG_TYPE_STORE_DYNAMIC) {
ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical);
options &= ~LYPLG_TYPE_STORE_DYNAMIC;
LY_CHECK_GOTO(ret, cleanup);
} else {
ret = lydict_insert(ctx, value, value_len, &storage->_canonical);
LY_CHECK_GOTO(ret, cleanup);
}
cleanup:
if (options & LYPLG_TYPE_STORE_DYNAMIC) {
free((char *)value);
}
if (ret) {
lyplg_type_free_simple(ctx, storage);
}
return ret;
}
LIBYANG_API_DEF LY_ERR
lyplg_type_compare_boolean(const struct lyd_value *val1, const struct lyd_value *val2)
{
if (val1->realtype != val2->realtype) {
return LY_ENOT;
}
if (val1->boolean != val2->boolean) {
return LY_ENOT;
}
return LY_SUCCESS;
}
LIBYANG_API_DEF const void *
lyplg_type_print_boolean(const struct ly_ctx *UNUSED(ctx), const struct lyd_value *value, LY_VALUE_FORMAT format,
void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len)
{
if (format == LY_VALUE_LYB) {
*dynamic = 0;
if (value_len) {
*value_len = sizeof value->boolean;
}
return &value->boolean;
}
/* use the cached canonical value */
if (dynamic) {
*dynamic = 0;
}
if (value_len) {
*value_len = strlen(value->_canonical);
}
return value->_canonical;
}
/**
* @brief Plugin information for boolean type implementation.
*
* Note that external plugins are supposed to use:
*
* LYPLG_TYPES = {
*/
const struct lyplg_type_record plugins_boolean[] = {
{
.module = "",
.revision = NULL,
.name = LY_TYPE_BOOL_STR,
.plugin.id = "libyang 2 - boolean, version 1",
.plugin.store = lyplg_type_store_boolean,
.plugin.validate = NULL,
.plugin.compare = lyplg_type_compare_boolean,
.plugin.sort = NULL,
.plugin.print = lyplg_type_print_boolean,
.plugin.duplicate = lyplg_type_dup_simple,
.plugin.free = lyplg_type_free_simple,
.plugin.lyb_data_len = 1,
},
{0}
};
|
