The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
value.h
Go to the documentation of this file.
1#pragma once
2/*
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
16 */
17
18/** Boxed value structures and functions to manipulate them
19 *
20 * @file src/lib/util/value.h
21 *
22 * @copyright 2015-2018 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
23 */
24RCSIDH(value_h, "$Id: 7f25f2d35228447ec198e1c3208703584fe87f45 $")
25
26#ifdef __cplusplus
27extern "C" {
28#endif
29
30#define FR_MAX_STRING_LEN 254 /* RFC2138: string 0-253 octets */
31
33
34#ifdef __cplusplus
35}
36#endif
37
38#include <freeradius-devel/build.h>
39#include <freeradius-devel/util/dcursor.h>
40#include <freeradius-devel/missing.h>
41#include <freeradius-devel/util/dbuff.h>
42#include <freeradius-devel/util/debug.h>
43#include <freeradius-devel/util/dict.h>
44#include <freeradius-devel/util/dlist.h>
45#include <freeradius-devel/util/inet.h>
46#include <freeradius-devel/util/log.h>
47#include <freeradius-devel/util/strerror.h>
48#include <freeradius-devel/util/table.h>
49#include <freeradius-devel/util/time.h>
50#include <freeradius-devel/util/token.h>
51#include <freeradius-devel/util/types.h>
52
53#ifdef __cplusplus
54extern "C" {
55#endif
56
57/*
58 * Allow public and private versions of the same structures
59 */
60#ifdef _CONST
61# error _CONST can only be defined in the local header
62#endif
63#ifndef _VALUE_PRIVATE
64# define _CONST const
65#else
66# define _CONST
67#endif
68
69extern size_t const fr_value_box_field_sizes[];
70
71extern size_t const fr_value_box_offsets[];
72
79
87
89
90#ifndef NDEBUG
91# define FR_VALUE_BOX_MAGIC RADIUSD_MAGIC_NUMBER
92#endif
93
94/** @name List and cursor type definitions
95 */
96FR_DLIST_TYPES(fr_value_box_list)
97FR_DLIST_TYPEDEFS(fr_value_box_list, fr_value_box_list_t, fr_value_box_entry_t)
98FR_DCURSOR_DLIST_TYPES(fr_value_box_dcursor, fr_value_box_list, fr_value_box_t)
99/** @{ */
100
101typedef union {
102 /*
103 * Variable length values
104 */
105 struct {
106 union {
107 char const * _CONST strvalue; //!< Pointer to UTF-8 string.
108 uint8_t const * _CONST octets; //!< Pointer to binary string.
109 void * _CONST ptr; //!< generic pointer.
110 };
111 size_t length; //!< Only these types are variable length.
112 };
113
114 struct {
115 void * _CONST cursor; //!< cursors
116 char const * _CONST name; //!< name of the current cursor
117 };
118
119 /*
120 * Fixed length values
121 */
122 fr_ipaddr_t ip; //!< IPv4/6 address/prefix.
123
124 fr_ifid_t ifid; //!< IPv6 interface ID.
125 fr_ethernet_t ether; //!< Ethernet (MAC) address.
126
127 bool boolean; //!< A truth value.
128
129 uint8_t uint8; //!< 8bit unsigned integer.
130 uint16_t uint16; //!< 16bit unsigned integer.
131 uint32_t uint32; //!< 32bit unsigned integer.
132 uint64_t uint64; //!< 64bit unsigned integer.
133 uint128_t uint128; //!< 128bit unsigned integer.
134
135 int8_t int8; //!< 8bit signed integer.
136 int16_t int16; //!< 16bit signed integer.
137 int32_t int32; //!< 32bit signed integer.
138 int64_t int64; //!< 64bit signed integer;
139
140 float float32; //!< Single precision float.
141 double float64; //!< Double precision float.
142
143 fr_unix_time_t date; //!< Date internal format in nanoseconds
144
145 /*
146 * System specific - Used for runtime configuration only.
147 */
148 size_t size; //!< System specific file/memory size.
149 fr_time_delta_t time_delta; //!< a delta time in nanoseconds
150
151 fr_dict_attr_t const * _CONST da; //!< dictionary reference
152
153 fr_value_box_list_t children; //!< for groups
155
156/** Escaping that's been applied to a value box
157 *
158 * This should be a unique value for each dialect being escaped. If the value is 0,
159 * then the box is not escaped. If the escaped value matches the escaped value of
160 * the function performing the escaping then it should not be re-escaped.
161 */
162typedef uintptr_t fr_value_box_safe_for_t;
163
164/*
165 * The default value of "completely unsafe" is zero. That way any initialization routines will default
166 * to marking the data as unsafe.
167 *
168 * The only data which should be marked as being completely safe is data taken from the configuration
169 * files which are managed by the administrator. Data create by end users (e.g. passwords) should always
170 * be marked as unsafe.
171 */
172#define FR_VALUE_BOX_SAFE_FOR_NONE ((uintptr_t) 0)
173#define FR_VALUE_BOX_SAFE_FOR_ANY (~((uintptr_t) 0))
174
175/** Union containing all data types supported by the server
176 *
177 * This union contains all data types that can be represented by fr_pair_ts. It may also be used in other parts
178 * of the server where values of different types need to be stored.
179 *
180 * fr_type_t should be an enumeration of the values in this union.
181 *
182 * Don't change the order of the fields below without checking that the output of radsize doesn't change.
183 *
184 * The first few fields (before safe_for) are reused in the #fr_pair_t. This allows structural
185 * data types to have vp->vp_type, and to also use / set the various flags defined below. Do NOT
186 * change the order of the fields!
187 */
189 /** Type and flags should appear together for packing efficiency
190 */
191 fr_type_t _CONST type; //!< Type of this value-box, at the start, see pair.h
192
193 unsigned int tainted : 1; //!< i.e. did it come from an untrusted source
194 unsigned int secret : 1; //!< Same as #fr_dict_attr_flags_t secret
195 unsigned int immutable : 1; //!< once set, the value cannot be changed
196 unsigned int talloced : 1; //!< Talloced, not stack or text allocated.
197
198 unsigned int edit : 1; //!< to control foreach / edits
199
200 fr_value_box_safe_for_t _CONST safe_for; //!< A unique value to indicate if that value box is safe
201 ///< for consumption by a particular module for a particular
202 ///< purpose. e.g. LDAP, SQL, etc.
203 ///< Usually set by the xlat framework on behalf of an xlat
204 ///< escaping function, and checked by a #fr_value_box_escape_t
205 ///< to see if it needs to operate.
206
207 fr_value_box_entry_t entry; //!< Doubly linked list entry.
208
209 fr_dict_attr_t const *enumv; //!< Enumeration values.
210
211 fr_value_box_datum_t datum; //!< The value held by the value box. Should appear
212 ///< last for packing efficiency.
213#ifndef NDEBUG
214 uint64_t magic; //!< Value to verify that the structure was allocated or initialised properly.
215 char const *file; //!< File where the box was allocated or initialised.
216 int line; //!< Line where the box was allocated or initialised.
217#endif
218};
219
220/** @name List and cursor function definitions
221 */
222FR_DLIST_FUNCS(fr_value_box_list, fr_value_box_t, entry)
223
224#define fr_value_box_list_foreach(_list_head, _iter) fr_dlist_foreach(fr_value_box_list_dlist_head(_list_head), fr_value_box_t, _iter)
225#define fr_value_box_list_foreach_safe(_list_head, _iter) fr_dlist_foreach_safe(fr_value_box_list_dlist_head(_list_head), fr_value_box_t, _iter)
226
227FR_DCURSOR_FUNCS(fr_value_box_dcursor, fr_value_box_list, fr_value_box_t)
228/** @} */
229
230/** Actions to perform when we process a box in a list
231 *
232 */
233typedef enum {
234 FR_VALUE_BOX_LIST_NONE = 0x00, //!< Do nothing to processed boxes.
235 FR_VALUE_BOX_LIST_REMOVE = 0x01, //!< Remove the box from the input list.
236 FR_VALUE_BOX_LIST_FREE_BOX = (0x02 | FR_VALUE_BOX_LIST_REMOVE), //!< Free each processed box.
237 FR_VALUE_BOX_LIST_FREE_BOX_VALUE = 0x04, //!< Explicitly free any value buffers associated
238 ///< with a box.
241
242#define vb_should_free(_action) ((_action & FR_VALUE_BOX_LIST_FREE_BOX) == FR_VALUE_BOX_LIST_FREE_BOX)
243#define vb_should_free_value(_action) ((_action & FR_VALUE_BOX_LIST_FREE_BOX_VALUE) == FR_VALUE_BOX_LIST_FREE_BOX_VALUE)
244#define vb_should_remove(_action) ((_action & FR_VALUE_BOX_LIST_REMOVE) == FR_VALUE_BOX_LIST_REMOVE)
245
246#ifndef NDEBUG
247#define VALUE_BOX_NDEBUG_INITIALISER .file = __FILE__, .line = __LINE__, .magic = FR_VALUE_BOX_MAGIC
248#else
249#define VALUE_BOX_NDEBUG_INITIALISER
250#endif
251
252/** @name Field accessors for #fr_value_box_t
253 *
254 * Use these instead of accessing fields directly to make refactoring
255 * easier in future.
256 *
257 * @{
258 */
259#define vb_strvalue datum.strvalue
260#define vb_octets datum.octets
261#define vb_void datum.ptr
262#define vb_group datum.children
263#define vb_attr datum.da
264
265#define vb_ip datum.ip
266
267#define vb_ifid datum.ifid.addr
268#define vb_ether datum.ether.addr
269
270#define vb_bool datum.boolean
271#define vb_uint8 datum.uint8
272#define vb_uint16 datum.uint16
273#define vb_uint32 datum.uint32
274#define vb_uint64 datum.uint64
275#define vb_uint128 datum.uint128
276
277#define vb_int8 datum.int8
278#define vb_int16 datum.int16
279#define vb_int32 datum.int32
280#define vb_int64 datum.int64
281
282#define vb_float32 datum.float32
283#define vb_float64 datum.float64
284
285#define vb_date datum.date
286
287#define vb_size datum.size
288#define vb_timeval datum.timeval
289#define vb_time_delta datum.time_delta
290
291#define vb_length datum.length
292
293#define vb_cursor datum.cursor
294#define vb_cursor_name datum.name
295/** @} */
296
297/** @name Argument boxing macros
298 *
299 * These macros allow C types to be passed to functions which take
300 * boxed arguments, without needing to declare a fr_value_box_t
301 * explicitly on the stack.
302 *
303 * @{
304 */
305#define _fr_box_with_len(_type, _field, _val, _len) &(fr_value_box_t){ .type = _type, _field = _val, .vb_length = _len, VALUE_BOX_NDEBUG_INITIALISER }
306
307#define fr_box_strvalue(_val) _fr_box_with_len(FR_TYPE_STRING, .vb_strvalue, _val, strlen(_val))
308#define fr_box_strvalue_len(_val, _len) _fr_box_with_len(FR_TYPE_STRING, .vb_strvalue, _val, _len)
309
310#define fr_box_octets(_val, _len) _fr_box_with_len(FR_TYPE_OCTETS, .vb_octets, _val, _len)
311#define fr_box_strvalue_buffer(_val) _fr_box_with_len(FR_TYPE_STRING, .vb_strvalue, _val, talloc_array_length(_val) - 1)
312#define fr_box_octets_buffer(_val) _fr_box_with_len(FR_TYPE_OCTETS, .vb_octets, _val, talloc_array_length(_val))
313
314#define _fr_box(_type, _field, _val) (&(fr_value_box_t){ .type = _type, _field = (_val), VALUE_BOX_NDEBUG_INITIALISER })
315
316#define fr_box_ipaddr(_val) _fr_box((((_val).af == AF_INET) ? \
317 (((_val).prefix == 32) ? FR_TYPE_IPV4_ADDR : \
318 FR_TYPE_IPV4_PREFIX) : \
319 (((_val).prefix == 128) ? FR_TYPE_IPV6_ADDR : \
320 FR_TYPE_IPV6_PREFIX)), \
321 .vb_ip, _val)
322#define fr_box_ipv4addr(_val) _fr_box(FR_TYPE_IPV4_ADDR, .vb_ip, _val)
323#define fr_box_ipv4prefix(_val) _fr_box(FR_TYPE_IPV4_PREFIX, .vb_ip, _val)
324#define fr_box_ipv6addr(_val) _fr_box(FR_TYPE_IPV6_ADDR, .vb_ip, _val)
325#define fr_box_ipv6prefix(_val) _fr_box(FR_TYPE_IPV6_PREFIX, .vb_ip, _val)
326
327#define fr_box_ifid(_val) _fr_box(FR_TYPE_IFID, .vb_ifid, _val)
328#define fr_box_ether(_val) &(fr_value_box_t){ .type = FR_TYPE_ETHERNET, .vb_ether = { _val[0], _val[1], _val[2], _val[3], _val[4], _val[5] } }
329
330#define fr_box_bool(_val) _fr_box(FR_TYPE_BOOL, .vb_bool, _val)
331
332#define fr_box_uint8(_val) _fr_box(FR_TYPE_UINT8, .vb_uint8, _val)
333#define fr_box_uint16(_val) _fr_box(FR_TYPE_UINT16, .vb_uint16, _val)
334#define fr_box_uint32(_val) _fr_box(FR_TYPE_UINT32, .vb_uint32, _val)
335#define fr_box_uint64(_val) _fr_box(FR_TYPE_UINT64, .vb_uint64, _val)
336#define fr_box_uint128(_val) _fr_box(FR_TYPE_UINT128, .vb_uint128, _val)
337
338#define fr_box_int8(_val) _fr_box(FR_TYPE_INT8, .vb_int8, _val)
339#define fr_box_int16(_val) _fr_box(FR_TYPE_INT16, .vb_int16, _val)
340#define fr_box_int32(_val) _fr_box(FR_TYPE_INT32, .vb_int32, _val)
341#define fr_box_int64(_val) _fr_box(FR_TYPE_INT64, .vb_int64, _val)
342
343#define fr_box_float32(_val) _fr_box(FR_TYPE_FLOAT32, .vb_float32, _val)
344#define fr_box_float64(_val) _fr_box(FR_TYPE_FLOAT64, .vb_float64, _val)
345
346#define fr_box_date(_val) _fr_box(FR_TYPE_DATE, .vb_date, _val)
347
348#define fr_box_time(_val) _fr_box(FR_TYPE_DATE, .vb_date, fr_time_to_unix_time(_val))
349
350#define fr_box_size(_val) _fr_box(FR_TYPE_SIZE, .vb_size, _val)
351
352#define _fr_box_with_da(_type, _field, _val, _da) (&(fr_value_box_t){ .type = _type, _field = (_val), .enumv = (_da) })
353
354#define fr_box_time_delta_with_res(_val, _res) _fr_box_with_da(FR_TYPE_TIME_DELTA, \
355 .vb_time_delta, \
356 (_val), \
357 (&(fr_dict_attr_t){ \
358 .name = NULL, \
359 .type = FR_TYPE_TIME_DELTA, \
360 .flags = { \
361 .type_size = _res \
362 } \
363 }))
364
365#define fr_box_time_delta(_val) fr_box_time_delta_with_res((_val), FR_TIME_RES_SEC)
366
367#define fr_box_time_delta_sec(_val) fr_box_time_delta_with_res((_val), FR_TIME_RES_SEC)
368
369#define fr_box_time_delta_msec(_val) fr_box_time_delta_with_res((_val), FR_TIME_RES_MSEC)
370
371#define fr_box_time_delta_nsec(_val) fr_box_time_delta_with_res((_val), FR_TIME_RES_NSEC)
372
373#define fr_box_time_delta_usec(_val) fr_box_time_delta_with_res((_val), FR_TIME_RES_USEC)
374
375/** Create an ephemeral box
376 *
377 * @note This likely shouldn't be used for variable width integers like 'int'
378 * as it obscures the underlying type.
379 *
380 * @param[in] _val to box.
381 */
382#define fr_box(_val) _Generic((_val), \
383 fr_ipaddr_t * : fr_box_ipaddr, \
384 fr_ipaddr_t const * : fr_box_ipaddr, \
385 fr_ethernet_t * : fr_box_ether, \
386 fr_ethernet_t const * : fr_box_ether, \
387 bool : fr_box_bool, \
388 int8_t : fr_box_int8, \
389 int16_t : fr_box_int16, \
390 int32_t : fr_box_int32, \
391 int64_t : fr_box_int16, \
392 uint8_t : fr_box_uint8, \
393 uint16_t : fr_box_uint16, \
394 uint32_t : fr_box_uint32, \
395 uint64_t : fr_box_uint64, \
396 size_t : fr_box_size, \
397 float : fr_box_float32, \
398 double : fr_box_float64 \
399)(_val)
400
401/** Create an ephemeral boxed value with a variable length
402 *
403 * @param[in] _val C variable to assign value from.
404 * @param[in] _len of C variable.
405 */
406#define fr_box_len( _val, _len) \
407_Generic((_val), \
408 char * : fr_box_strvalue_len, \
409 char const * : fr_box_strvalue_len, \
410 uint8_t * : fr_box_octets, \
411 uint8_t const * : fr_box_octets \
412)(_val, _len)
413
414/** @} */
415
416/** @name Type checking macros
417 *
418 * Convenience macros for checking if a box is a
419 * specific type.
420 *
421 * @{
422 */
423#define fr_box_is_null(_x) fr_type_is_null((_x)->type)
424#define fr_box_is_string(_x) fr_type_is_string((_x)->type)
425#define fr_box_is_octets(_x) fr_type_is_octets((_x)->type)
426#define fr_box_is_ipv4addr(_x) fr_type_is_ipv4addr((_x)->type)
427#define fr_box_is_ipv4prefix(_x) fr_type_is_ipv4prefix((_x)->type)
428#define fr_box_is_ipv6addr(_x) fr_type_is_ipv6addr((_x)->type)
429#define fr_box_is_ipv6prefix(_x) fr_type_is_ipv6prefix((_x)->type)
430#define fr_box_is_ifid(_x) fr_type_is_ifid((_x)->type)
431#define fr_box_is_combo_ipaddr(_x) fr_type_is_combo_ipaddr((_x)->type)
432#define fr_box_is_combo_ipprefix(_x) fr_type_is_combo_ipprefix((_x)->type)
433#define fr_box_is_ethernet(_x) fr_type_is_ethernet((_x)->type)
434#define fr_box_is_bool(_x) fr_type_is_bool((_x)->type)
435#define fr_box_is_uint8(_x) fr_type_is_uint8((_x)->type)
436#define fr_box_is_uint16(_x) fr_type_is_uint16((_x)->type)
437#define fr_box_is_uint32(_x) fr_type_is_uint32((_x)->type)
438#define fr_box_is_uint64(_x) fr_type_is_uint64((_x)->type)
439#define fr_box_is_int8(_x) fr_type_is_int8((_x)->type)
440#define fr_box_is_int16(_x) fr_type_is_int16((_x)->type)
441#define fr_box_is_int32(_x) fr_type_is_int32((_x)->type)
442#define fr_box_is_int64(_x) fr_type_is_int64((_x)->type)
443#define fr_box_is_float32(_x) fr_type_is_float32((_x)->type)
444#define fr_box_is_float64(_x) fr_type_is_float64((_x)->type)
445#define fr_box_is_date(_x) fr_type_is_date((_x)->type)
446#define fr_box_is_time_delta(_x) fr_type_is_time_delta((_x)->type)
447#define fr_box_is_size(_x) fr_type_is_size((_x)->type)
448#define fr_box_is_tlv(_x) fr_type_is_tlv((_x)->type)
449#define fr_box_is_struct(_x) fr_type_is_struct((_x)->type)
450#define fr_box_is_vsa(_x) fr_type_is_vsa((_x)->type)
451#define fr_box_is_vendor(_x) fr_type_is_vendor((_x)->type)
452#define fr_box_is_group(_x) fr_type_is_group((_x)->type)
453#define fr_box_is_value_box(_x) fr_type_is_value_box((_x)->type)
454#define fr_box_is_void(_x) fr_type_is_void((_x)->type)
455
456#define fr_box_is_integer_except_bool(_x) fr_type_is_integer_except_bool((_x)->type)
457#define fr_box_is_integer(_x) fr_type_is_integer((_x)->type)
458#define fr_box_is_numeric(_x) fr_type_is_numeric((_x)->type)
459
460#define fr_box_is_ip(_x) fr_type_is_ip((_x)->type)
461
462#define fr_box_is_fixed_size(_x) fr_type_is_fixed_size((_x)->type)
463#define fr_box_is_variable_size(_x) fr_type_is_variable_size((_x)->type)
464#define fr_box_is_value(_x) fr_type_is_value((_x)->type)
465#define fr_box_is_quoted(_x) fr_type_is_quoted((_x)->type)
466
467#define fr_box_is_structural_except_vsa(_x) fr_type_is_structural_except_vsa((_x)->type)
468#define fr_box_is_structural(_x) fr_type_is_structural((_x)->type)
469#define fr_box_is_non_value(_x) fr_type_is_non_value((_x)->type)
470/** @} */
471
472/** @name Parsing rules for various types of string
473 *
474 * @{
475 */
476extern fr_sbuff_parse_rules_t const value_parse_rules_bareword_unquoted;
477extern fr_sbuff_parse_rules_t const value_parse_rules_double_unquoted;
478extern fr_sbuff_parse_rules_t const value_parse_rules_single_unquoted;
479extern fr_sbuff_parse_rules_t const value_parse_rules_solidus_unquoted;
480extern fr_sbuff_parse_rules_t const value_parse_rules_backtick_unquoted;
481extern fr_sbuff_parse_rules_t const *value_parse_rules_unquoted[T_TOKEN_LAST];
482extern fr_sbuff_parse_rules_t const *value_parse_rules_unquoted_char[UINT8_MAX];
483
484extern fr_sbuff_parse_rules_t const value_parse_rules_bareword_quoted;
485extern fr_sbuff_parse_rules_t const value_parse_rules_double_quoted;
486extern fr_sbuff_parse_rules_t const value_parse_rules_single_quoted;
487extern fr_sbuff_parse_rules_t const value_parse_rules_solidus_quoted;
488extern fr_sbuff_parse_rules_t const value_parse_rules_backtick_quoted;
489extern fr_sbuff_parse_rules_t const *value_parse_rules_quoted[T_TOKEN_LAST];
490extern fr_sbuff_parse_rules_t const *value_parse_rules_quoted_char[UINT8_MAX];
491
492extern fr_sbuff_parse_rules_t const value_parse_rules_double_3quoted;
493extern fr_sbuff_parse_rules_t const value_parse_rules_single_3quoted;
494extern fr_sbuff_parse_rules_t const value_parse_rules_solidus_3quoted;
495extern fr_sbuff_parse_rules_t const value_parse_rules_backtick_3quoted;
496extern fr_sbuff_parse_rules_t const *value_parse_rules_3quoted[T_TOKEN_LAST];
497/** @} */
498
499/** @name Allocation and initialisation functions
500 *
501 * These macros and inline functions simplify working
502 * with lists of value boxes.
503 *
504 * @{
505 */
506/** A static initialiser for stack/globally allocated boxes
507 *
508 * We can only safely initialise a null box, as many other type need special initialisation
509 */
510#define FR_VALUE_BOX_INITIALISER_NULL(_vb) \
511 { \
512 .type = FR_TYPE_NULL, \
513 .entry = { \
514 .entry = FR_DLIST_ENTRY_INITIALISER((_vb).entry.entry) \
515 }, \
516 VALUE_BOX_NDEBUG_INITIALISER \
517 }
518
519/** A static initialiser for stack/globally allocated boxes
520 *
521 */
522#define FR_VALUE_BOX_INITIALISER(_vb, _type, _field, _val) \
523 { \
524 .type = _type, \
525 .datum = { \
526 _field = _val, \
527 }, \
528 .entry = { \
529 .entry = FR_DLIST_ENTRY_INITIALISER((_vb).entry.entry) \
530 }, \
531 VALUE_BOX_NDEBUG_INITIALISER \
532 }
533
534static inline CC_HINT(nonnull(1), always_inline)
536{
537 /*
538 * Initializes an fr_value_box_t pointed at by vb appropriately for a given type.
539 * Coverity gets involved here because an fr_value_box_t has members with const-
540 * qualified type (and members that have members with const-qualified type), so an
541 * attempt to assign to *vb or any of its cosnt-qualified members will give an error.
542 *
543 * C compilers, at least currently, let one get around the issue. See the memcpy()
544 * below. Coverity, though, isn't faked out, and reports the store_writes_const_field
545 * defect annotated here. Anything we do has to eventually assign to the whole of *vb
546 * and thus will raise the issue.
547 */
548 /* coverity[store_writes_const_field] */
549 memcpy((void *) vb, &(fr_value_box_t){
550 .type = type,
551 .enumv = enumv,
552 .tainted = tainted,
553 .secret = enumv && enumv->flags.secret,
554 /* don't set the immutable flag. The caller has to do it once he's finished editing the values */
555 }, sizeof(*vb));
556 fr_value_box_list_entry_init(vb);
557
558 /*
559 * The majority of types are fine to initialise to
560 * all zeros, the following are the exceptions.
561 */
562 switch (type) {
564 fr_value_box_list_init(&vb->vb_group);
565 break;
566
568 case FR_TYPE_COMBO_IP_ADDR: /* Default to the smaller type */
569 vb->vb_ip.af = AF_INET;
570 vb->vb_ip.prefix = 32;
571 break;
572
574 case FR_TYPE_COMBO_IP_PREFIX: /* Default to the samaller type */
575 vb->vb_ip.af = AF_INET;
576 break;
577
579 vb->vb_ip.af = AF_INET6;
580 vb->vb_ip.prefix = 128;
581 break;
582
584 vb->vb_ip.af = AF_INET6;
585 break;
586
587 default:
588 break;
589 }
590
591#ifndef NDEBUG
592 vb->magic = FR_VALUE_BOX_MAGIC;
593 vb->file = file;
594 vb->line = line;
595#endif
596}
597
598/** Initialise a fr_value_box_t
599 *
600 * The value should be set later with one of the fr_value_box_* functions.
601 *
602 * @param[in] _vb to initialise.
603 * @param[in] _type to set.
604 * @param[in] _enumv Enumeration values.
605 * @param[in] _tainted Whether data will come from an untrusted source.
606 *
607 * @hidecallergraph
608 */
609#define fr_value_box_init(_vb, _type, _enumv, _tainted) _fr_value_box_init(NDEBUG_LOCATION_EXP _vb, _type, _enumv, _tainted)
610
611/** Initialise an empty/null box that will be filled later
612 *
613 * @param[in] _vb to initialise.
614 */
615#define fr_value_box_init_null(_vb) _fr_value_box_init(NDEBUG_LOCATION_EXP _vb, FR_TYPE_NULL, NULL, false)
616
617static inline CC_HINT(always_inline)
619{
620 fr_value_box_t *vb;
621
622 vb = talloc(ctx, fr_value_box_t);
623 if (unlikely(!vb)) return NULL;
624
626 vb->talloced = 1;
627
628 return vb;
629}
630
631/** Allocate a value box of a specific type
632 *
633 * Allocates memory for the box, and sets the length of the value
634 * for fixed length types.
635 *
636 * @param[in] _ctx to allocate the value_box in.
637 * @param[in] _type of value.
638 * @param[in] _enumv Enumeration values.
639 * @return
640 * - A new fr_value_box_t.
641 * - NULL on error.
642 */
643#define fr_value_box_alloc(_ctx, _type, _enumv) _fr_value_box_alloc(NDEBUG_LOCATION_EXP _ctx, _type, _enumv)
644
645/** Allocate a value box for later use with a value assignment function
646 *
647 * @param[in] _ctx to allocate the value_box in.
648 * @return
649 * - A new fr_value_box_t.
650 * - NULL on error.
651 *
652 * @hidecallergraph
653 */
654#define fr_value_box_alloc_null(_ctx) _fr_value_box_alloc(NDEBUG_LOCATION_EXP _ctx, FR_TYPE_NULL, NULL)
655
656/** @} */
657
658/** @name Escape functions
659 *
660 * Apply a transformation to a value box or list of value boxes.
661 *
662 * @{
663 */
664
665 /** Escape a value box
666 *
667 * @param[in] vb to escape.
668 * @param[in] uctx user context to pass to the escape function.
669 * @return
670 * - 0 on success.
671 * - -1 on failure.
672 */
673typedef int (*fr_value_box_escape_func_t)(fr_value_box_t *vb, void *uctx);
674
680
681int fr_value_box_escape_in_place(fr_value_box_t *vb, fr_value_box_escape_t const *escape, void *uctx)
682 CC_HINT(nonnull(1,2));
683int fr_value_box_list_escape_in_place(fr_value_box_list_t *list, fr_value_box_escape_t const *escape, void *uctx)
684 CC_HINT(nonnull(1,2));
685/** @} */
686
687/** @name Convenience functions
688 *
689 * These macros and inline functions simplify working
690 * with lists of value boxes.
691 *
692 * @{
693 */
694/** Determines whether a list contains the number of boxes required
695 *
696 * @param[in] list of value boxes.
697 * @param[in] min The number of boxes required to return true.
698 * @return
699 * - true if the list has at least min boxes.
700 * - false if the list has fewer than min boxes.
701 */
702static inline CC_HINT(nonnull)
703bool fr_value_box_list_len_min(fr_value_box_list_t const *list, unsigned int min)
704{
705 unsigned int i = fr_value_box_list_num_elements(list);
706
707 return (i >= min);
708}
709/** @} */
710
711/** @name Box to box copying
712 *
713 * @{
714 */
716 CC_HINT(nonnull(1));
717
719 CC_HINT(nonnull(1));
720
721int fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src)
722 CC_HINT(nonnull(2,3));
723
724void fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst,
725 const fr_value_box_t *src)
726 CC_HINT(nonnull(2,3));
727
728int fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src)
729 CC_HINT(nonnull(2,3));
730
731/** Copy an existing box, allocating a new box to hold its contents
732 *
733 * @param[in] ctx to allocate new box in.
734 * @param[in] src box to copy.
735 */
736static inline CC_HINT(nonnull(2))
738{
740 if (unlikely(!vb)) return NULL;
741
742 if ((unlikely(fr_value_box_copy(vb, vb, src) < 0))) {
743 talloc_free(vb);
744 return NULL;
745 }
746
747 return vb;
748}
749/** @} */
750
751/** @name Value box assignment functions
752 *
753 * These functions allow C values to be assigned to value boxes.
754 * They will work with uninitialised/stack allocated memory.
755 *
756 * @{
757 */
758
759/** Return a pointer to the "raw" value from a value-box.
760 *
761 * This has "const" input and "unconst" output because sometimes it's used
762 * to copy out of, and sometimes in to, a value-box. We rely on the caller to know
763 * the correct uses of it.
764 */
765static inline CC_HINT(always_inline)
770
771/** Copy the value of a value box to a field in a C struct
772 *
773 * This is useful when interacting with 3rd party libraries, and doing configuration parsing
774 * as it allows us to use standard parsing and casting functions and then emit the result
775 * as a C value.
776 *
777 * The field pointed to by out must be of the same type as we use to represent the value boxe's
778 * value in its datum union, or at least the same size.
779 *
780 * No checks are done to ensure this is the case, so if you get this wrong it'll lead to silent
781 * memory corruption.
782 *
783 * @param[out] out Field in struct to write variable to.
784 * @param[in] vb to copy value from.
785 * @return
786 * - 0 on success.
787 * - -1 on failure.
788 */
789static inline CC_HINT(always_inline)
791{
792 size_t len;
793
794 len = fr_value_box_field_sizes[vb->type];
795 if (len == 0) {
796 fr_strerror_printf("Type %s not supported for conversion to C type", fr_type_to_str(vb->type));
797 return -1;
798 }
799
800 memcpy(out, ((uint8_t const *)vb) + fr_value_box_offsets[vb->type], len);
801
802 return 0;
803}
804
805/** Copy a C value value to a value box.
806 *
807 * This is useful when interacting with 3rd party libraries, and doing configuration parsing
808 * as it allows us to use standard parsing and casting functions and then emit the result
809 * as a C value.
810 *
811 * The field pointed to by in must be of the same type as we use to represent the value boxe's
812 * value in its datum union, or at least the same size.
813 *
814 * No checks are done to ensure this is the case, so if you get this wrong it'll lead to silent
815 * memory corruption.
816 *
817 * @param[in] vb destination value box, MUST already be initialized
818 * @param[out] in C variable to read from
819 * @return
820 * - 0 on success.
821 * - -1 on failure.
822 */
823static inline CC_HINT(always_inline)
825{
826 size_t len;
827
828 len = fr_value_box_field_sizes[vb->type];
829 if (len == 0) {
830 fr_strerror_printf("Type %s not supported for conversion to C type", fr_type_to_str(vb->type));
831 return -1;
832 }
833
834 memcpy(((uint8_t *)vb) + fr_value_box_offsets[vb->type], in, len);
835
836 return 0;
837}
838
839
840/** Box an ethernet value (6 bytes, network byte order)
841 *
842 * @param[in] dst Where to copy the ethernet address to.
843 * @param[in] enumv Enumeration values.
844 * @param[in] src The ethernet address.
845 * @param[in] tainted Whether data will come from an untrusted source.
846 * @return 0 (always successful).
847 */
848static inline CC_HINT(nonnull(1,3), always_inline) \
850 fr_ethernet_t const *src, bool tainted)
851{
852 fr_value_box_init(dst, FR_TYPE_ETHERNET, enumv, tainted);
853 memcpy(dst->vb_ether, src, sizeof(dst->vb_ether));
854 return 0;
855}
856
857#define DEF_BOXING_FUNC(_ctype, _field, _type) \
858static inline CC_HINT(nonnull(1), always_inline) \
859int fr_value_box_##_field(fr_value_box_t *dst, fr_dict_attr_t const *enumv, \
860 _ctype const value, bool tainted) { \
861 fr_value_box_init(dst, _type, enumv, tainted); \
862 dst->vb_##_field = value; \
863 return 0; \
864}
865
866DEF_BOXING_FUNC(bool, bool, FR_TYPE_BOOL)
867
871DEF_BOXING_FUNC(uint64_t, uint64, FR_TYPE_UINT64)
872
873DEF_BOXING_FUNC(int8_t, int8, FR_TYPE_INT8)
874DEF_BOXING_FUNC(int16_t, int16, FR_TYPE_INT16)
875DEF_BOXING_FUNC(int32_t, int32, FR_TYPE_INT32)
876DEF_BOXING_FUNC(int64_t, int64, FR_TYPE_INT64)
877
878DEF_BOXING_FUNC(float, float32, FR_TYPE_FLOAT32)
880
882
883/** Automagically fill in a box, determining the value type from the type of the C variable
884 *
885 * Simplify boxing for simple C types using the _Generic macro to emit code that
886 * fills in the value box based on the type of _var provided.
887 *
888 * @note Will not set the box value to tainted. You should do this manually if required.
889 *
890 * @note Will not work for all box types. Will default to the 'simpler' box type, if the mapping
891 * between C type and box type is ambiguous.
892 *
893 * @param[in] _box to assign value to.
894 * @param[in] _var C variable to assign value from.
895 * @param[in] _tainted Whether the value came from an untrusted source.
896 */
897#define fr_value_box(_box, _var, _tainted) \
898_Generic((_var), \
899 fr_ipaddr_t * : fr_value_box_ipaddr, \
900 fr_ipaddr_t const * : fr_value_box_ipaddr, \
901 fr_ethernet_t * : fr_value_box_ethernet_addr, \
902 fr_ethernet_t const * : fr_value_box_ethernet_addr, \
903 bool : fr_value_box_bool, \
904 uint8_t : fr_value_box_uint8, \
905 uint16_t : fr_value_box_uint16, \
906 uint32_t : fr_value_box_uint32, \
907 uint64_t : fr_value_box_uint64, \
908 int8_t : fr_value_box_int8, \
909 int16_t : fr_value_box_int16, \
910 int32_t : fr_value_box_int32, \
911 int64_t : fr_value_box_int64, \
912 float : fr_value_box_float32, \
913 double : fr_value_box_float64 \
914)(_box, NULL, _var, _tainted)
915
916/** Automagically fill in a box, for types with length
917 *
918 * @param[in] _ctx to allocate value in.
919 * @param[in] _box to assign value to.
920 * @param[in] _var C variable to assign value from.
921 * @param[in] _len of C variable.
922 * @param[in] _tainted Whether the value came from an untrusted source.
923 */
924#define fr_value_box_len(_ctx, _box, _var, _len, _tainted) \
925_Generic((_var), \
926 char * : fr_value_box_bstrndup, \
927 char const * : fr_value_box_bstrndup, \
928 uint8_t * : fr_value_box_memdup, \
929 uint8_t const * : fr_value_box_memdup \
930)(_ctx, _box, NULL, _var, _len, _tainted)
931
932/** Unbox an ethernet value (6 bytes, network byte order)
933 *
934 * @param[in] dst Where to copy the ethernet address to.
935 * @param[in] src Where to copy the ethernet address from.
936 * @return
937 * - 0 on success.
938 * - -1 on type mismatch.
939 */
940static inline CC_HINT(nonnull)
942{
943 if (unlikely(src->type != FR_TYPE_ETHERNET)) { \
944 fr_strerror_printf("Unboxing failed. Needed type %s, had type %s",
946 fr_type_to_str(src->type));
947 return -1; \
948 }
949 memcpy(dst, src->vb_ether, sizeof(src->vb_ether)); /* Must be src, dst is a pointer */
950 return 0;
951}
952
953#define DEF_UNBOXING_FUNC(_ctype, _field, _type) \
954static inline CC_HINT(nonnull) \
955int fr_value_unbox_##_field(_ctype *var, fr_value_box_t const *src) { \
956 if (unlikely(src->type != _type)) { \
957 fr_strerror_printf("Unboxing failed. Needed type %s, had type %s", \
958 fr_type_to_str(_type), \
959 fr_type_to_str(src->type)); \
960 return -1; \
961 } \
962 *var = src->vb_##_field; \
963 return 0; \
964}
965
969DEF_UNBOXING_FUNC(uint64_t, uint64, FR_TYPE_UINT64)
970
971DEF_UNBOXING_FUNC(int8_t, int8, FR_TYPE_INT8)
972DEF_UNBOXING_FUNC(int16_t, int16, FR_TYPE_INT16)
973DEF_UNBOXING_FUNC(int32_t, int32, FR_TYPE_INT32)
974DEF_UNBOXING_FUNC(int64_t, int64, FR_TYPE_INT64)
975
976DEF_UNBOXING_FUNC(float, float32, FR_TYPE_FLOAT32)
978
980
981/** Unbox simple types performing type checks
982 *
983 * @param[out] _var to write to.
984 * @param[in] _box to unbox.
985 */
986#define fr_value_unbox_shallow(_var, _box) \
987_Generic((_var), \
988 uint8_t * : fr_value_unbox_uint8, \
989 uint16_t * : fr_value_unbox_uint16, \
990 uint32_t * : fr_value_unbox_uint32, \
991 uint64_t * : fr_value_unbox_uint64, \
992 int8_t * : fr_value_unbox_int8, \
993 int16_t * : fr_value_unbox_int16, \
994 int32_t * : fr_value_unbox_int32, \
995 int64_t * : fr_value_unbox_int64, \
996 float * : fr_value_unbox_float32, \
997 double * : fr_value_unbox_float64 \
998)(_var, _box)
999
1000/** @} */
1001
1002/*
1003 * Comparison
1004 */
1005int8_t fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b)
1006 CC_HINT(nonnull);
1007
1009 CC_HINT(nonnull);
1010
1011/*
1012 * Conversion
1013 */
1014size_t fr_value_str_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
1015 CC_HINT(nonnull);
1016
1017size_t fr_value_substr_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
1018 CC_HINT(nonnull);
1019
1020static inline size_t fr_value_str_aunescape(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t inlen, char quote)
1022
1023static inline size_t fr_value_substr_aunescape(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t inlen, char quote)
1025
1027 CC_HINT(nonnull);
1028
1030 CC_HINT(nonnull);
1031
1033#define FR_VALUE_BOX_TO_NETWORK_RETURN(_dbuff, _value) FR_DBUFF_RETURN(fr_value_box_to_network, _dbuff, _value)
1034
1035int fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *value)
1036 CC_HINT(nonnull);
1037
1038/** Special value to indicate fr_value_box_from_network experienced a general error
1039 */
1040#define FR_VALUE_BOX_NET_ERROR SSIZE_MIN
1041
1042/** Special value to indicate fr_value_box_from_network hit an out of memory error
1043 */
1044#define FR_VALUE_BOX_NET_OOM (FR_VALUE_BOX_NET_ERROR + 1)
1045
1046/** Special value to ensure other encoding/decoding errors don't overlap
1047 */
1048#define FR_VALUE_BOX_NET_MAX (FR_VALUE_BOX_NET_OOM + 1)
1049
1050ssize_t fr_value_box_from_network(TALLOC_CTX *ctx,
1051 fr_value_box_t *dst, fr_type_t type, fr_dict_attr_t const *enumv,
1052 fr_dbuff_t *dbuff, size_t len, bool tainted)
1053 CC_HINT(nonnull(2,5));
1054
1055int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst,
1056 fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
1057 fr_value_box_t const *src)
1058 CC_HINT(warn_unused_result,nonnull(2,5));
1059
1060int fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb,
1061 fr_type_t dst_type, fr_dict_attr_t const *dst_enumv)
1062 CC_HINT(warn_unused_result,nonnull(1));
1063
1065 CC_HINT(nonnull(1));
1066
1068 fr_ipaddr_t const *ipaddr, bool tainted)
1069 CC_HINT(nonnull(1,3));
1070
1072 CC_HINT(nonnull);
1073
1074#define fr_value_box_mark_safe_for(_box, _safe_for) _fr_value_box_mark_safe_for(_box, (fr_value_box_safe_for_t)_safe_for)
1076 CC_HINT(nonnull);
1077
1079 CC_HINT(nonnull);
1080
1081#define fr_value_box_is_safe_for(_box, _safe_for) ((_box->safe_for == (fr_value_box_safe_for_t)_safe_for) || (_box->safe_for == FR_VALUE_BOX_SAFE_FOR_ANY))
1082#define fr_value_box_is_safe_for_only(_box, _safe_for) (_box->safe_for == (fr_value_box_safe_for_t)_safe_for)
1083
1084void fr_value_box_list_mark_safe_for(fr_value_box_list_t *list, fr_value_box_safe_for_t safe_for);
1085
1089
1090static inline CC_HINT(nonnull, always_inline)
1092{
1093 return box->secret;
1094}
1095
1096static inline CC_HINT(nonnull)
1098{
1099 fr_value_box_t const *vb = NULL;
1100
1101 if (box->secret) return true;
1102 if (box->type == FR_TYPE_GROUP) {
1103 while ((vb = fr_value_box_list_next(&box->vb_group, vb))) {
1104 if (fr_value_box_contains_secret(vb)) return true;
1105 }
1106 }
1107 return false;
1108}
1109
1110static inline CC_HINT(nonnull, always_inline)
1112{
1113 box->secret = secret;
1114}
1115
1116/** @name Assign and manipulate binary-unsafe C strings
1117 *
1118 * @{
1119 */
1120int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1121 char const *src, bool tainted)
1122 CC_HINT(nonnull(2,4));
1123
1124int fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb)
1125 CC_HINT(nonnull(1));
1126
1127int fr_value_box_vasprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted,
1128 char const *fmt, va_list ap)
1129 CC_HINT(nonnull(2,5), format(printf,5,0));
1130
1131int fr_value_box_asprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted,
1132 char const *fmt, ...)
1133 CC_HINT(format(printf,5,6), nonnull(2,5));
1134
1136 char const *src, bool tainted)
1137 CC_HINT(nonnull(1,3));
1138
1139void fr_value_box_strdup_shallow_replace(fr_value_box_t *vb, char const *src, ssize_t len)
1140 CC_HINT(nonnull);
1141/** @} */
1142
1143/** @name Assign and manipulate binary-safe strings
1144 *
1145 * @{
1146 */
1147int fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1148 size_t len, bool tainted)
1149 CC_HINT(nonnull(3));
1150
1151int fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len)
1152 CC_HINT(nonnull(3));
1153
1154int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1155 char const *src, size_t len, bool tainted)
1156 CC_HINT(nonnull(2)); /* src may be NULL if len == 0 */
1157
1158int fr_value_box_bstrndup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1159 fr_dbuff_t *dbuff, size_t len, bool tainted)
1160 CC_HINT(nonnull(2,4));
1161
1162int fr_value_box_bstrdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1163 char const *src, bool tainted)
1164 CC_HINT(nonnull(2,4));
1165
1167 char const *src, size_t len, bool tainted)
1168 CC_HINT(nonnull(1,3));
1169
1170int fr_value_box_bstrdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1171 char const *src, bool tainted)
1172 CC_HINT(nonnull(2,4));
1173
1174/** @} */
1175
1176/** @name Assign and manipulate octets strings
1177 *
1178 * @{
1179 */
1180int fr_value_box_mem_alloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1181 size_t len, bool tainted)
1182 CC_HINT(nonnull(3));
1183
1184int fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len)
1185 CC_HINT(nonnull(3));
1186
1187int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1188 uint8_t const *src, size_t len, bool tainted)
1189 CC_HINT(nonnull(2)); /* src may be NULL if len == 0 */
1190
1191int fr_value_box_memdup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1192 fr_dbuff_t *dbuff, size_t len, bool tainted)
1193 CC_HINT(nonnull(2,4));
1194
1195int fr_value_box_memdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1196 uint8_t const *src, bool tainted)
1197 CC_HINT(nonnull(2,4));
1198
1200 uint8_t const *src, size_t len, bool tainted)
1201 CC_HINT(nonnull(1,3));
1202
1203void fr_value_box_memdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv,
1204 uint8_t const *src, bool tainted)
1205 CC_HINT(nonnull(2,4));
1206
1207/** @} */
1208
1210 CC_HINT(nonnull);
1211
1212
1213
1214void fr_value_box_set_cursor(fr_value_box_t *dst, fr_type_t type, void *ptr, char const *name) CC_HINT(nonnull);
1215
1216#define fr_value_box_get_cursor(_dst) talloc_get_type_abort((_dst)->vb_cursor, fr_dcursor_t)
1217
1218/** @name Parsing
1219 *
1220 * @{
1221 */
1222ssize_t fr_value_box_from_substr(TALLOC_CTX *ctx, fr_value_box_t *dst,
1223 fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
1224 fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules)
1225 CC_HINT(nonnull(2,5));
1226
1227ssize_t fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst,
1228 fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
1229 char const *in, size_t inlen,
1230 fr_sbuff_unescape_rules_t const *erules)
1231 CC_HINT(nonnull(2,5));
1232/** @} */
1233
1234/** @name Work with lists of boxed values
1235 *
1236 * @{
1237 */
1238ssize_t fr_value_box_list_concat_as_string(fr_value_box_t *safety, fr_sbuff_t *sbuff, fr_value_box_list_t *list,
1239 char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules,
1240 fr_value_box_list_action_t proc_action, fr_value_box_safe_for_t safe_for, bool flatten)
1241 CC_HINT(nonnull(2,3));
1242
1243ssize_t fr_value_box_list_concat_as_octets(fr_value_box_t *safety, fr_dbuff_t *dbuff, fr_value_box_list_t *list,
1244 uint8_t const *sep, size_t sep_len,
1245 fr_value_box_list_action_t proc_action, bool flatten)
1246 CC_HINT(nonnull(2,3));
1247
1248int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx,
1249 fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type,
1250 fr_value_box_list_action_t proc_action, bool flatten,
1251 size_t max_size)
1252 CC_HINT(nonnull(2,3));
1253
1254void fr_value_box_flatten(TALLOC_CTX *ctx, fr_value_box_list_t *list, bool steal, bool free)
1255 CC_HINT(nonnull(2));
1256
1257char *fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim,
1258 fr_sbuff_escape_rules_t const *e_rules)
1259 CC_HINT(nonnull(2));
1260
1261char *fr_value_box_list_aprint_secure(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim,
1262 fr_sbuff_escape_rules_t const *e_rules)
1263 CC_HINT(nonnull(2));
1264
1265int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
1266 CC_HINT(nonnull(2,3));
1267
1268bool fr_value_box_list_tainted(fr_value_box_list_t const *head)
1269 CC_HINT(nonnull(1));
1270
1271void fr_value_box_list_taint(fr_value_box_list_t *head)
1272 CC_HINT(nonnull(1));
1273
1274void fr_value_box_list_untaint(fr_value_box_list_t *head)
1275 CC_HINT(nonnull(1));
1276/** @} */
1277
1278/** @name Print the value of a value box as a string
1279 *
1280 * @{
1281 */
1283 CC_HINT(nonnull(1,2));
1284
1286 CC_HINT(nonnull);
1287
1288static inline CC_HINT(nonnull(2,3))
1289 fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out,
1290 fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
1292
1293static inline CC_HINT(nonnull(2,3))
1295 fr_value_box_t const *data, fr_token_t quote)
1297
1298/** @} */
1299/** @name Hashing
1300 *
1301 * @{
1302 */
1304
1305/** @} */
1306
1307void fr_value_box_verify(char const *file, int line, fr_value_box_t const *vb)
1308 CC_HINT(nonnull(3));
1309void fr_value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list)
1310 CC_HINT(nonnull(3));
1311
1312#ifdef WITH_VERIFY_PTR
1313# define VALUE_BOX_VERIFY(_x) fr_value_box_verify(__FILE__, __LINE__, _x)
1314# define VALUE_BOX_LIST_VERIFY(_x) fr_value_box_list_verify(__FILE__, __LINE__, _x)
1315#else
1316/*
1317 * Even if were building without WITH_VERIFY_PTR
1318 * the pointer must not be NULL when these various macros are used
1319 * so we can add some sneaky asserts.
1320 */
1321# define VALUE_BOX_VERIFY(_x) fr_assert(_x)
1322# define VALUE_BOX_LIST_VERIFY(_x) fr_assert(_x)
1323# define VALUE_BOX_VERIFY(_x) fr_assert(_x)
1324# define VALUE_BOX_LIST_VERIFY(_x) fr_assert(_x)
1325#endif
1326
1327/** @name Debug functions
1328 *
1329 * @{
1330 */
1331void fr_value_box_list_debug(fr_value_box_list_t const *head);
1332void fr_value_box_debug(fr_value_box_t const *vb);
1333/** @} */
1334
1335#undef _CONST
1336
1337#ifdef __cplusplus
1338}
1339#endif
int const char * file
Definition acutest.h:702
static int const char * fmt
Definition acutest.h:573
int const char int line
Definition acutest.h:702
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:167
#define RCSIDH(h, id)
Definition build.h:486
#define unlikely(_x)
Definition build.h:383
#define NDEBUG_LOCATION_VALS
Definition build.h:264
#define NDEBUG_LOCATION_ARGS
Pass caller information to the function.
Definition build.h:263
static size_t min(size_t x, size_t y)
Definition dbuff.c:66
#define FR_DCURSOR_DLIST_TYPES(_name, _list_name, _element_type)
Define type specific wrapper structs for dcursors.
Definition dcursor.h:874
#define FR_DCURSOR_FUNCS(_name, _list_name, _element_type)
Define type specific wrapper functions for dcursors.
Definition dcursor.h:891
Test enumeration values.
Definition dict_test.h:92
#define FR_DLIST_TYPES(_name)
Define type specific wrapper structs for dlists.
Definition dlist.h:1129
#define FR_DLIST_FUNCS(_name, _element_type, _element_entry)
Define type specific wrapper functions for dlists.
Definition dlist.h:1152
#define FR_DLIST_TYPEDEFS(_name, _head, _entry)
Define friendly names for type specific dlist head and entry structures.
Definition dlist.h:1139
free(array)
Struct to represent an ethernet address.
Definition inet.h:45
Struct to represent an interface id.
Definition inet.h:54
IPv4/6 prefix.
talloc_free(reap)
unsigned short uint16_t
fr_type_t
@ FR_TYPE_FLOAT32
Single precision floating point.
@ FR_TYPE_IPV4_ADDR
32 Bit IPv4 Address.
@ FR_TYPE_INT8
8 Bit signed integer.
@ FR_TYPE_ETHERNET
48 Bit Mac-Address.
@ FR_TYPE_IPV6_PREFIX
IPv6 Prefix.
@ FR_TYPE_UINT16
16 Bit unsigned integer.
@ FR_TYPE_INT64
64 Bit signed integer.
@ FR_TYPE_INT16
16 Bit signed integer.
@ FR_TYPE_DATE
Unix time stamp, always has value >2^31.
@ FR_TYPE_COMBO_IP_PREFIX
IPv4 or IPv6 address prefix depending on length.
@ FR_TYPE_UINT8
8 Bit unsigned integer.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_INT32
32 Bit signed integer.
@ FR_TYPE_UINT64
64 Bit unsigned integer.
@ FR_TYPE_IPV6_ADDR
128 Bit IPv6 Address.
@ FR_TYPE_IPV4_PREFIX
IPv4 Prefix.
@ FR_TYPE_BOOL
A truth value.
@ FR_TYPE_COMBO_IP_ADDR
IPv4 or IPv6 address depending on length.
@ FR_TYPE_GROUP
A grouping of other attributes.
@ FR_TYPE_FLOAT64
Double precision floating point.
unsigned int uint32_t
long int ssize_t
unsigned char bool
unsigned char uint8_t
ssize_t fr_slen_t
#define UINT8_MAX
static char * secret
static char const * name
#define SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(_func,...)
#define SBUFF_OUT_TALLOC_FUNC_DEF(_func, _in, _len,...)
Set of parsing rules for *unescape_until functions.
PRIVATE void float64()
fr_aka_sim_id_type_t type
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
"Unix" time.
Definition time.h:95
enum fr_token fr_token_t
#define T_TOKEN_LAST
Definition token.h:129
static fr_slen_t head
Definition xlat.h:420
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
#define FR_TYPE_STRUCTURAL
Definition types.h:314
static char const * fr_type_to_str(fr_type_t type)
Return a static string containing the type name.
Definition types.h:452
fr_value_box_list_action_t
Actions to perform when we process a box in a list.
Definition value.h:233
@ FR_VALUE_BOX_LIST_NONE
Do nothing to processed boxes.
Definition value.h:234
@ FR_VALUE_BOX_LIST_REMOVE
Remove the box from the input list.
Definition value.h:235
@ FR_VALUE_BOX_LIST_FREE
Definition value.h:239
@ FR_VALUE_BOX_LIST_FREE_BOX_VALUE
Explicitly free any value buffers associated with a box.
Definition value.h:237
@ FR_VALUE_BOX_LIST_FREE_BOX
Free each processed box.
Definition value.h:236
size_t const fr_value_box_field_sizes[]
How many bytes wide each of the value data fields are.
Definition value.c:150
fr_sbuff_escape_rules_t fr_value_escape_double
Definition value.c:354
size_t fr_value_box_network_length(fr_value_box_t const *value)
Get the size of the value held by the fr_value_box_t.
Definition value.c:1380
int fr_value_box_vasprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted, char const *fmt, va_list ap)
int(* fr_value_box_escape_func_t)(fr_value_box_t *vb, void *uctx)
Escape a value box.
Definition value.h:673
fr_ifid_t ifid
IPv6 interface ID.
Definition value.h:124
void fr_value_box_debug(fr_value_box_t const *vb)
Print the value of a box as info messages.
Definition value.c:6892
uint16_t uint16
16bit unsigned integer.
Definition value.h:130
#define DEF_UNBOXING_FUNC(_ctype, _field, _type)
Definition value.h:953
fr_sbuff_escape_rules_t fr_value_escape_single
Definition value.c:392
uint32_t fr_value_box_hash(fr_value_box_t const *vb)
Hash the contents of a value box.
Definition value.c:6515
static int fr_value_box_memcpy_out(void *out, fr_value_box_t const *vb)
Copy the value of a value box to a field in a C struct.
Definition value.h:790
char * fr_value_box_list_aprint_secure(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules))
Concatenate the string representations of a list of value boxes together hiding "secret" values.
Definition value.c:6464
int fr_value_box_escape_in_place(fr_value_box_t *vb, fr_value_box_escape_t const *escape, void *uctx))
Escape a single value box in place.
Definition value.c:6318
int8_t int8
8bit signed integer.
Definition value.h:135
fr_sbuff_parse_rules_t const value_parse_rules_single_3quoted
Definition value.c:584
void fr_value_box_list_untaint(fr_value_box_list_t *head))
Untaint every list member (and their children)
Definition value.c:6603
static fr_slen_t fr_value_box_aprint(TALLOC_CTX *ctx, char **out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules) 1(fr_value_box_print
ssize_t fr_value_box_list_concat_as_string(fr_value_box_t *safety, fr_sbuff_t *sbuff, fr_value_box_list_t *list, char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules, fr_value_box_list_action_t proc_action, fr_value_box_safe_for_t safe_for, bool flatten))
Concatenate a list of value boxes together.
Definition value.c:5934
static bool fr_value_box_is_secret(fr_value_box_t const *box)
Definition value.h:1091
#define DEF_BOXING_FUNC(_ctype, _field, _type)
Definition value.h:857
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx, fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type, fr_value_box_list_action_t proc_action, bool flatten, size_t max_size))
Concatenate a list of value boxes.
Definition value.c:6150
fr_sbuff_parse_rules_t const value_parse_rules_double_unquoted
Definition value.c:488
size_t size
System specific file/memory size.
Definition value.h:148
fr_sbuff_parse_rules_t const value_parse_rules_solidus_quoted
Definition value.c:563
static fr_slen_t data
Definition value.h:1291
int fr_value_box_cast(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_value_box_t const *src))
Convert one type of fr_value_box_t to another.
Definition value.c:3671
static bool fr_value_box_contains_secret(fr_value_box_t const *box)
Definition value.h:1097
fr_value_box_list_t children
for groups
Definition value.h:153
int fr_value_box_copy(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src))
Copy value data verbatim duplicating any buffers.
Definition value.c:4086
int fr_value_box_bstrndup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted))
Definition value.c:4537
ssize_t fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, char const *in, size_t inlen, fr_sbuff_unescape_rules_t const *erules))
Definition value.c:5631
int fr_value_box_asprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted, char const *fmt,...)
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted))
Copy a nul terminated string to a fr_value_box_t.
Definition value.c:4292
static bool fr_value_box_list_len_min(fr_value_box_list_t const *list, unsigned int min)
Determines whether a list contains the number of boxes required.
Definition value.h:703
fr_type_t _CONST type
Type and flags should appear together for packing efficiency.
Definition value.h:191
ssize_t fr_value_box_from_substr(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv, fr_sbuff_t *in, fr_sbuff_parse_rules_t const *rules))
Convert string value to a fr_value_box_t type.
Definition value.c:5033
fr_sbuff_parse_rules_t const * value_parse_rules_unquoted_char[UINT8_MAX]
Definition value.c:520
fr_sbuff_parse_rules_t const * value_parse_rules_quoted[T_TOKEN_LAST]
Parse rules for quoted strings.
Definition value.c:610
static void fr_value_box_set_secret(fr_value_box_t *box, bool secret)
Definition value.h:1111
static fr_value_box_t * fr_value_box_acopy(TALLOC_CTX *ctx, fr_value_box_t const *src)
Copy an existing box, allocating a new box to hold its contents.
Definition value.h:737
static uint8_t * fr_value_box_raw(fr_value_box_t const *vb, fr_type_t type)
Return a pointer to the "raw" value from a value-box.
Definition value.h:766
float float32
Single precision float.
Definition value.h:140
int8_t fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b)
Compare two values.
Definition value.c:727
size_t const fr_value_box_offsets[]
Where the value starts in the fr_value_box_t.
Definition value.c:192
fr_sbuff_parse_rules_t const * value_parse_rules_quoted_char[UINT8_MAX]
Definition value.c:618
#define FR_VALUE_BOX_MAGIC
Definition value.h:91
int fr_value_box_mem_alloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted))
Pre-allocate an octets buffer for filling by the caller.
Definition value.c:4657
fr_sbuff_parse_rules_t const value_parse_rules_bareword_unquoted
Default formatting rules.
Definition value.c:484
int fr_value_box_strtrim(TALLOC_CTX *ctx, fr_value_box_t *vb))
Trim the length of the string buffer to match the length of the C string.
Definition value.c:4318
int fr_value_box_ipaddr(fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_ipaddr_t const *ipaddr, bool tainted))
Assign a fr_value_box_t value from an fr_ipaddr_t.
Definition value.c:3972
fr_sbuff_parse_rules_t const value_parse_rules_single_unquoted
Definition value.c:492
int fr_value_box_cmp_op(fr_token_t op, fr_value_box_t const *a, fr_value_box_t const *b)
Compare two attributes using an operator.
Definition value.c:984
unsigned int immutable
once set, the value cannot be changed
Definition value.h:195
fr_sbuff_unescape_rules_t fr_value_unescape_solidus
Definition value.c:300
void fr_value_box_list_taint(fr_value_box_list_t *head))
Taint every list member (and their children)
Definition value.c:6588
int fr_value_box_memdup_dbuff(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted))
Definition value.c:4779
fr_unix_time_t date
Date internal format in nanoseconds.
Definition value.h:143
uint64_t magic
Value to verify that the structure was allocated or initialised properly.
Definition value.h:214
fr_ipaddr_t ip
IPv4/6 address/prefix.
Definition value.h:122
fr_sbuff_parse_rules_t const value_parse_rules_single_quoted
Definition value.c:557
int32_t int32
32bit signed integer.
Definition value.h:137
int fr_value_box_mem_realloc(TALLOC_CTX *ctx, uint8_t **out, fr_value_box_t *dst, size_t len))
Change the length of a buffer already allocated to a value box.
Definition value.c:4690
fr_sbuff_unescape_rules_t * fr_value_unescape_by_char[UINT8_MAX+1]
Definition value.c:347
void fr_value_box_list_debug(fr_value_box_list_t const *head)
Print a list of value boxes as info messages.
Definition value.c:6845
fr_sbuff_escape_rules_t fr_value_escape_solidus
Definition value.c:402
void fr_value_box_memdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted))
Assign a buffer to a box, but don't copy it.
Definition value.c:4834
char const * file
File where the box was allocated or initialised.
Definition value.h:215
ssize_t fr_value_box_list_concat_as_octets(fr_value_box_t *safety, fr_dbuff_t *dbuff, fr_value_box_list_t *list, uint8_t const *sep, size_t sep_len, fr_value_box_list_action_t proc_action, bool flatten))
Concatenate a list of value boxes together.
Definition value.c:6050
void fr_value_box_increment(fr_value_box_t *vb)
Increment a boxed value.
Definition value.c:4880
fr_sbuff_escape_rules_t * fr_value_escape_by_quote[T_TOKEN_LAST]
Definition value.c:445
size_t fr_value_str_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
Convert a string value with escape sequences into its binary form.
Definition value.c:1180
int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted))
Copy a buffer to a fr_value_box_t.
Definition value.c:4754
static size_t char fr_sbuff_t size_t inlen
Definition value.h:1023
void fr_value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list))
Definition value.c:6678
fr_value_box_safe_for_t safe_for
Definition value.h:677
fr_sbuff_parse_rules_t const * value_parse_rules_3quoted[T_TOKEN_LAST]
Definition value.c:626
void fr_value_box_flatten(TALLOC_CTX *ctx, fr_value_box_list_t *list, bool steal, bool free))
Removes a single layer of nesting, moving all children into the parent list.
Definition value.c:6389
void fr_value_box_strdup_shallow_replace(fr_value_box_t *vb, char const *src, ssize_t len)
Free the existing buffer (if talloced) associated with the valuebox, and replace it with a new one.
Definition value.c:4417
void _fr_value_box_mark_safe_for(fr_value_box_t *box, fr_value_box_safe_for_t safe_for)
Mark a value-box as "safe", of a particular type.
Definition value.c:6686
void fr_value_box_clear_value(fr_value_box_t *data))
Clear/free any existing value.
Definition value.c:4023
ssize_t fr_value_box_from_network(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_type_t type, fr_dict_attr_t const *enumv, fr_dbuff_t *dbuff, size_t len, bool tainted))
Decode a fr_value_box_t from serialized binary data.
Definition value.c:1851
static int fr_value_box_memcpy_in(fr_value_box_t *vb, void const *in)
Copy a C value value to a value box.
Definition value.h:824
ssize_t fr_value_box_print_quoted(fr_sbuff_t *out, fr_value_box_t const *data, fr_token_t quote)
Print one boxed value to a string with quotes (where needed)
Definition value.c:5891
bool boolean
A truth value.
Definition value.h:127
fr_sbuff_parse_rules_t const value_parse_rules_double_3quoted
Definition value.c:578
static always_inline void _fr_value_box_init(NDEBUG_LOCATION_ARGS fr_value_box_t *vb, fr_type_t type, fr_dict_attr_t const *enumv, bool tainted)
Definition value.h:535
static size_t fr_value_str_aunescape(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t inlen, char quote) static inline size_t fr_value_substr_aunescape(TALLOC_CTX *ctx
fr_sbuff_escape_rules_t fr_value_escape_unprintables
Definition value.c:459
int line
Line where the box was allocated or initialised.
Definition value.h:216
bool fr_value_box_list_tainted(fr_value_box_list_t const *head))
Check to see if any list members (or their children) are tainted.
Definition value.c:6572
void fr_value_box_safety_copy_changed(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
Definition value.c:6748
fr_sbuff_escape_rules_t fr_value_escape_backtick
Definition value.c:423
fr_dict_attr_t const * enumv
Enumeration values.
Definition value.h:209
bool fr_value_box_is_truthy(fr_value_box_t const *box))
Check truthiness of values.
Definition value.c:6795
void fr_value_box_verify(char const *file, int line, fr_value_box_t const *vb))
Validation function to check that a fr_value_box_t is correctly initialised.
Definition value.c:6616
uintptr_t fr_value_box_safe_for_t
Escaping that's been applied to a value box.
Definition value.h:162
#define _CONST
Definition value.h:64
void fr_value_box_list_mark_safe_for(fr_value_box_list_t *list, fr_value_box_safe_for_t safe_for)
Set the escaped flag for all value boxes in a list.
Definition value.c:6717
fr_sbuff_escape_rules_t * fr_value_escape_by_char[UINT8_MAX+1]
Definition value.c:452
fr_sbuff_unescape_rules_t fr_value_unescape_backtick
Definition value.c:321
int fr_value_unbox_ipaddr(fr_ipaddr_t *dst, fr_value_box_t *src)
Unbox an IP address performing a type check.
Definition value.c:4004
int fr_value_box_cast_in_place(TALLOC_CTX *ctx, fr_value_box_t *vb, fr_type_t dst_type, fr_dict_attr_t const *dst_enumv))
Convert one type of fr_value_box_t to another in place.
Definition value.c:3914
fr_sbuff_parse_rules_t const value_parse_rules_bareword_quoted
Definition value.c:528
void fr_value_box_safety_merge(fr_value_box_t *out, fr_value_box_t const *in)
Merge safety results.
Definition value.c:6757
fr_sbuff_parse_rules_t const value_parse_rules_backtick_3quoted
Definition value.c:596
fr_value_box_entry_t entry
Doubly linked list entry.
Definition value.h:207
int fr_value_box_list_escape_in_place(fr_value_box_list_t *list, fr_value_box_escape_t const *escape, void *uctx))
Escape a list of value boxes in place.
Definition value.c:6369
fr_ethernet_t ether
Ethernet (MAC) address.
Definition value.h:125
unsigned int secret
Same as fr_dict_attr_flags_t secret.
Definition value.h:194
fr_sbuff_parse_rules_t const value_parse_rules_solidus_unquoted
Definition value.c:496
fr_sbuff_parse_rules_t const value_parse_rules_backtick_quoted
Definition value.c:569
fr_value_box_datum_t datum
The value held by the value box.
Definition value.h:211
fr_sbuff_parse_rules_t const * value_parse_rules_unquoted[T_TOKEN_LAST]
Parse rules for non-quoted strings.
Definition value.c:512
unsigned int talloced
Talloced, not stack or text allocated.
Definition value.h:196
double float64
Double precision float.
Definition value.h:141
int nonnull(2, 5))
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:654
uint64_t uint64
64bit unsigned integer.
Definition value.h:132
void fr_value_box_strdup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted))
Assign a buffer containing a nul terminated string to a box, but don't copy it.
Definition value.c:4401
fr_value_box_safe_for_t _CONST safe_for
A unique value to indicate if that value box is safe for consumption by a particular module for a par...
Definition value.h:200
fr_sbuff_unescape_rules_t fr_value_unescape_single
Definition value.c:289
int fr_value_box_bstrdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted))
Copy a nul terminated talloced buffer to a fr_value_box_t.
Definition value.c:4573
int fr_value_box_bstrdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted))
Assign a talloced buffer containing a nul terminated string to a box, but don't copy it.
Definition value.c:4618
static fr_slen_t static e_rules fr_slen_t fr_value_box_aprint_quoted(TALLOC_CTX *ctx, char **out, fr_value_box_t const *data, fr_token_t quote) 1(fr_value_box_print_quoted
void fr_value_box_safety_copy(fr_value_box_t *out, fr_value_box_t const *in)
Copy the safety values from one box to another.
Definition value.c:6735
unsigned int tainted
i.e. did it come from an untrusted source
Definition value.h:193
fr_sbuff_parse_rules_t const value_parse_rules_backtick_unquoted
Definition value.c:500
fr_sbuff_parse_rules_t const value_parse_rules_double_quoted
Definition value.c:551
void fr_value_box_memdup_buffer_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, bool tainted))
Assign a talloced buffer to a box, but don't copy it.
Definition value.c:4852
fr_sbuff_unescape_rules_t * fr_value_unescape_by_quote[T_TOKEN_LAST]
Definition value.c:340
static size_t char fr_sbuff_t * in
Definition value.h:1023
fr_sbuff_parse_rules_t const value_parse_rules_solidus_3quoted
Definition value.c:590
uint32_t uint32
32bit unsigned integer.
Definition value.h:131
int fr_value_box_bstr_realloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, size_t len))
Change the length of a buffer already allocated to a value box.
Definition value.c:4469
unsigned int edit
to control foreach / edits
Definition value.h:198
static size_t char fr_sbuff_t size_t char quote int fr_value_box_hton(fr_value_box_t *dst, fr_value_box_t const *src)
Performs byte order reversal for types that need it.
Definition value.c:1283
uint128_t uint128
128bit unsigned integer.
Definition value.h:133
int fr_value_box_to_key(uint8_t **out, size_t *outlen, fr_value_box_t const *value)
Get a key from a value box.
Definition value.c:2227
fr_value_box_escape_func_t func
Definition value.h:676
void fr_value_box_bstrndup_shallow(fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted))
Assign a string to to a fr_value_box_t.
Definition value.c:4597
int16_t int16
16bit signed integer.
Definition value.h:136
void fr_value_box_set_cursor(fr_value_box_t *dst, fr_type_t type, void *ptr, char const *name)
Definition value.c:4865
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted))
Copy a string to to a fr_value_box_t.
Definition value.c:4513
ssize_t fr_value_box_to_network(fr_dbuff_t *dbuff, fr_value_box_t const *value)
Encode a single value box, serializing its contents in generic network format.
Definition value.c:1459
void fr_value_box_copy_shallow(TALLOC_CTX *ctx, fr_value_box_t *dst, const fr_value_box_t *src))
Perform a shallow copy of a value_box.
Definition value.c:4201
static always_inline int fr_value_box_ethernet_addr(fr_value_box_t *dst, fr_dict_attr_t const *enumv, fr_ethernet_t const *src, bool tainted)
Definition value.h:849
char * fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim, fr_sbuff_escape_rules_t const *e_rules))
Concatenate the string representations of a list of value boxes together.
Definition value.c:6414
static fr_value_box_t * _fr_value_box_alloc(NDEBUG_LOCATION_ARGS TALLOC_CTX *ctx, fr_type_t type, fr_dict_attr_t const *enumv)
Definition value.h:618
static int fr_value_unbox_ethernet_addr(fr_ethernet_t *dst, fr_value_box_t *src)
Unbox an ethernet value (6 bytes, network byte order)
Definition value.h:941
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:609
void fr_value_box_clear(fr_value_box_t *data))
Clear/free any existing value and metadata.
Definition value.c:4069
void fr_value_box_mark_unsafe(fr_value_box_t *box)
Mark a value-box as "unsafe".
Definition value.c:6705
uint8_t uint8
8bit unsigned integer.
Definition value.h:129
fr_sbuff_unescape_rules_t fr_value_unescape_double
Definition value.c:270
int fr_value_box_memdup_buffer(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, bool tainted))
Copy a talloced buffer to a fr_value_box_t.
Definition value.c:4812
fr_dict_attr_t const *_CONST da
dictionary reference
Definition value.h:151
int format(printf, 5, 0))
size_t fr_value_substr_unescape(fr_sbuff_t *out, fr_sbuff_t *in, size_t inlen, char quote)
Convert a string value with escape sequences into its binary form.
Definition value.c:1253
fr_sbuff_escape_rules_t fr_value_escape_secret
Escape secret fields by simply mashing all data to '.
Definition value.c:385
static size_t char ** out
Definition value.h:1023
int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in))
Do a full copy of a list of value boxes.
Definition value.c:6544
ssize_t fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules))
Print one boxed value to a string.
Definition value.c:5668
int fr_value_box_bstr_alloc(TALLOC_CTX *ctx, char **out, fr_value_box_t *dst, fr_dict_attr_t const *enumv, size_t len, bool tainted))
Alloc and assign an empty \0 terminated string to a fr_value_box_t.
Definition value.c:4436
fr_time_delta_t time_delta
a delta time in nanoseconds
Definition value.h:149
int64_t int64
64bit signed integer;
Definition value.h:138
int fr_value_box_steal(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_t *src))
Copy value data verbatim moving any buffers to the specified context.
Definition value.c:4225
Union containing all data types supported by the server.
Definition value.h:188