The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
sbuff.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/** A generic buffer structure for string printing and parsing strings
19 *
20 * Because doing manual length checks is error prone and a waste of everyones time.
21 *
22 * @file src/lib/util/sbuff.h
23 *
24 * @copyright 2020 Arran Cudbard-Bell <a.cudbardb@freeradius.org>
25 */
26RCSIDH(sbuff_h, "$Id: 0f226f9915e15ff2e43ca49e8ef79d8a4f58b168 $")
27
28# ifdef __cplusplus
29extern "C" {
30# endif
31
32#include <ctype.h>
33#include <errno.h>
34#include <limits.h>
35#include <stdbool.h>
36#include <stdint.h>
37#include <stdio.h>
38#include <string.h>
39#include <sys/types.h>
40
41/** Represents number of bytes parsed or location of parse error
42 *
43 * Number of bytes parsed will be >= 0.
44 *
45 * If a parse error occurs the value will be the negative offset
46 * of the error -1. i.e. offset 0 will be -1.
47 *
48 * This is to disambiguate between 0 bytes parsed and error at
49 * offset 0.
50 */
51typedef ssize_t fr_slen_t;
52typedef struct fr_sbuff_s fr_sbuff_t;
53typedef struct fr_sbuff_ptr_s fr_sbuff_marker_t;
54
55#include <freeradius-devel/util/atexit.h>
56#include <freeradius-devel/util/strerror.h>
57#include <freeradius-devel/util/table.h>
58#include <freeradius-devel/util/talloc.h>
59
60/** Whether the buffer is currently extendable and whether it was extended
61 *
62 */
63DIAG_OFF(attributes)
64typedef enum CC_HINT(flag_enum) {
65 FR_SBUFF_FLAG_EXTENDED = 0x01, //!< The last call to extend function actually extended the buffer.
66 FR_SBUFF_FLAG_EXTEND_ERROR = 0x02 //!< The last call to an extend function resulted in an error.
67 ///< Error should be provided using fr_strerror_const/fr_strerror_printf
68 ///< by the extension function.
69} fr_sbuff_extend_status_t;
70DIAG_OFF(attributes)
71
72/** Extension callback
73 *
74 * Retrieves additional data from a source and adds it to a buffer.
75 */
76typedef size_t(*fr_sbuff_extend_t)(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t req_extension);
77
78/** For a given extension function, returns whether it is at EOF
79 *
80 */
81typedef bool(*fr_sbuff_eof_t)(fr_sbuff_t *sbuff);
82
83
84struct fr_sbuff_ptr_s {
85 union {
86 char const *p_i; //!< Immutable position pointer.
87 char *p; //!< Mutable position pointer.
88 };
89 fr_sbuff_marker_t *next; //!< Next m in the list.
90 fr_sbuff_t *parent; //!< Owner of the marker
91};
92
93struct fr_sbuff_s {
94 union {
95 char const *buff_i; //!< Immutable buffer pointer.
96 char *buff; //!< Mutable buffer pointer.
97 };
98
99 union {
100 char const *start_i; //!< Immutable start pointer.
101 char *start; //!< Mutable start pointer.
102 };
103
104 union {
105 char const *end_i; //!< Immutable end pointer.
106 char *end; //!< Mutable end pointer.
107 };
108
109 union {
110 char const *p_i; //!< Immutable position pointer.
111 char *p; //!< Mutable position pointer.
112 };
113
114 char const *err; //!< Where the last error occurred.
115
116 uint8_t is_const:1; //!< Can't be modified.
117 uint8_t adv_parent:1; //!< If true, advance the parent.
118 size_t shifted; //!< How many bytes this sbuff has been
119 ///< shifted since its creation.
120
121 fr_sbuff_extend_t extend; //!< Function to re-populate or extend
122 ///< the buffer.
123
124 fr_sbuff_eof_t eof; //!< Function to determine if the buffer is at EOF.
125
126 void *uctx; //!< Extend uctx data.
127
128 fr_sbuff_t *parent; //!< sbuff this sbuff was copied from.
129
130 fr_sbuff_marker_t *m; //!< Pointers to update if the underlying
131 ///< buffer changes.
132};
133
134/** Talloc sbuff extension structure
135 *
136 * Holds the data necessary for creating dynamically
137 * extensible buffers.
138 */
139typedef struct {
140 TALLOC_CTX *ctx; //!< Context to alloc new buffers in.
141 size_t init; //!< How much to allocate initially.
142 size_t max; //!< Maximum size of the buffer.
143} fr_sbuff_uctx_talloc_t;
144
145/** File sbuff extension structure
146 *
147 * Holds the data necessary for creating dynamically
148 * extensible file buffers.
149 */
150typedef struct {
151 FILE *file; //!< FILE * we're reading from.
152 char *buff_end; //!< The true end of the buffer.
153 size_t max; //!< Maximum number of bytes to read.
154 size_t shifted; //!< How much we've read from this file.
155 bool eof; //!< are we at EOF?
156} fr_sbuff_uctx_file_t;
157
158/** Terminal element with pre-calculated lengths
159 *
160 */
161typedef struct {
162 char const *str; //!< Terminal string
163 size_t len; //!< Length of string
164} fr_sbuff_term_elem_t;
165
166/** Set of terminal elements
167 *
168 * The elements MUST be listed in sorted order. If the inputs are
169 * not sorted, then all kinds of things will break.
170 */
171typedef struct {
172 size_t len; //!< Length of the list.
173 fr_sbuff_term_elem_t *elem; //!< A sorted list of terminal strings.
174} fr_sbuff_term_t;
175
176/** Initialise a terminal structure with a single string
177 *
178 * @param[in] _str terminal string.
179 */
180#define FR_SBUFF_TERM(_str) \
181(fr_sbuff_term_t){ \
182 .len = 1, \
183 .elem = (fr_sbuff_term_elem_t[]){ L(_str) }, \
184}
185
186/** Initialise a terminal structure with a list of sorted strings
187 *
188 * Strings must be lexicographically sorted.
189 *
190 * @param[in] ... Lexicographically sorted list of terminal strings.
191 */
192#define FR_SBUFF_TERMS(...) \
193(fr_sbuff_term_t){ \
194 .len = (sizeof((fr_sbuff_term_elem_t[]){ __VA_ARGS__ }) / sizeof(fr_sbuff_term_elem_t)), \
195 .elem = (fr_sbuff_term_elem_t[]){ __VA_ARGS__ }, \
196}
197
198/** Set of parsing rules for *unescape_until functions
199 *
200 */
201typedef struct {
202 char const *name; //!< Name for rule set to aid we debugging.
203
204 char chr; //!< Character at the start of an escape sequence.
205 char subs[UINT8_MAX + 1]; //!< Special characters and their substitutions.
206 ///< Indexed by the printable representation i.e.
207 ///< 'n' for \n.
208 bool skip[UINT8_MAX + 1]; //!< Characters that are escaped, but left in the
209 ///< output along with the escape character.
210 ///< This is useful where we need to interpret escape
211 ///< sequences for parsing, but where the string will
212 ///< be passed off to a 3rd party library which will
213 ///< need to interpret the same sequences.
214
215 bool do_hex; //!< Process hex sequences i.e. @verbatim\x<hex><hex>.@endverbatim
216 bool do_oct; //!< Process oct sequences i.e. @verbatim<oct><oct><oct>.@endverbatim
217} fr_sbuff_unescape_rules_t;
218
219/** Set of parsing rules for *unescape_until functions
220 *
221 */
222typedef struct {
223 char const *name; //!< Name for rule set to aid we debugging.
224
225 char chr; //!< Character at the start of an escape sequence.
226
227 char subs[UINT8_MAX + 1]; //!< Special characters and their substitutions.
228 ///< Indexed by the binary representation i.e.
229 ///< 0x0a for \n.
230 bool esc[UINT8_MAX + 1]; //!< Characters that should be translated to hex or
231 ///< octal escape sequences.
232 bool do_utf8; //!< If true Don't apply escaping rules to valid UTF-8 sequences.
233
234 bool do_hex; //!< Represent escaped chars as hex sequences i.e.
235 ///< @verbatim\x<hex><hex>@endverbatim
236 bool do_oct; //!< Represent escapes chars as octal sequences i.e.
237 ///< @verbatim<oct><oct><oct>@endvertbatim
238} fr_sbuff_escape_rules_t;
239
240/** A set of terminal sequences, and escape rules
241 *
242 */
243typedef struct {
244 fr_sbuff_unescape_rules_t const *escapes; //!< Escape characters
245
246 fr_sbuff_term_t const *terminals; //!< Terminal characters used as a hint
247 ///< that a token is not complete.
248} fr_sbuff_parse_rules_t;
249
250/** Standard parsing errors to be used by sbuff functions and other sbuff based parsing functions
251 *
252 */
253typedef enum {
254 FR_SBUFF_PARSE_OK = 0, //!< No error.
255 FR_SBUFF_PARSE_ERROR_NOT_FOUND = -1, //!< String does not contain a token
256 ///< matching the output type.
257 FR_SBUFF_PARSE_ERROR_TRAILING = -2, //!< Trailing characters found.
258 FR_SBUFF_PARSE_ERROR_FORMAT = -3, //!< Format of data was invalid.
259 FR_SBUFF_PARSE_ERROR_OUT_OF_SPACE = -4, //!< No space available in output buffer.
260 FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW = -5, //!< Integer type would overflow.
261 FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW = -6 //!< Integer type would underflow.
262} fr_sbuff_parse_error_t;
263
264extern fr_table_num_ordered_t const sbuff_parse_error_table[];
265extern size_t sbuff_parse_error_table_len;
266
267/** Replace the contents of the thread local error stack with the string representation of a parse error
268 */
269static inline void fr_sbuff_parse_error_to_strerror(fr_sbuff_parse_error_t err)
270{
271 fr_strerror_const(fr_table_str_by_value(sbuff_parse_error_table, err, "<INVALID>"));
272}
273
274/** Return whether the sbuff is extendable
275 */
276static inline bool fr_sbuff_is_extendable(fr_sbuff_t *sbuff)
277{
278 return sbuff->extend && (!sbuff->eof || (sbuff->eof(sbuff) == false));
279}
280
281#define fr_sbuff_was_extended(_status) (_status & FR_SBUFF_FLAG_EXTENDED)
282
283extern bool const sbuff_char_class_uint[UINT8_MAX + 1];
284extern bool const sbuff_char_class_int[UINT8_MAX + 1];
285extern bool const sbuff_char_class_float[UINT8_MAX + 1];
286extern bool const sbuff_char_class_zero[UINT8_MAX + 1];
287extern bool const sbuff_char_class_hex[UINT8_MAX + 1];
288extern bool const sbuff_char_alpha_num[UINT8_MAX + 1];
289extern bool const sbuff_char_word[UINT8_MAX + 1];
290extern bool const sbuff_char_whitespace[UINT8_MAX + 1];
291extern bool const sbuff_char_line_endings[UINT8_MAX + 1];
292extern bool const sbuff_char_blank[UINT8_MAX + 1];
293extern bool const sbuff_char_class_hostname[UINT8_MAX + 1];
294
295/** Matches a-z,A-Z
296 */
297#define SBUFF_CHAR_CLASS_ALPHA \
298 ['a'] = true, ['b'] = true, ['c'] = true, ['d'] = true, ['e'] = true, \
299 ['f'] = true, ['g'] = true, ['h'] = true, ['i'] = true, ['j'] = true, \
300 ['k'] = true, ['l'] = true, ['m'] = true, ['n'] = true, ['o'] = true, \
301 ['p'] = true, ['q'] = true, ['r'] = true, ['s'] = true, ['t'] = true, \
302 ['u'] = true, ['v'] = true, ['w'] = true, ['x'] = true, ['y'] = true, \
303 ['z'] = true, \
304 ['A'] = true, ['B'] = true, ['C'] = true, ['D'] = true, ['E'] = true, \
305 ['F'] = true, ['G'] = true, ['H'] = true, ['I'] = true, ['J'] = true, \
306 ['K'] = true, ['L'] = true, ['M'] = true, ['N'] = true, ['O'] = true, \
307 ['P'] = true, ['Q'] = true, ['R'] = true, ['S'] = true, ['T'] = true, \
308 ['U'] = true, ['V'] = true, ['W'] = true, ['X'] = true, ['Y'] = true, \
309 ['Z'] = true
310
311/** Matches 0-9
312 */
313#define SBUFF_CHAR_CLASS_NUM \
314 ['0'] = true, ['1'] = true, ['2'] = true, ['3'] = true, ['4'] = true, \
315 ['5'] = true, ['6'] = true, ['7'] = true, ['8'] = true, ['9'] = true
316
317/** Matches 0-9,a-z,A-Z
318 */
319#define SBUFF_CHAR_CLASS_ALPHA_NUM \
320 SBUFF_CHAR_CLASS_ALPHA, \
321 SBUFF_CHAR_CLASS_NUM
322
323/** Matches 0-9,a-f,A-F
324 */
325#define SBUFF_CHAR_CLASS_HEX \
326 SBUFF_CHAR_CLASS_NUM, \
327 ['a'] = true, ['b'] = true, ['c'] = true, ['d'] = true, ['e'] = true, \
328 ['f'] = true, \
329 ['A'] = true, ['B'] = true, ['C'] = true, ['D'] = true, ['E'] = true, \
330 ['F'] = true
331
332#define SBUFF_CHAR_CLASS_SYMBOLS \
333 ['!'] = true, ['"'] = true, ['#'] = true, ['$'] = true, ['%'] = true, \
334 ['&'] = true, ['/'] = true, ['('] = true, [')'] = true, ['*'] = true, \
335 ['+'] = true, ['`'] = true, ['-'] = true, ['.'] = true, ['/'] = true, \
336 [':'] = true, [';'] = true, ['<'] = true, ['='] = true, ['>'] = true, \
337 ['?'] = true, ['@'] = true, ['['] = true, ['\''] = true, [']'] = true, \
338 ['^'] = true, ['_'] = true, ['`'] = true, ['{'] = true, ['|'] = true, \
339 ['}'] = true, ['~'] = true \
340
341/*
342 * If the additional tables need to be generated feel free to use this
343 * code snippet.
344 *
345 * @verbatim
346 #include <stdio.h>
347 #include <stdlib.h>
348
349 int main(int argc, char **argv)
350 {
351 int start, end, i;
352 start = atoi(argv[1]);
353 end = atoi(argv[2]);
354 for (i = start; i <= end; i++) {
355 printf("[0x%02x] = true, ", i);
356 if (!(i % 8)) printf("\\\n");
357 }
358 return 0;
359 }
360 * @endverbatim
361 */
362
363/** Unprintables (ascii range)
364 *
365 * We don't include characters in the extended range (128-255) as they're
366 * likely part of a multi-byte sequence and we don't want to break UTF8 strings.
367 */
368#define SBUFF_CHAR_UNPRINTABLES_LOW \
369 [0x00] = true, \
370 [0x01] = true, [0x02] = true, [0x03] = true, [0x04] = true, [0x05] = true, [0x06] = true, [0x07] = true, [0x08] = true, \
371 [0x09] = true, [0x0a] = true, [0x0b] = true, [0x0c] = true, [0x0d] = true, [0x0e] = true, [0x0f] = true, [0x10] = true, \
372 [0x11] = true, [0x12] = true, [0x13] = true, [0x14] = true, [0x15] = true, [0x16] = true, [0x17] = true, [0x18] = true, \
373 [0x19] = true, [0x1a] = true, [0x1b] = true, [0x1c] = true, [0x1d] = true, [0x1e] = true, [0x1f] = true, \
374 [0x7f] = true
375
376/** Unprintables (extended range)
377 *
378 * If these characters are being escaped, the function should also be passed
379 * the 'do_utf8' flag.
380 */
381#define SBUFF_CHAR_UNPRINTABLES_EXTENDED \
382 [0x80] = true, \
383 [0x81] = true, [0x82] = true, [0x83] = true, [0x84] = true, [0x85] = true, [0x86] = true, [0x87] = true, [0x88] = true, \
384 [0x89] = true, [0x8a] = true, [0x8b] = true, [0x8c] = true, [0x8d] = true, [0x8e] = true, [0x8f] = true, [0x90] = true, \
385 [0x91] = true, [0x92] = true, [0x93] = true, [0x94] = true, [0x95] = true, [0x96] = true, [0x97] = true, [0x98] = true, \
386 [0x99] = true, [0x9a] = true, [0x9b] = true, [0x9c] = true, [0x9d] = true, [0x9e] = true, [0x9f] = true, [0xa0] = true, \
387 [0xa1] = true, [0xa2] = true, [0xa3] = true, [0xa4] = true, [0xa5] = true, [0xa6] = true, [0xa7] = true, [0xa8] = true, \
388 [0xa9] = true, [0xaa] = true, [0xab] = true, [0xac] = true, [0xad] = true, [0xae] = true, [0xaf] = true, [0xb0] = true, \
389 [0xb1] = true, [0xb2] = true, [0xb3] = true, [0xb4] = true, [0xb5] = true, [0xb6] = true, [0xb7] = true, [0xb8] = true, \
390 [0xb9] = true, [0xba] = true, [0xbb] = true, [0xbc] = true, [0xbd] = true, [0xbe] = true, [0xbf] = true, [0xc0] = true, \
391 [0xc1] = true, [0xc2] = true, [0xc3] = true, [0xc4] = true, [0xc5] = true, [0xc6] = true, [0xc7] = true, [0xc8] = true, \
392 [0xc9] = true, [0xca] = true, [0xcb] = true, [0xcc] = true, [0xcd] = true, [0xce] = true, [0xcf] = true, [0xd0] = true, \
393 [0xd1] = true, [0xd2] = true, [0xd3] = true, [0xd4] = true, [0xd5] = true, [0xd6] = true, [0xd7] = true, [0xd8] = true, \
394 [0xd9] = true, [0xda] = true, [0xdb] = true, [0xdc] = true, [0xdd] = true, [0xde] = true, [0xdf] = true, [0xe0] = true, \
395 [0xe1] = true, [0xe2] = true, [0xe3] = true, [0xe4] = true, [0xe5] = true, [0xe6] = true, [0xe7] = true, [0xe8] = true, \
396 [0xe9] = true, [0xea] = true, [0xeb] = true, [0xec] = true, [0xed] = true, [0xee] = true, [0xef] = true, [0xf0] = true, \
397 [0xf1] = true, [0xf2] = true, [0xf3] = true, [0xf4] = true, [0xf5] = true, [0xf6] = true, [0xf7] = true, [0xf8] = true, \
398 [0xf9] = true, [0xfa] = true, [0xfb] = true, [0xfc] = true, [0xfd] = true, [0xfe] = true, [0xff] = true
399
400/** Generic wrapper macro to return if there's insufficient memory to satisfy the request on the sbuff
401 *
402 */
403#define FR_SBUFF_RETURN(_func, _sbuff, ...) \
404do { \
405 ssize_t _slen; \
406 _slen = _func(_sbuff, ## __VA_ARGS__ ); \
407 if (_slen < 0) return _slen; \
408} while (0)
409
410/** @name Ephemeral copying macros
411 * @{
412 */
413
414/** @cond */
415
416/** Copy another fr_sbuff_t, modifying it.
417 *
418 * @private
419 */
420#define _FR_SBUFF(_sbuff_or_marker, _start, _current, _end, _extend, _eof, _adv_parent) \
421((fr_sbuff_t){ \
422 .buff = fr_sbuff_buff(_sbuff_or_marker), \
423 .start = (_start), \
424 .end = (_end), \
425 .p = (_current), \
426 .is_const = fr_sbuff_ptr(_sbuff_or_marker)->is_const, \
427 .adv_parent = (_adv_parent), \
428 .shifted = 0, \
429 .extend = (_extend), \
430 .eof = (_eof), \
431 .uctx = fr_sbuff_ptr(_sbuff_or_marker)->uctx, \
432 .parent = fr_sbuff_ptr(_sbuff_or_marker) \
433})
434/* @endcond */
435
436/** Create a new sbuff pointing to the same underlying buffer
437 *
438 * - Parent will _NOT_ be advanced by operations on its child.
439 * - Child will have its `start` pointer set to the `p` pointer of the parent.
440 *
441 * @param[in] _sbuff_or_marker to make an ephemeral copy of.
442 */
443#define FR_SBUFF(_sbuff_or_marker) _FR_SBUFF(_sbuff_or_marker, \
444 fr_sbuff_current(_sbuff_or_marker), \
445 fr_sbuff_current(_sbuff_or_marker), \
446 fr_sbuff_end(_sbuff_or_marker), \
447 fr_sbuff_ptr(_sbuff_or_marker)->extend, \
448 fr_sbuff_ptr(_sbuff_or_marker)->eof, \
449 0x00)
450
451/** Create a new sbuff pointing to the same underlying buffer
452 *
453 * - Parent will _NOT_ be advanced by operations on its child.
454 * - Child will have its `start` pointer set to the `start` pointer of the parent.
455 *
456 * @param[in] _sbuff_or_marker to make an ephemeral copy of.
457 */
458#define FR_SBUFF_ABS(_sbuff_or_marker) _FR_SBUFF(_sbuff_or_marker, \
459 fr_sbuff_start(_sbuff_or_marker), \
460 fr_sbuff_current(_sbuff_or_marker), \
461 fr_sbuff_end(_sbuff_or_marker), \
462 fr_sbuff_ptr(_sbuff_or_marker)->extend, \
463 0x00)
464
465/** Create a new sbuff pointing to the same underlying buffer
466 *
467 * The intent of this sbuff type is to allow parsing operations to be performed
468 * on a subset of the buffer data.
469 *
470 * - Parent will _NOT_ be advanced by operations on its child.
471 * - Child will have its `start` pointer set to the `start` pointer of the parent.
472 * - Child will have its `end` pointer set to the `p` pointer of the parent.
473 * - Child will not extend parent.
474 *
475 * @param[in] _sbuff_or_marker to make an ephemeral copy of.
476 */
477#define FR_SBUFF_REPARSE(_sbuff_or_marker) _FR_SBUFF(_sbuff_or_marker, \
478 fr_sbuff_start(_sbuff_or_marker), \
479 fr_sbuff_start(_sbuff_or_marker), \
480 fr_sbuff_current(_sbuff_or_marker), \
481 NULL, \
482 NULL, \
483 0x00)
484
485/** Create a new sbuff pointing to the same underlying buffer
486 *
487 * - Parent `p` pointer will be advanced with child's `p` pointer.
488 * - Child will have its `start` pointer set to the `p` pointer of the parent.
489 *
490 * @param[in] _sbuff_or_marker to make an ephemeral copy of.
491 */
492#define FR_SBUFF_BIND_CURRENT(_sbuff_or_marker) _FR_SBUFF(_sbuff_or_marker, \
493 fr_sbuff_current(_sbuff_or_marker), \
494 fr_sbuff_current(_sbuff_or_marker), \
495 fr_sbuff_end(_sbuff_or_marker), \
496 fr_sbuff_ptr(_sbuff_or_marker)->extend, \
497 fr_sbuff_ptr(_sbuff_or_marker)->eof, \
498 0x01)
499
500/** Create a new sbuff pointing to the same underlying buffer
501 *
502 * - Parent `p` pointer will be advanced with child's `p` pointer.
503 * - Child will have its `start` pointer set to the `start` pointer of the parent.
504 *
505 * @param[in] _sbuff_or_marker to make an ephemeral copy of.
506 */
507#define FR_SBUFF_BIND_CURRENT_ABS(_sbuff_or_marker) FR_SBUFF_ABS(_sbuff_or_marker, \
508 fr_sbuff_start(_sbuff_or_marker), \
509 fr_sbuff_current(_sbuff_or_marker), \
510 fr_sbuff_end(_sbuff_or_marker), \
511 fr_sbuff_ptr(_sbuff_or_marker)->extend, \
512 fr_sbuff_ptr(_sbuff_or_marker)->eof, \
513 0x01)
514
515/** Creates an empty sbuff which can then be used as a destination for printing
516 *
517 * @note The return value of the function should be used to determine how much
518 * data was written to the buffer.
519 *
520 * @param[in] _start of the buffer.
521 * @param[in] _len_or_end Length of the buffer or the end pointer.
522 */
523#define FR_SBUFF_OUT(_start, _len_or_end) \
524((fr_sbuff_t){ \
525 .buff_i = _start, \
526 .start_i = _Generic((_start), \
527 char * : _start, \
528 uint8_t * : _start \
529 ), \
530 .end_i = _Generic((_len_or_end), \
531 size_t : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
532 long : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
533 int : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
534 unsigned int : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
535 char * : (char const *)(_len_or_end), \
536 char const * : (char const *)(_len_or_end) \
537 ), \
538 .p_i = _start, \
539 .is_const = false, \
540})
541
542/** Creates an sbuff from existing data, so the caller can read from it.
543 *
544 * @note The return value of the function should be used to determine how much
545 * data was written to the buffer.
546 *
547 * @param[in] _start of the buffer.
548 * @param[in] _len_or_end Length of the buffer or the end pointer.
549 */
550#define FR_SBUFF_IN(_start, _len_or_end) \
551((fr_sbuff_t){ \
552 .buff_i = _start, \
553 .start_i = _Generic((_start), \
554 char * : _start, \
555 char const * : _start, \
556 uint8_t * : _start, \
557 uint8_t const * : _start \
558 ), \
559 .end_i = _Generic((_len_or_end), \
560 size_t : (char const *)(_start) + (size_t)(_len_or_end), \
561 long : (char const *)(_start) + (size_t)(_len_or_end), \
562 int : (char const *)(_start) + (size_t)(_len_or_end), \
563 unsigned int : (char const *)(_start) + (size_t)(_len_or_end), \
564 char * : (char const *)(_len_or_end), \
565 char const * : (char const *)(_len_or_end) \
566 ), \
567 .p_i = _start, \
568 .is_const = true, \
569})
570
571#define FR_SBUFF_IN_STR(_start) FR_SBUFF_IN(_start, strlen(_start))
572
573/** Structure to encapsulate a thread local sbuff information
574 *
575 */
576typedef struct {
577 fr_sbuff_t sbuff; //!< Thread local sbuff.
578 fr_sbuff_uctx_talloc_t tctx; //!< Thread local tctx.
579} fr_sbuff_thread_local_t;
580
581static inline int _sbuff_thread_local_free(void *sbtl)
582{
583 return talloc_free(sbtl);
584}
585
586/** Create a function local and thread local extensible sbuff
587 *
588 * @param[out] _sbuff_out Where to write a pointer to the thread local sbuff
589 * @param[in] _init Initial size for the sbuff buffer.
590 * @param[in] _max Maximum size of the sbuff buffer.
591 */
592#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max) \
593do { \
594 static _Thread_local fr_sbuff_thread_local_t *_sbuff_t_local; \
595 if (!_sbuff_t_local) { \
596 fr_sbuff_thread_local_t *sbtl = talloc_zero(NULL, fr_sbuff_thread_local_t); \
597 fr_sbuff_init_talloc(sbtl, &sbtl->sbuff, &sbtl->tctx, _init, _max); \
598 fr_atexit_thread_local(_sbuff_t_local, _sbuff_thread_local_free, sbtl); \
599 *(_out) = &_sbuff_t_local->sbuff; \
600 } else { \
601 fr_sbuff_reset_talloc(&_sbuff_t_local->sbuff); \
602 *(_out) = &_sbuff_t_local->sbuff; \
603 } \
604} while (0)
605
606void fr_sbuff_update(fr_sbuff_t *sbuff, char *new_buff, size_t new_len);
607
608size_t fr_sbuff_shift(fr_sbuff_t *sbuff, size_t shift, bool move_end);
609
610size_t fr_sbuff_extend_file(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t extension);
611
612bool fr_sbuff_eof_file(fr_sbuff_t *sbuff);
613
614size_t fr_sbuff_extend_talloc(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t extension);
615
616int fr_sbuff_trim_talloc(fr_sbuff_t *sbuff, size_t len);
617
618int fr_sbuff_reset_talloc(fr_sbuff_t *sbuff);
619
620static inline void fr_sbuff_terminate(fr_sbuff_t *sbuff)
621{
622 *sbuff->p = '\0';
623}
624
625static inline void _fr_sbuff_init(fr_sbuff_t *out, char const *start, char const *end, bool is_const)
626{
627 if (unlikely(end < start)) end = start; /* Could be an assert? */
628
629 *out = (fr_sbuff_t){
630 .buff_i = start,
631 .start_i = start,
632 .p_i = start,
633 .end_i = end,
634 .is_const = is_const
635 };
636}
637
638/*
639 * GCC is stupid and will warn about output variables
640 * being unnitialised, even if they're not dereferenced.
641 */
642#if defined(__GNUC__) && __GNUC__ >= 11
643DIAG_OFF(maybe-uninitialized)
644#endif
645
646/** Initialise an sbuff around a stack allocated buffer for printing
647 *
648 * Will \0 terminate the output buffer.
649 *
650 * @param[out] _out Pointer to buffer.
651 * @param[in] _start Start of the buffer. Cannot be const.
652 * @param[in] _len_or_end Either an end pointer or the length
653 * of the buffer. 'end' can be const.
654 */
655#define fr_sbuff_init_out(_out, _start, _len_or_end) \
656do { \
657 *(_start) = '\0'; \
658 _fr_sbuff_init(_out, _start, \
659 _Generic((_len_or_end), \
660 size_t : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
661 long : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
662 int : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
663 char * : (char const *)(_len_or_end), \
664 char const * : (char const *)(_len_or_end) \
665 ), \
666 false); \
667} while (0)
668
669#if defined(__GNUC__) && __GNUC__ >= 11
670DIAG_ON(maybe-uninitialized)
671#endif
672
673/** Initialise an sbuff around a stack allocated buffer for parsing
674 *
675 * @param[out] _out Pointer to buffer.
676 * @param[in] _start Start of the buffer.
677 * @param[in] _len_or_end Either an end pointer or the length
678 * of the buffer.
679 */
680#define fr_sbuff_init_in(_out, _start, _len_or_end) \
681_fr_sbuff_init(_out, _start, \
682_Generic((_len_or_end), \
683 size_t : (char const *)(_start) + (size_t)(_len_or_end), \
684 long : (char const *)(_start) + (size_t)(_len_or_end), \
685 int : (char const *)(_start) + (size_t)(_len_or_end), \
686 char * : (char const *)(_len_or_end), \
687 char const * : (char const *)(_len_or_end) \
688), \
689IS_CONST(char *, _start))
690
691/** Initialise a special sbuff which automatically reads in more data as the buffer is exhausted
692 *
693 * @param[out] sbuff to initialise.
694 * @param[out] fctx to initialise. Must have a lifetime >= to the sbuff.
695 * @param[in] buff Temporary buffer to use for storing file contents.
696 * @param[in] len Length of the temporary buffer.
697 * @param[in] file to read from.
698 * @param[in] max The maximum length of data to read from the file.
699 * @return
700 * - The passed sbuff on success.
701 * - NULL on failure.
702 */
703static inline fr_sbuff_t *fr_sbuff_init_file(fr_sbuff_t *sbuff, fr_sbuff_uctx_file_t *fctx,
704 char *buff, size_t len, FILE *file, size_t max)
705{
706 *fctx = (fr_sbuff_uctx_file_t){
707 .file = file,
708 .max = max,
709 .buff_end = buff + len //!< Store the real end
710 };
711
712 *sbuff = (fr_sbuff_t){
713 .buff = buff,
714 .start = buff,
715 .p = buff,
716 .end = buff, //!< Starts with 0 bytes available
717 .extend = fr_sbuff_extend_file,
718 .eof = fr_sbuff_eof_file,
719 .uctx = fctx
720 };
721
722 return sbuff;
723}
724
725/** Initialise a special sbuff which automatically extends as additional data is written
726 *
727 * @param[in] ctx to allocate buffer in.
728 * @param[out] sbuff to initialise.
729 * @param[out] tctx to initialise. Must have a lifetime >= to the sbuff.
730 * @param[in] init The length of the initial buffer, excluding \0 byte.
731 * @param[in] max The maximum length of the buffer.
732 * @return
733 * - The passed sbuff on success.
734 * - NULL on failure.
735 */
736static inline fr_sbuff_t *fr_sbuff_init_talloc(TALLOC_CTX *ctx,
737 fr_sbuff_t *sbuff, fr_sbuff_uctx_talloc_t *tctx,
738 size_t init, size_t max)
739{
740 char *buff;
741
742 *tctx = (fr_sbuff_uctx_talloc_t){
743 .ctx = ctx,
744 .init = init,
745 .max = max
746 };
747
748 /*
749 * Allocate the initial buffer
750 *
751 * We always allocate a buffer so we don't
752 * trigger ubsan errors by performing
753 * arithmetic on NULL pointers.
754 */
755 buff = talloc_zero_array(ctx, char, init + 1);
756 if (!buff) {
757 fr_strerror_printf("Failed allocating buffer of %zu bytes", init + 1);
758 memset(sbuff, 0, sizeof(*sbuff)); /* clang scan */
759 return NULL;
760 }
761
762 *sbuff = (fr_sbuff_t){
763 .buff = buff,
764 .start = buff,
765 .p = buff,
766 .end = buff + init,
767 .extend = fr_sbuff_extend_talloc,
768 .uctx = tctx
769 };
770
771 return sbuff;
772}
773/** @} */
774
775/** @name Accessors
776 *
777 * Caching the values of these pointers or the pointer values from the sbuff
778 * directly is strongly discouraged as they can become invalidated during
779 * stream parsing or when printing to an auto-expanding buffer.
780 *
781 * These functions should only be used to pass sbuff pointers into 3rd party
782 * APIs.
783 *
784 * @{
785 */
786
787/** Return a pointer to the sbuff
788 *
789 * @param[in] _sbuff_or_marker to return a pointer to.
790 * @return A pointer to the sbuff.
791 */
792#define fr_sbuff_ptr(_sbuff_or_marker) \
793 _Generic((_sbuff_or_marker), \
794 fr_sbuff_t * : ((fr_sbuff_t *)(_sbuff_or_marker)), \
795 fr_sbuff_marker_t * : ((fr_sbuff_marker_t *)(_sbuff_or_marker))->parent \
796 )
797
798/** Return a pointer to the start of the underlying buffer in an sbuff or one of its markers
799 *
800 * @param[in] _sbuff_or_marker to return the buffer for.
801 * @return A pointer to the start of the buffer.
802 */
803#define fr_sbuff_buff(_sbuff_or_marker) \
804 _Generic((_sbuff_or_marker), \
805 fr_sbuff_t * : ((fr_sbuff_t const *)(_sbuff_or_marker))->buff, \
806 fr_sbuff_t const * : ((fr_sbuff_t const *)(_sbuff_or_marker))->buff, \
807 fr_sbuff_marker_t * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->buff, \
808 fr_sbuff_marker_t const * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->buff \
809 )
810
811/** Return a pointer to the 'start' position of an sbuff or one of its markers
812 *
813 * The start position is not necessarily the start of the buffer, and is
814 * advanced every time an sbuff is copied.
815 *
816 * @param[in] _sbuff_or_marker to return the start position of.
817 * @return A pointer to the start position of the buffer.
818 */
819#define fr_sbuff_start(_sbuff_or_marker) \
820 (_Generic((_sbuff_or_marker), \
821 fr_sbuff_t * : ((fr_sbuff_t const *)(_sbuff_or_marker))->start, \
822 fr_sbuff_t const * : ((fr_sbuff_t const *)(_sbuff_or_marker))->start, \
823 fr_sbuff_marker_t * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->start, \
824 fr_sbuff_marker_t const * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->start \
825 ))
826
827/** Return a pointer to the 'current' position of an sbuff or one of its markers
828 *
829 * @note Should not be derferenced as it may point past the end of the buffer.
830 * Use #fr_sbuff_char to get the current char.
831 *
832 * @param[in] _sbuff_or_marker to return the current position of.
833 * @return A pointer to the current position of the buffer or marker.
834 */
835#define fr_sbuff_current(_sbuff_or_marker) \
836 (_Generic((_sbuff_or_marker), \
837 fr_sbuff_t * : ((fr_sbuff_t const *)(_sbuff_or_marker))->p, \
838 fr_sbuff_t const * : ((fr_sbuff_t const *)(_sbuff_or_marker))->p, \
839 fr_sbuff_marker_t * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->p, \
840 fr_sbuff_marker_t const * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->p \
841 ))
842
843/** Return a pointer to the 'end' position of an sbuff or one of its markers
844 *
845 * @param[in] _sbuff_or_marker to return the end position of.
846 * @return A pointer to the end position of the buffer or marker.
847 */
848#define fr_sbuff_end(_sbuff_or_marker) \
849 (_Generic((_sbuff_or_marker), \
850 fr_sbuff_t * : ((fr_sbuff_t const *)(_sbuff_or_marker))->end, \
851 fr_sbuff_t const * : ((fr_sbuff_t const *)(_sbuff_or_marker))->end, \
852 fr_sbuff_marker_t * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->end, \
853 fr_sbuff_marker_t const * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->end \
854 ))
855
856/** Return the value of the shifted field
857 *
858 * @param[in] _sbuff_or_marker to return the position of.
859 * @return the number of bytes the buffer has been shifted.
860 */
861#define fr_sbuff_shifted(_sbuff_or_marker) \
862 (_Generic((_sbuff_or_marker), \
863 fr_sbuff_t * : ((fr_sbuff_t const *)(_sbuff_or_marker))->shifted, \
864 fr_sbuff_t const * : ((fr_sbuff_t const *)(_sbuff_or_marker))->shifted, \
865 fr_sbuff_marker_t * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->shifted, \
866 fr_sbuff_marker_t const * : ((fr_sbuff_marker_t const *)(_sbuff_or_marker))->parent->shifted \
867 ))
868
869/** Return the current char pointed to by the sbuff or '\0' if no more chars remain
870 *
871 * @note Should be used in place of #fr_sbuff_current if switching over the current char.
872 *
873 * @param[in] _sbuff_or_marker to return the current char from.
874 * @param[in] _eob char used to indicate End of Buffer, usually '\0'.
875 * @return The current char pointed to be the sbuff.
876 */
877#define fr_sbuff_char(_sbuff_or_marker, _eob) \
878 (fr_sbuff_current(_sbuff_or_marker) >= fr_sbuff_end(_sbuff_or_marker) ? _eob : *fr_sbuff_current(_sbuff_or_marker))
879
880/** Start a switch block over the current sbuff char
881 *
882 * @note '\0' is used to indicate EOB.
883 *
884 * @param[in] _sbuff_or_marker to return the current char from.
885 * @param[in] _eob char used to indicate End of Buffer, usually '\0'.
886 */
887#define fr_sbuff_switch(_sbuff_or_marker, _eob) \
888 switch (fr_sbuff_char(_sbuff_or_marker, _eob))
889/** @} */
890
891/** @name Length calculations
892 * @{
893 */
894
895/** Return the difference in position between the two sbuffs or markers
896 *
897 * @param[in] _a The first sbuff or marker.
898 * @param[in] _b The second sbuff or marker.
899 * @return
900 * - >0 the number of bytes _a is ahead of _b.
901 * - 0 _a and _b are the same position.
902 * - <0 the number of bytes _a is behind of _b.
903 */
904#define fr_sbuff_diff(_a, _b) \
905 ((ssize_t)(fr_sbuff_current(_a) - fr_sbuff_current(_b)))
906
907/** Return the number of bytes remaining between the sbuff or marker and the end of the buffer
908 *
909 * @note Do not use this in functions that may be used for stream parsing
910 * unless you're sure you know what you're doing.
911 * The value return does not reflect the number of bytes that may
912 * be potentially read from the stream, only the number of bytes
913 * until the end of the current chunk.
914 *
915 * @param[in] _sbuff_or_marker to return the number of bytes remaining for.
916 * @return
917 * - >0 the number of bytes remaining before we reach the end of the buffer.
918 * - -0 we're at the end of the buffer.
919 */
920#define fr_sbuff_remaining(_sbuff_or_marker) \
921 ((size_t)(fr_sbuff_end(_sbuff_or_marker) < fr_sbuff_current(_sbuff_or_marker) ? \
922 0 : (fr_sbuff_end(_sbuff_or_marker) - fr_sbuff_current(_sbuff_or_marker))))
923
924/** Return the number of bytes remaining between the start of the sbuff or marker and the current position
925 *
926 * @param[in] _sbuff_or_marker to return the number of bytes used for.
927 * @return
928 * - >0 the number of bytes the current position has advanced past the start.
929 * - -0 the current position is at the start of the buffer.
930 */
931#define fr_sbuff_used(_sbuff_or_marker) \
932 ((size_t)(fr_sbuff_start(_sbuff_or_marker) > fr_sbuff_current(_sbuff_or_marker) ? \
933 0 : (fr_sbuff_current(_sbuff_or_marker) - fr_sbuff_start(_sbuff_or_marker))))
934
935/** Sets an error marker in the parent
936 *
937 * If an error already exists at this level it will be used instead of the provided error.
938 *
939 * @param[in] sbuff who's parent we'll set the error marker in.
940 * @param[in] err marker to set.
941 * @return <0 the negative offset of the error.
942 */
943static inline fr_slen_t _fr_sbuff_error(fr_sbuff_t *sbuff, char const *err)
944{
945 fr_sbuff_t *parent = sbuff->parent;
946 fr_slen_t slen;
947
948 if (sbuff->err) err = sbuff->err;
949 if (parent) parent->err = err;
950
951 slen = -((err - fr_sbuff_start(sbuff)) + 1);
952
953#ifdef __clang_analyzer__
954 /*
955 * Convince clang that the return value
956 * is always negative. It never can be
957 * else the sbuff code is very broken.
958 */
959 if (slen >= 0) return -1;
960#endif
961
962 return slen;
963}
964
965/** Return the current position as an error marker
966 *
967 * @param[in] _sbuff_or_marker Error marker will be set from the current position of this sbuff.
968 *
969 * +1 is added to the position to disambiguate with 0 meaning "parsed no data".
970 *
971 * An error at offset 0 will be returned as -1.
972 */
973#define fr_sbuff_error(_sbuff_or_marker) \
974 _fr_sbuff_error(fr_sbuff_ptr(_sbuff_or_marker), fr_sbuff_current(_sbuff_or_marker))
975
976/** Like fr_sbuff_used, but adjusts for the value returned for the amount shifted
977 *
978 * @param[in] _sbuff_or_marker to return the number of bytes used for.
979 * @return
980 * - >0 the number of bytes the current position has advanced past the start +
981 * the amount the buffer has shifted.
982 * - -0 the current position is at the start of the buffer (and hasn't been shifted).
983 */
984#define fr_sbuff_used_total(_sbuff_or_marker) \
985 ((size_t)((fr_sbuff_current(_sbuff_or_marker) + fr_sbuff_shifted(_sbuff_or_marker)) - fr_sbuff_start(_sbuff_or_marker)))
986
987/** The length of the underlying buffer
988 *
989 * @param[in] _sbuff_or_marker to return the length of.
990 * @return The length of the underlying buffer (minus 1 byte for \0).
991 */
992#define fr_sbuff_len(_sbuff_or_marker) \
993 ((size_t)(fr_sbuff_end(_sbuff_or_marker) - fr_sbuff_buff(_sbuff_or_marker)))
994
995/** How many bytes the sbuff or marker is behind its parent
996 *
997 * @param[in] _sbuff_or_marker
998 * @return
999 * - 0 the sbuff or marker is ahead of its parent.
1000 * - >0 the number of bytes the marker is behind its parent.
1001 */
1002#define fr_sbuff_behind(_sbuff_or_marker) \
1003 (fr_sbuff_current(_sbuff_or_marker) > fr_sbuff_current((_sbuff_or_marker)->parent) ? \
1004 0 : fr_sbuff_current((_sbuff_or_marker)->parent) - fr_sbuff_current(_sbuff_or_marker))
1005
1006/** How many bytes the sbuff or marker is ahead of its parent
1007 *
1008 * @return
1009 * - 0 the sbuff or marker is behind its parent.
1010 * - >0 the number of bytes the marker is ahead of its parent.
1011 */
1012#define fr_sbuff_ahead(_sbuff_or_marker) \
1013 (fr_sbuff_current((_sbuff_or_marker)->parent) > fr_sbuff_current(_sbuff_or_marker) ? \
1014 0 : fr_sbuff_current(_sbuff_or_marker) - fr_sbuff_current((_sbuff_or_marker)->parent))
1015
1016/** Return the current position in the sbuff as a negative offset
1017 *
1018 */
1019#define FR_SBUFF_ERROR_RETURN(_sbuff_or_marker) return fr_sbuff_error(_sbuff_or_marker)
1020
1021/** Check if _len bytes are available in the sbuff, and if not return the number of bytes we'd need
1022 *
1023 */
1024#define FR_SBUFF_CHECK_REMAINING_RETURN(_sbuff, _len) \
1025 if ((_len) > fr_sbuff_remaining(_sbuff)) return -((_len) - fr_sbuff_remaining(_sbuff))
1026
1027static inline size_t _fr_sbuff_extend_lowat(fr_sbuff_extend_status_t *status, fr_sbuff_t *in, size_t remaining, size_t lowat)
1028{
1029 size_t extended;
1030 fr_sbuff_extend_status_t our_status = 0;
1031
1032 if (!fr_sbuff_is_extendable(in)) {
1033 no_extend:
1034 if (status) *status = our_status;
1035 return remaining;
1036 }
1037
1038 /* Still have data remaining, no need to try and extend */
1039 if (remaining >= lowat) goto no_extend;
1040
1041 if (!in->extend || ((extended = in->extend(&our_status, in, lowat - remaining)) == 0)) {
1042 goto no_extend;
1043 }
1044
1045 our_status |= FR_SBUFF_FLAG_EXTENDED;
1046
1047 if (status) *status = our_status;
1048 return remaining + extended;
1049}
1050
1051/** Extend a buffer if we're below the low water mark
1052 *
1053 * @param[out] _status Should be initialised to FR_SBUFF_EXTENDABLE
1054 * for the first call to this function if used
1055 * as a loop condition.
1056 * Will be filled with the result of the previous
1057 * call, and can be used to determine if the buffer
1058 * was extended.
1059 * @param[in] _sbuff_or_marker to extend.
1060 * @param[in] _lowat If bytes remaining are below the amount, extend.
1061 * @return
1062 * - 0 if there are no bytes left in the buffer and we couldn't extend.
1063 * - >0 the number of bytes in the buffer after extending.
1064 */
1065#define fr_sbuff_extend_lowat(_status, _sbuff_or_marker, _lowat) \
1066 _fr_sbuff_extend_lowat(_status, \
1067 fr_sbuff_ptr(_sbuff_or_marker), \
1068 fr_sbuff_remaining(_sbuff_or_marker), _lowat)
1069
1070/** Check if _len bytes are available in the sbuff and extend the buffer if possible
1071 *
1072 * If we do not have _len bytes in the sbuff after extending, then return.
1073 *
1074 * @param[in] _sbuff to extend.
1075 * @param[in] _len The minimum amount the sbuff should be extended by.
1076 * @return The number of bytes we would need to satisfy _len as a negative integer.
1077 */
1078#define FR_SBUFF_EXTEND_LOWAT_OR_RETURN(_sbuff, _len) \
1079do { \
1080 size_t _remaining = fr_sbuff_extend_lowat(NULL, _sbuff, _len); \
1081 if (_remaining < _len) return -(_len - _remaining); \
1082} while (0)
1083
1084/** Extend a buffer if no space remains
1085 *
1086 * @param[in] _sbuff_or_marker to extend.
1087 * @return
1088 * - 0 if there are no bytes left in the buffer and we couldn't extend.
1089 * - >0 the number of bytes in the buffer after extending.
1090 */
1091#define fr_sbuff_extend(_sbuff_or_marker) fr_sbuff_extend_lowat(NULL, _sbuff_or_marker, 1)
1092
1093/** @} */
1094
1095/** @name Position modification (recursive)
1096 *
1097 * Change the current position of pointers in the sbuff and their children.
1098 * @{
1099 */
1100
1101/** Update the position of p in a list of sbuffs
1102 *
1103 * @note Do not call directly.
1104 */
1105static inline void _fr_sbuff_set_recurse(fr_sbuff_t *sbuff, char const *p)
1106{
1107 sbuff->p_i = p;
1108 sbuff->err = NULL; /* Modifying the position of the sbuff clears the error */
1109
1110 if (sbuff->adv_parent && sbuff->parent) _fr_sbuff_set_recurse(sbuff->parent, p);
1111}
1112
1113static inline ssize_t _fr_sbuff_marker_set(fr_sbuff_marker_t *m, char const *p)
1114{
1115 fr_sbuff_t *sbuff = m->parent;
1116 char *current = m->p;
1117
1118 if (unlikely(p > sbuff->end)) return -(p - sbuff->end);
1119 if (unlikely(p < sbuff->start)) return 0;
1120
1121 sbuff->err = NULL; /* Modifying the position of any markers clears the error, unsure if this is correct? */
1122 m->p_i = p;
1123
1124 return p - current;
1125}
1126
1127static inline ssize_t _fr_sbuff_set(fr_sbuff_t *sbuff, char const *p)
1128{
1129 char const *c;
1130
1131 if (unlikely(p > sbuff->end)) return -(p - sbuff->end);
1132 if (unlikely(p < sbuff->start)) return 0;
1133
1134 c = sbuff->p;
1135 _fr_sbuff_set_recurse(sbuff, p);
1136
1137 return p - c;
1138}
1139
1140/** Set the position in a sbuff using another sbuff, a char pointer, or a length
1141 *
1142 * @param[in] _dst sbuff or marker to set the position for.
1143 * @param[in] _src Variable to glean new position from. Behaviour here
1144 * depends on the type of the variable.
1145 * - sbuff, the current position of the sbuff.
1146 * - marker, the current position of the marker.
1147 * - pointer, the position of the pointer.
1148 * - size_t, _dst->start + _src.
1149 * @return
1150 * - 0 not advanced.
1151 * - >0 the number of bytes the sbuff was advanced by.
1152 * - <0 the number of bytes required to complete the advancement
1153 */
1154#define fr_sbuff_set(_dst, _src) \
1155_Generic((_dst), \
1156 fr_sbuff_t * : _fr_sbuff_set, \
1157 fr_sbuff_marker_t * : _fr_sbuff_marker_set \
1158)(_dst, \
1159_Generic((_src), \
1160 fr_sbuff_t * : fr_sbuff_current((fr_sbuff_t const *)(_src)), \
1161 fr_sbuff_t const * : fr_sbuff_current((fr_sbuff_t const *)(_src)), \
1162 fr_sbuff_marker_t * : fr_sbuff_current((fr_sbuff_marker_t const *)(_src)), \
1163 fr_sbuff_marker_t const * : fr_sbuff_current((fr_sbuff_marker_t const *)(_src)), \
1164 char const * : (char const *)(_src), \
1165 char * : (char const *)(_src), \
1166 size_t : (fr_sbuff_start(_dst) + (uintptr_t)(_src)) \
1167))
1168
1169/** Set an sbuff to a given position, and return how much it was advanced
1170 *
1171 * @param[in] _dst to modify.
1172 * @param[in] _src position to set it too.
1173 * @return The number of bytes _dst was advanced.
1174 */
1175#define FR_SBUFF_SET_RETURN(_dst, _src) return fr_sbuff_set(_dst, _src)
1176
1177/** Advance position in sbuff by N bytes
1178 *
1179 * @param[in] _sbuff_or_marker to advance.
1180 * @param[in] _len How much to advance sbuff by.
1181 * @return
1182 * - 0 not advanced.
1183 * - >0 the number of bytes the sbuff was advanced by.
1184 * - <0 the number of bytes required to complete the advancement
1185 */
1186#define fr_sbuff_advance(_sbuff_or_marker, _len) fr_sbuff_set(_sbuff_or_marker, (fr_sbuff_current(_sbuff_or_marker) + (_len)))
1187#define FR_SBUFF_ADVANCE_RETURN(_sbuff, _len) FR_SBUFF_RETURN(fr_sbuff_advance, _sbuff, _len)
1188
1189/** Reset the current position of the sbuff to the start of the string
1190 *
1191 */
1192static inline void fr_sbuff_set_to_start(fr_sbuff_t *sbuff)
1193{
1194 _fr_sbuff_set_recurse(sbuff, sbuff->start);
1195}
1196
1197/** Reset the current position of the sbuff to the end of the string
1198 *
1199 */
1200static inline void fr_sbuff_set_to_end(fr_sbuff_t *sbuff)
1201{
1202 _fr_sbuff_set_recurse(sbuff, sbuff->end);
1203}
1204/** @} */
1205
1206/** @name Add a marker to an sbuff
1207 *
1208 * Markers are used to indicate an area of the code is working at a particular
1209 * point in a string buffer.
1210 *
1211 * If the sbuff is performing stream parsing, then markers are used to update
1212 * any pointers to the buffer, as the data in the buffer is shifted to make
1213 * room for new data from the stream.
1214 *
1215 * If the sbuff is being used to create strings, then the markers are updated
1216 * if the buffer is re-allocated.
1217 * @{
1218 */
1219
1220/** Adds a new pointer to the beginning of the list of pointers to update
1221 *
1222 * @param[out] m to initialise.
1223 * @param[in] sbuff to associate marker with.
1224 * @return The position the marker was set to.
1225 */
1226static inline char *fr_sbuff_marker(fr_sbuff_marker_t *m, fr_sbuff_t *sbuff)
1227{
1228 *m = (fr_sbuff_marker_t){
1229 .next = sbuff->m, /* Link into the head */
1230 .p = sbuff->p, /* Set the current position in the sbuff */
1231 .parent = sbuff /* Record which sbuff this marker was associated with */
1232 };
1233 sbuff->m = m;
1234
1235 return sbuff->p;
1236}
1237
1238/** Used to update the position of an 'end' position marker
1239 *
1240 * Updates a marker so that it represents a 'constrained' end.
1241 * If max > fr_sbuff_remaining() + fr_sbuff_used_total(), then the marker will
1242 * be set to the end of the sbuff.
1243 *
1244 * Otherwise the marker will be set to the position indicated by
1245 * start + (max - fr_sbuff_used_total()).
1246 *
1247 * This is used to add a constraint on the amount data that can be copied from
1248 * an extendable buffer.
1249 *
1250 * @param[in] m Marker created with #fr_sbuff_marker.
1251 * @param[in] max amount of data we allow to be read from
1252 * the sbuff. May be SIZE_MAX in which
1253 * case there is no constraint imposed
1254 * and the marker is set to the end of the buffer.
1255 */
1256static inline char *fr_sbuff_marker_update_end(fr_sbuff_marker_t *m, size_t max)
1257{
1258 fr_sbuff_t *sbuff = m->parent;
1259 size_t used = fr_sbuff_used_total(sbuff);
1260
1261 m->p = (((max) - (used)) > fr_sbuff_remaining(sbuff) ?
1262 fr_sbuff_end(sbuff) :
1263 fr_sbuff_current(sbuff) + ((max) - (used)));
1264
1265 return m->p;
1266}
1267
1268/** Trims the linked list back to the specified pointer
1269 *
1270 * Pointers should be released in the inverse order to allocation.
1271 *
1272 * Alternatively the oldest pointer can be released, resulting in any newer pointer
1273 * also being removed from the list.
1274 *
1275 * @param[in] m to release.
1276 */
1277static inline void fr_sbuff_marker_release(fr_sbuff_marker_t *m)
1278{
1279 m->parent->m = m->next;
1280
1281#ifndef NDEBUF
1282 memset(m, 0, sizeof(*m)); /* Use after release */
1283#endif
1284}
1285
1286/** Trims the linked list back to the specified pointer and return how many bytes marker was behind p
1287 *
1288 * Pointers should be released in the inverse order to allocation.
1289 *
1290 * Alternatively the oldest pointer can be released, resulting in any newer pointer
1291 * also being removed from the list.
1292 *
1293 * @param[in] m to release.
1294 * @return
1295 * - 0 marker is ahead of p.
1296 * - >0 the number of bytes the marker is behind p.
1297 */
1298static inline size_t fr_sbuff_marker_release_behind(fr_sbuff_marker_t *m)
1299{
1300 size_t len = fr_sbuff_behind(m);
1301 fr_sbuff_marker_release(m);
1302 return len;
1303}
1304
1305/** Trims the linked list back to the specified pointer and return how many bytes marker was ahead of p
1306 *
1307 * Pointers should be released in the inverse order to allocation.
1308 *
1309 * Alternatively the oldest pointer can be released, resulting in any newer pointer
1310 * also being removed from the list.
1311 *
1312 * @param[in] m to release.
1313 * @return
1314 * - 0 marker is ahead of p.
1315 * - >0 the number of bytes the marker is behind p.
1316 */
1317static inline size_t fr_sbuff_marker_release_ahead(fr_sbuff_marker_t *m)
1318{
1319 size_t len = fr_sbuff_ahead(m);
1320 fr_sbuff_marker_release(m);
1321 return len;
1322}
1323
1324/** Trims the linked list back to the specified pointer and return how many bytes marker was behind p
1325 *
1326 * Pointers should be released in the inverse order to allocation.
1327 *
1328 * Alternatively the oldest pointer can be released, resulting in any newer pointer
1329 * also being removed from the list.
1330 *
1331 * @param[in] m to release.
1332 * @return
1333 * - 0 marker is ahead of p.
1334 * - >0 the number of bytes the marker is behind p.
1335 */
1336static inline size_t fr_sbuff_marker_release_reset_behind(fr_sbuff_marker_t *m)
1337{
1338 size_t len = fr_sbuff_behind(m);
1339 fr_sbuff_set(m->parent, m);
1340 fr_sbuff_marker_release(m);
1341 return len;
1342}
1343
1344/** Trims the linked list back to the specified pointer and return how many bytes marker was ahead of p
1345 *
1346 * Pointers should be released in the inverse order to allocation.
1347 *
1348 * Alternatively the oldest pointer can be released, resulting in any newer pointer
1349 * also being removed from the list.
1350 *
1351 * @param[in] m to release.
1352 * @return
1353 * - 0 marker is ahead of p.
1354 * - >0 the number of bytes the marker is behind p.
1355 */
1356static inline size_t fr_sbuff_marker_release_reset_ahead(fr_sbuff_marker_t *m)
1357{
1358 size_t len = fr_sbuff_ahead(m);
1359 fr_sbuff_set(m->parent, m);
1360 fr_sbuff_marker_release(m);
1361 return len;
1362}
1363/** @} */
1364
1365/** @name Copy data between an sbuff/marker
1366 *
1367 * These functions are typically used for moving data between sbuffs
1368 *
1369 * @{
1370 */
1371size_t _fr_sbuff_move_sbuff_to_sbuff(fr_sbuff_t *out, fr_sbuff_t *in, size_t len);
1372
1373size_t _fr_sbuff_move_marker_to_sbuff(fr_sbuff_t *out, fr_sbuff_marker_t *in, size_t len);
1374
1375size_t _fr_sbuff_move_marker_to_marker(fr_sbuff_marker_t *out, fr_sbuff_marker_t *in, size_t len);
1376
1377size_t _fr_sbuff_move_sbuff_to_marker(fr_sbuff_marker_t *out, fr_sbuff_t *in, size_t len);
1378
1379/** Copy in as many bytes as possible from one sbuff or marker to another
1380 *
1381 * @param[in] _out to copy into.
1382 * @param[in] _in to copy from.
1383 * @param[in] _len The maximum length to copy.
1384 * @return Number of bytes copied.
1385 */
1386#define fr_sbuff_move(_out, _in, _len) \
1387 _Generic((_out), \
1388 fr_sbuff_t * : \
1389 _Generic((_in), \
1390 fr_sbuff_t * : _fr_sbuff_move_sbuff_to_sbuff((fr_sbuff_t *)_out, (fr_sbuff_t *)_in, _len), \
1391 fr_sbuff_marker_t * : _fr_sbuff_move_marker_to_sbuff((fr_sbuff_t *)_out, (fr_sbuff_marker_t *)_in, _len) \
1392 ), \
1393 fr_sbuff_marker_t * : \
1394 _Generic((_in), \
1395 fr_sbuff_t * : _fr_sbuff_move_sbuff_to_marker((fr_sbuff_marker_t *)_out, (fr_sbuff_t *)_in, _len), \
1396 fr_sbuff_marker_t * : _fr_sbuff_move_marker_to_marker((fr_sbuff_marker_t *)_out, (fr_sbuff_marker_t *)_in, _len) \
1397 ) \
1398 )
1399/** @} */
1400
1401/** @name Copy/print complete input data to an sbuff
1402 *
1403 * These functions are typically used for printing.
1404 *
1405 * @{
1406 */
1407#define fr_sbuff_in_char(_sbuff, ...) fr_sbuff_in_bstrncpy(_sbuff, ((char []){ __VA_ARGS__ }), sizeof((char []){ __VA_ARGS__ }))
1408#define FR_SBUFF_IN_CHAR_RETURN(_sbuff, ...) FR_SBUFF_RETURN(fr_sbuff_in_bstrncpy, _sbuff, ((char []){ __VA_ARGS__ }), sizeof((char []){ __VA_ARGS__ }))
1409
1410ssize_t fr_sbuff_in_strcpy(fr_sbuff_t *sbuff, char const *str);
1411#define FR_SBUFF_IN_STRCPY_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_strcpy, ##__VA_ARGS__)
1412
1413ssize_t fr_sbuff_in_bstrncpy(fr_sbuff_t *sbuff, char const *str, size_t len);
1414#define FR_SBUFF_IN_BSTRNCPY_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_bstrncpy, ##__VA_ARGS__)
1415
1416#define fr_sbuff_in_strcpy_literal(_sbuff, _str) fr_sbuff_in_bstrncpy(_sbuff, _str, sizeof(_str) - 1)
1417#define FR_SBUFF_IN_STRCPY_LITERAL_RETURN(_sbuff, _str) FR_SBUFF_RETURN(fr_sbuff_in_bstrncpy, _sbuff, _str, sizeof(_str) - 1)
1418
1419ssize_t fr_sbuff_in_bstrcpy_buffer(fr_sbuff_t *sbuff, char const *str);
1420#define FR_SBUFF_IN_BSTRCPY_BUFFER_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_bstrcpy_buffer, ##__VA_ARGS__)
1421
1422ssize_t fr_sbuff_in_vsprintf(fr_sbuff_t *sbuff, char const *fmt, va_list ap);
1423#define FR_SBUFF_IN_VSPRINTF_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_vsprintf, ##__VA_ARGS__)
1424
1425ssize_t fr_sbuff_in_sprintf(fr_sbuff_t *sbuff, char const *fmt, ...);
1426#define FR_SBUFF_IN_SPRINTF_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_sprintf, ##__VA_ARGS__)
1427
1428ssize_t fr_sbuff_in_escape(fr_sbuff_t *sbuff, char const *in, size_t inlen, fr_sbuff_escape_rules_t const *e_rules);
1429#define FR_SBUFF_IN_ESCAPE_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_escape, ##__VA_ARGS__)
1430
1431ssize_t fr_sbuff_in_escape_buffer(fr_sbuff_t *sbuff, char const *in, fr_sbuff_escape_rules_t const *e_rules);
1432#define FR_SBUFF_IN_ESCAPE_BUFFER_RETURN(...) FR_SBUFF_RETURN(fr_sbuff_in_escape_buffer, ##__VA_ARGS__)
1433
1434ssize_t fr_sbuff_in_array(fr_sbuff_t *sbuff, char const * const *array, char const *sep);
1435#define FR_SBUFF_IN_ARRAY(...) FR_SBUFF_RETURN(fr_sbuff_in_array, ##__VA_ARGS__)
1436
1437/** Lookup a string in a table using an integer value, and copy it to the sbuff
1438 *
1439 * @param[out] _slen Where to write the return value.
1440 * @param[in] _sbuff to search in.
1441 * @param[in] _table to search for number in.
1442 * @param[in] _number to search for.
1443 * @param[in] _def Default string value.
1444 */
1445#define fr_sbuff_in_table_str(_slen, _sbuff, _table, _number, _def) \
1446 _slen = fr_sbuff_in_strcpy(_sbuff, fr_table_str_by_value(_table, _number, _def))
1447#define FR_SBUFF_IN_TABLE_STR_RETURN(_sbuff, _table, _number, _def) \
1448do { \
1449 ssize_t _slen; \
1450 fr_sbuff_in_table_str(_slen, _sbuff, _table, _number, _def); \
1451 if (_slen < 0) return _slen; \
1452} while (0)
1453/** @} */
1454
1455/** @name Copy data out of an sbuff
1456 *
1457 * These functions are typically used for parsing.
1458 *
1459 * @{
1460 */
1461
1462/** Toggle any chars to 'true' in out, that were present in, out or in
1463 *
1464 */
1465static inline void fr_sbuff_allowed_merge(bool out[static UINT8_MAX + 1], bool const in[static UINT8_MAX + 1])
1466{
1467 for (size_t i = 0; i <= UINT8_MAX; i++) out[i] = out[i] || in[i];
1468}
1469
1470fr_sbuff_term_t *fr_sbuff_terminals_amerge(TALLOC_CTX *ctx,
1471 fr_sbuff_term_t const *a, fr_sbuff_term_t const *b);
1472
1473size_t fr_sbuff_out_bstrncpy(fr_sbuff_t *out, fr_sbuff_t *in, size_t len);
1474
1475ssize_t fr_sbuff_out_bstrncpy_exact(fr_sbuff_t *out, fr_sbuff_t *in, size_t len);
1476
1477size_t fr_sbuff_out_bstrncpy_allowed(fr_sbuff_t *out, fr_sbuff_t *in, size_t len,
1478 bool const allowed[static UINT8_MAX + 1]);
1479
1480size_t fr_sbuff_out_bstrncpy_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len,
1481 fr_sbuff_term_t const *tt,
1482 fr_sbuff_unescape_rules_t const *u_rules);
1483
1484size_t fr_sbuff_out_unescape_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len,
1485 fr_sbuff_term_t const *tt,
1486 fr_sbuff_unescape_rules_t const *u_rules);
1487
1488/** Find the longest prefix in an sbuff
1489 *
1490 * @param[out] _match_len The length of the matched string.
1491 * May be NULL.
1492 * @param[out] _out The value resolved in the table.
1493 * @param[in] _table to find longest match in.
1494 * @param[in] _sbuff containing the needle.
1495 * @param[in] _def Default value if no match is found.
1496 */
1497#define fr_sbuff_out_by_longest_prefix(_match_len, _out, _table, _sbuff, _def) \
1498do { \
1499 size_t _match_len_tmp; \
1500 fr_sbuff_extend_lowat(NULL, _sbuff, fr_table_max_needle_len(_table)); \
1501 *(_out) = fr_table_value_by_longest_prefix(&_match_len_tmp, _table, \
1502 fr_sbuff_current(_sbuff), fr_sbuff_remaining(_sbuff), \
1503 _def); \
1504 (void) fr_sbuff_advance(_sbuff, _match_len_tmp); /* can't fail */ \
1505 *(_match_len) = _match_len_tmp; \
1506} while (0)
1507
1508/** Build a talloc wrapper function for a fr_sbuff_out_* function
1509 *
1510 * @param[in] _func to call.
1511 * @param[in] _in input sbuff arg.
1512 * @param[in] _len expected output len.
1513 * @param[in] ... additional arguments to pass to _func.
1514 */
1515#define SBUFF_OUT_TALLOC_ERR_FUNC_DEF(_func, _in, _len, ...) \
1516{ \
1517 fr_sbuff_t sbuff; \
1518 fr_sbuff_uctx_talloc_t tctx; \
1519 fr_sbuff_parse_error_t err; \
1520 fr_slen_t slen = -1; \
1521 if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
1522 ((_len) != SIZE_MAX) ? (_len) : 1024, \
1523 ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX) == NULL)) { \
1524 error: \
1525 TALLOC_FREE(sbuff.buff); \
1526 *out = NULL; \
1527 return slen; \
1528 } \
1529 slen = _func(&err, &sbuff, _in, _len, ##__VA_ARGS__); \
1530 if (slen < 0) goto error; \
1531 if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
1532 slen = -1; \
1533 goto error; \
1534 } \
1535 *out = sbuff.buff; \
1536 return slen; \
1537}
1538
1539/** Build a talloc wrapper function for a fr_sbuff_out_* function
1540 *
1541 * @param[in] _func to call.
1542 * @param[in] _in input sbuff arg.
1543 * @param[in] _len expected output len.
1544 * @param[in] ... additional arguments to pass to _func.
1545 */
1546#define SBUFF_OUT_TALLOC_FUNC_DEF(_func, _in, _len, ...) \
1547{ \
1548 fr_sbuff_t sbuff; \
1549 fr_sbuff_uctx_talloc_t tctx; \
1550 fr_slen_t slen = -1; \
1551 if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, \
1552 ((_len) != SIZE_MAX) ? (_len) : 1024, \
1553 ((_len) != SIZE_MAX) ? (_len) : SIZE_MAX) == NULL)) { \
1554 error: \
1555 TALLOC_FREE(sbuff.buff); \
1556 *out = NULL; \
1557 return slen; \
1558 } \
1559 slen = _func(&sbuff, _in, _len, ##__VA_ARGS__); \
1560 if (slen < 0) goto error; \
1561 if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
1562 slen = -1; \
1563 goto error; \
1564 } \
1565 *out = sbuff.buff; \
1566 return slen; \
1567}
1568
1569/** Build a talloc wrapper function for a fr_sbuff_out_* function
1570 *
1571 * @param[in] _func to call.
1572 * @param[in] ... additional arguments to pass to _func.
1573 */
1574#define SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(_func, ...) \
1575{ \
1576 fr_sbuff_t sbuff; \
1577 fr_sbuff_uctx_talloc_t tctx; \
1578 fr_slen_t slen = -1; \
1579 if (unlikely(fr_sbuff_init_talloc(ctx, &sbuff, &tctx, 0, SIZE_MAX) == NULL)) { \
1580 error: \
1581 TALLOC_FREE(sbuff.buff); \
1582 *out = NULL; \
1583 return slen; \
1584 } \
1585 slen = _func(&sbuff, ##__VA_ARGS__); \
1586 if (slen < 0) goto error; \
1587 if (unlikely(fr_sbuff_trim_talloc(&sbuff, SIZE_MAX) < 0)) { \
1588 slen = -1; \
1589 goto error; \
1590 } \
1591 *out = sbuff.buff; \
1592 return slen; \
1593}
1594
1595static inline fr_slen_t fr_sbuff_out_abstrncpy(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t len)
1596SBUFF_OUT_TALLOC_FUNC_DEF(fr_sbuff_out_bstrncpy, in, len)
1597
1598static inline fr_slen_t fr_sbuff_out_abstrncpy_exact(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t len)
1599SBUFF_OUT_TALLOC_FUNC_DEF(fr_sbuff_out_bstrncpy_exact, in, len)
1600
1601static inline fr_slen_t fr_sbuff_out_abstrncpy_allowed(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t len,
1602 bool const allowed[static UINT8_MAX + 1])
1603SBUFF_OUT_TALLOC_FUNC_DEF(fr_sbuff_out_bstrncpy_allowed, in, len, allowed)
1604
1605static inline fr_slen_t fr_sbuff_out_abstrncpy_until(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t len,
1606 fr_sbuff_term_t const *tt,
1607 fr_sbuff_unescape_rules_t const *u_rules)
1608SBUFF_OUT_TALLOC_FUNC_DEF(fr_sbuff_out_bstrncpy_until, in, len, tt, u_rules)
1609
1610static inline fr_slen_t fr_sbuff_out_aunescape_until(TALLOC_CTX *ctx, char **out, fr_sbuff_t *in, size_t len,
1611 fr_sbuff_term_t const *tt,
1612 fr_sbuff_unescape_rules_t const *u_rules)
1613SBUFF_OUT_TALLOC_FUNC_DEF(fr_sbuff_out_unescape_until, in, len, tt, u_rules)
1614/** @} */
1615
1616/** @name Look for a token in a particular format, parse it, and write it to the output pointer
1617 *
1618 * These functions should not be called directly. #fr_sbuff_out should be used instead
1619 * so that if the output variable type changes, the parse rules are automatically changed.
1620 * @{
1621 */
1622fr_slen_t fr_sbuff_out_bool(bool *out, fr_sbuff_t *in);
1623
1624fr_slen_t fr_sbuff_out_int8(fr_sbuff_parse_error_t *err, int8_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1625fr_slen_t fr_sbuff_out_int16(fr_sbuff_parse_error_t *err, int16_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1626fr_slen_t fr_sbuff_out_int32(fr_sbuff_parse_error_t *err, int32_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1627fr_slen_t fr_sbuff_out_int64(fr_sbuff_parse_error_t *err, int64_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1628fr_slen_t fr_sbuff_out_ssize(fr_sbuff_parse_error_t *err, ssize_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1629fr_slen_t fr_sbuff_out_uint8(fr_sbuff_parse_error_t *err, uint8_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1630fr_slen_t fr_sbuff_out_uint16(fr_sbuff_parse_error_t *err, uint16_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1631fr_slen_t fr_sbuff_out_uint32(fr_sbuff_parse_error_t *err, uint32_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1632fr_slen_t fr_sbuff_out_uint64(fr_sbuff_parse_error_t *err, uint64_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1633fr_slen_t fr_sbuff_out_size(fr_sbuff_parse_error_t *err, size_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1634
1635fr_slen_t fr_sbuff_out_uint8_dec(fr_sbuff_parse_error_t *err, uint8_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1636fr_slen_t fr_sbuff_out_uint16_dec(fr_sbuff_parse_error_t *err, uint16_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1637fr_slen_t fr_sbuff_out_uint32_dec(fr_sbuff_parse_error_t *err, uint32_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1638fr_slen_t fr_sbuff_out_uint64_dec(fr_sbuff_parse_error_t *err, uint64_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1639fr_slen_t fr_sbuff_out_size_dec(fr_sbuff_parse_error_t *err, size_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1640
1641fr_slen_t fr_sbuff_out_uint8_oct(fr_sbuff_parse_error_t *err, uint8_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1642fr_slen_t fr_sbuff_out_uint16_oct(fr_sbuff_parse_error_t *err, uint16_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1643fr_slen_t fr_sbuff_out_uint32_oct(fr_sbuff_parse_error_t *err, uint32_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1644fr_slen_t fr_sbuff_out_uint64_oct(fr_sbuff_parse_error_t *err, uint64_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1645fr_slen_t fr_sbuff_out_size_oct(fr_sbuff_parse_error_t *err, size_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1646
1647fr_slen_t fr_sbuff_out_uint8_hex(fr_sbuff_parse_error_t *err, uint8_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1648fr_slen_t fr_sbuff_out_uint16_hex(fr_sbuff_parse_error_t *err, uint16_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1649fr_slen_t fr_sbuff_out_uint32_hex(fr_sbuff_parse_error_t *err, uint32_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1650fr_slen_t fr_sbuff_out_uint64_hex(fr_sbuff_parse_error_t *err, uint64_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1651fr_slen_t fr_sbuff_out_size_hex(fr_sbuff_parse_error_t *err, size_t *out, fr_sbuff_t *sbuff, bool no_trailing);
1652
1653fr_slen_t fr_sbuff_out_float32(fr_sbuff_parse_error_t *err, float *out, fr_sbuff_t *sbuff, bool no_trailing);
1654fr_slen_t fr_sbuff_out_float64(fr_sbuff_parse_error_t *err, double *out, fr_sbuff_t *sbuff, bool no_trailing);
1655
1656#ifndef SIZE_SAME_AS_UINT64
1657# define _fr_sbuff_out_size(_err, _out, _in) size_t * : fr_sbuff_out_size(_err, (size_t *)_out, _in, true),
1658#else
1659# define _fr_sbuff_out_size(_err, _out, _in)
1660#endif
1661
1662#ifndef SSIZE_SAME_AS_INT64
1663# define _fr_sbuff_out_ssize(_err, _out, _in) ssize_t * : fr_sbuff_out_ssize(_err, (ssize_t *)_out, _in, true),
1664#else
1665# define _fr_sbuff_out_ssize(_err, _out, _in)
1666#endif
1667
1668/** Parse a value based on the output type
1669 *
1670 * @param[out] _err If not NULL a value describing the parse error
1671 * will be written to err.
1672 * @param[out] _out Pointer to an integer type.
1673 * @param[in] _in Sbuff to parse integer from.
1674 * @return The number of bytes parsed (even on error).
1675 */
1676#define fr_sbuff_out(_err, _out, _in) \
1677 _Generic((_out), \
1678 bool * : fr_sbuff_out_bool((bool *)_out, _in), \
1679 int8_t * : fr_sbuff_out_int8(_err, (int8_t *)_out, _in, true), \
1680 int16_t * : fr_sbuff_out_int16(_err, (int16_t *)_out, _in, true), \
1681 int32_t * : fr_sbuff_out_int32(_err, (int32_t *)_out, _in, true), \
1682 int64_t * : fr_sbuff_out_int64(_err, (int64_t *)_out, _in, true), \
1683 _fr_sbuff_out_ssize(_err, _out, _in) \
1684 uint8_t * : fr_sbuff_out_uint8(_err, (uint8_t *)_out, _in, true), \
1685 uint16_t * : fr_sbuff_out_uint16(_err, (uint16_t *)_out, _in, true), \
1686 uint32_t * : fr_sbuff_out_uint32(_err, (uint32_t *)_out, _in, true), \
1687 uint64_t * : fr_sbuff_out_uint64(_err, (uint64_t *)_out, _in, true), \
1688 _fr_sbuff_out_size(_err, _out, _in) \
1689 float * : fr_sbuff_out_float32(_err, (float *)_out, _in, true), \
1690 double * : fr_sbuff_out_float64(_err, (double *)_out, _in, true) \
1691 )
1692/** @} */
1693
1694
1695/** @name Conditional advancement
1696 *
1697 * These functions are typically used for parsing when trying to locate
1698 * a sequence of characters in the sbuff.
1699 *
1700 * @{
1701 */
1702size_t fr_sbuff_adv_past_str(fr_sbuff_t *sbuff, char const *needle, size_t need_len);
1703
1704#define fr_sbuff_adv_past_str_literal(_sbuff, _needle) fr_sbuff_adv_past_str(_sbuff, _needle, sizeof(_needle) - 1)
1705
1706size_t fr_sbuff_adv_past_strcase(fr_sbuff_t *sbuff, char const *needle, size_t need_len);
1707
1708#define fr_sbuff_adv_past_strcase_literal(_sbuff, _needle) fr_sbuff_adv_past_strcase(_sbuff, _needle, sizeof(_needle) - 1)
1709
1710size_t fr_sbuff_adv_past_allowed(fr_sbuff_t *sbuff, size_t len,
1711 bool const allowed[static UINT8_MAX + 1], fr_sbuff_term_t const *tt);
1712
1713#define fr_sbuff_adv_past_zeros(_sbuff, _len, _tt) fr_sbuff_adv_past_allowed(_sbuff, _len, sbuff_char_class_zero, _tt)
1714
1715#define fr_sbuff_adv_past_whitespace(_sbuff, _len, _tt) fr_sbuff_adv_past_allowed(_sbuff, _len, sbuff_char_whitespace, _tt)
1716
1717#define fr_sbuff_adv_past_blank(_sbuff, _len, _tt) fr_sbuff_adv_past_allowed(_sbuff, _len, sbuff_char_blank, _tt)
1718
1719size_t fr_sbuff_adv_until(fr_sbuff_t *sbuff, size_t len, fr_sbuff_term_t const *tt, char escape_chr);
1720
1721char *fr_sbuff_adv_to_chr_utf8(fr_sbuff_t *in, size_t len, char const *chr);
1722
1723char *fr_sbuff_adv_to_chr(fr_sbuff_t *in, size_t len, char c);
1724
1725char *fr_sbuff_adv_to_str(fr_sbuff_t *sbuff, size_t len, char const *needle, size_t needle_len);
1726
1727#define fr_sbuff_adv_to_str_literal(_sbuff, _len, _needle) fr_sbuff_adv_to_str(_sbuff, _len, _needle, sizeof(_needle) - 1)
1728
1729char *fr_sbuff_adv_to_strcase(fr_sbuff_t *sbuff, size_t len, char const *needle, size_t needle_len);
1730
1731#define fr_sbuff_adv_to_strcase_literal(_sbuff, _len, _needle) fr_sbuff_adv_to_strcase(_sbuff, _len, _needle, sizeof(_needle) - 1)
1732
1733bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c);
1734
1735bool fr_sbuff_next_unless_char(fr_sbuff_t *sbuff, char c);
1736
1737/** Advance the sbuff by one char
1738 *
1739 */
1740static inline char fr_sbuff_next(fr_sbuff_t *sbuff)
1741{
1742 if (!fr_sbuff_extend(sbuff)) return '\0';
1743 return fr_sbuff_advance(sbuff, 1);
1744}
1745/** @} */
1746
1747/** @name Remove chars from a buffer and re-terminate
1748 *
1749 * @{
1750 */
1751size_t fr_sbuff_trim(fr_sbuff_t *sbuff, bool const to_trim[static UINT8_MAX + 1]);
1752/** @} */
1753
1754/** @name Conditions
1755 *
1756 * These functions are typically used in recursive decent parsing for
1757 * look ahead.
1758 * @{
1759 */
1760bool fr_sbuff_is_terminal(fr_sbuff_t *in, fr_sbuff_term_t const *tt);
1761
1762static inline bool fr_sbuff_is_in_charset(fr_sbuff_t *sbuff, bool const chars[static UINT8_MAX + 1])
1763{
1764 if (!fr_sbuff_extend(sbuff)) return false;
1765 return chars[(uint8_t)*sbuff->p];
1766}
1767
1768static inline bool fr_sbuff_is_str(fr_sbuff_t *sbuff, char const *str, size_t len)
1769{
1770 if (len == SIZE_MAX) len = strlen(str);
1771 if (!fr_sbuff_extend_lowat(NULL, sbuff, len)) return false;
1772 return memcmp(sbuff->p, str, len) == 0;
1773}
1774#define fr_sbuff_is_str_literal(_sbuff, _str) fr_sbuff_is_str(_sbuff, _str, sizeof(_str) - 1)
1775
1776#define fr_sbuff_eof(_x) (!fr_sbuff_extend(_x))
1777
1778static inline bool _fr_sbuff_is_char(fr_sbuff_t *sbuff, char *p, char c)
1779{
1780 if (!fr_sbuff_extend(sbuff)) return false;
1781 return *p == c;
1782}
1783static inline bool _fr_marker_is_char(fr_sbuff_marker_t *marker, char *p, char c)
1784{
1785 if (!fr_sbuff_extend(marker)) return false;
1786 return *p == c;
1787}
1788#define fr_sbuff_is_char(_sbuff_or_marker, _c) \
1789 _Generic((_sbuff_or_marker), \
1790 fr_sbuff_t * : _fr_sbuff_is_char((fr_sbuff_t *)(_sbuff_or_marker), fr_sbuff_current(_sbuff_or_marker), _c), \
1791 fr_sbuff_marker_t * : _fr_marker_is_char((fr_sbuff_marker_t *)(_sbuff_or_marker), fr_sbuff_current(_sbuff_or_marker), _c) \
1792 )
1793
1794#define SBUFF_IS_FUNC(_name, _test) \
1795 static inline bool _fr_sbuff_is_ ## _name(fr_sbuff_t *sbuff, char *p) \
1796 { \
1797 if (!fr_sbuff_extend(sbuff)) return false; \
1798 return _test; \
1799 }\
1800 static inline bool _fr_marker_is_ ## _name(fr_sbuff_marker_t *marker, char *p) \
1801 { \
1802 if (!fr_sbuff_extend(marker)) return false; \
1803 return _test; \
1804 }
1805
1806#define SBUFF_IS_GENERIC(_sbuff_or_marker, _name) \
1807 _Generic((_sbuff_or_marker), \
1808 fr_sbuff_t * : _fr_sbuff_is_ ## _name((fr_sbuff_t *)(_sbuff_or_marker), fr_sbuff_current(_sbuff_or_marker)), \
1809 fr_sbuff_marker_t * : _fr_marker_is_ ## _name((fr_sbuff_marker_t *)(_sbuff_or_marker), fr_sbuff_current(_sbuff_or_marker)) \
1810 )
1811
1812SBUFF_IS_FUNC(digit, isdigit((uint8_t) *p))
1813#define fr_sbuff_is_digit(_sbuff_or_marker) \
1814 SBUFF_IS_GENERIC(_sbuff_or_marker, digit)
1815
1816SBUFF_IS_FUNC(upper, isupper((uint8_t) *p))
1817#define fr_sbuff_is_upper(_sbuff_or_marker) \
1818 SBUFF_IS_GENERIC(_sbuff_or_marker, upper)
1819
1820SBUFF_IS_FUNC(lower, islower((uint8_t) *p))
1821#define fr_sbuff_is_lower(_sbuff_or_marker) \
1822 SBUFF_IS_GENERIC(_sbuff_or_marker, lower)
1823
1824SBUFF_IS_FUNC(alpha, isalpha((uint8_t) *p))
1825#define fr_sbuff_is_alpha(_sbuff_or_marker) \
1826 SBUFF_IS_GENERIC(_sbuff_or_marker, alpha)
1827
1828SBUFF_IS_FUNC(alnum, isalnum((uint8_t) *p))
1829#define fr_sbuff_is_alnum(_sbuff_or_marker) \
1830 SBUFF_IS_GENERIC(_sbuff_or_marker, alnum)
1831
1832SBUFF_IS_FUNC(space, isspace((uint8_t) *p))
1833#define fr_sbuff_is_space(_sbuff_or_marker) \
1834 SBUFF_IS_GENERIC(_sbuff_or_marker, space)
1835
1836SBUFF_IS_FUNC(hex, isxdigit((uint8_t) *p))
1837#define fr_sbuff_is_hex(_sbuff_or_marker) \
1838 SBUFF_IS_GENERIC(_sbuff_or_marker, hex)
1839
1840/** @} */
1841
1842void fr_sbuff_unescape_debug(FILE *fp, fr_sbuff_unescape_rules_t const *escapes);
1843
1844void fr_sbuff_terminal_debug(FILE *fp, fr_sbuff_term_t const *tt);
1845
1846void fr_sbuff_parse_rules_debug(FILE *fp, fr_sbuff_parse_rules_t const *p_rules);
1847
1848/*
1849 * ...printf("foo %.*s", fr_sbuff_as_percent_s(&sbuff));
1850 */
1851#define fr_sbuff_as_percent_s(_sbuff) (int) fr_sbuff_remaining(_sbuff), fr_sbuff_current(_sbuff)
1852
1853#ifdef __cplusplus
1854}
1855#endif
RCSIDH
#define RCSIDH(h, id)
Definition build.h:486
DIAG_OFF
#define DIAG_OFF(_x)
Definition build.h:459
err
static fr_slen_t err
Definition dict.h:861
escapes
static const bool escapes[UINT8_MAX+1]
Definition util.c:40
ssize_t
long int ssize_t
Definition merged_model.c:24
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
UINT8_MAX
#define UINT8_MAX
Definition merged_model.c:32
fr_sbuff_parse_error_t
fr_sbuff_parse_error_t
Definition merged_model.c:45
FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW
@ FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW
Integer type would overflow.
Definition merged_model.c:52
FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW
@ FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW
Integer type would underflow.
Definition merged_model.c:53
FR_SBUFF_PARSE_ERROR_NOT_FOUND
@ FR_SBUFF_PARSE_ERROR_NOT_FOUND
String does not contain a token matching the output type.
Definition merged_model.c:47
FR_SBUFF_PARSE_ERROR_FORMAT
@ FR_SBUFF_PARSE_ERROR_FORMAT
Format of data was invalid.
Definition merged_model.c:50
FR_SBUFF_PARSE_OK
@ FR_SBUFF_PARSE_OK
No error.
Definition merged_model.c:46
FR_SBUFF_PARSE_ERROR_OUT_OF_SPACE
@ FR_SBUFF_PARSE_ERROR_OUT_OF_SPACE
No space available in output buffer.
Definition merged_model.c:51
FR_SBUFF_PARSE_ERROR_TRAILING
@ FR_SBUFF_PARSE_ERROR_TRAILING
Trailing characters found.
Definition merged_model.c:49
fr_sbuff_escape_rules_t
Definition merged_model.c:228
fr_sbuff_t
Definition merged_model.c:37
name
static char const * name
Definition rlm_redis_ippool_tool.c:156
sbuff_char_class_float
bool const sbuff_char_class_float[UINT8_MAX+1]
Definition sbuff.c:73
sbuff_char_line_endings
bool const sbuff_char_line_endings[UINT8_MAX+1]
Definition sbuff.c:107
sbuff_char_class_hex
bool const sbuff_char_class_hex[UINT8_MAX+1]
Definition sbuff.c:97
sbuff_char_class_uint
bool const sbuff_char_class_uint[UINT8_MAX+1]
Definition sbuff.c:63
sbuff_parse_error_table_len
size_t sbuff_parse_error_table_len
Definition sbuff.c:52
sbuff_char_class_zero
bool const sbuff_char_class_zero[UINT8_MAX+1]
Definition sbuff.c:78
sbuff_char_class_hostname
bool const sbuff_char_class_hostname[UINT8_MAX+1]
Definition sbuff.c:85
sbuff_char_whitespace
bool const sbuff_char_whitespace[UINT8_MAX+1]
Definition sbuff.c:103
sbuff_char_blank
bool const sbuff_char_blank[UINT8_MAX+1]
Definition sbuff.c:111
sbuff_char_class_int
bool const sbuff_char_class_int[UINT8_MAX+1]
Definition sbuff.c:68
sbuff_parse_error_table
fr_table_num_ordered_t const sbuff_parse_error_table[]
Definition sbuff.c:43
sbuff_char_word
bool const sbuff_char_word[UINT8_MAX+1]
Definition sbuff.c:99
sbuff_char_alpha_num
bool const sbuff_char_alpha_num[UINT8_MAX+1]
Definition sbuff.c:98
fr_sbuff_uctx_talloc_t::ctx
TALLOC_CTX * ctx
Context to alloc new buffers in.
Definition sbuff.h:140
fr_sbuff_eof_t
bool(* fr_sbuff_eof_t)(fr_sbuff_t *sbuff)
For a given extension function, returns whether it is at EOF.
Definition sbuff.h:81
fr_sbuff_uctx_file_t::shifted
size_t shifted
How much we've read from this file.
Definition sbuff.h:154
fr_sbuff_s::shifted
size_t shifted
How many bytes this sbuff has been shifted since its creation.
Definition sbuff.h:118
fr_sbuff_s::extend
fr_sbuff_extend_t extend
Function to re-populate or extend the buffer.
Definition sbuff.h:121
fr_sbuff_term_elem_t::str
char const * str
Terminal string.
Definition sbuff.h:162
fr_sbuff_s::uctx
void * uctx
Extend uctx data.
Definition sbuff.h:126
fr_sbuff_uctx_talloc_t::init
size_t init
How much to allocate initially.
Definition sbuff.h:141
fr_sbuff_unescape_rules_t::chr
char chr
Character at the start of an escape sequence.
Definition sbuff.h:204
fr_sbuff_unescape_rules_t::name
char const * name
Name for rule set to aid we debugging.
Definition sbuff.h:202
fr_sbuff_unescape_rules_t::do_oct
bool do_oct
Process oct sequences i.e.
Definition sbuff.h:216
fr_sbuff_s::m
fr_sbuff_marker_t * m
Pointers to update if the underlying buffer changes.
Definition sbuff.h:130
fr_sbuff_term_t::len
size_t len
Length of the list.
Definition sbuff.h:172
fr_sbuff_s::err
char const * err
Where the last error occurred.
Definition sbuff.h:114
fr_sbuff_unescape_rules_t::do_hex
bool do_hex
Process hex sequences i.e.
Definition sbuff.h:215
fr_sbuff_uctx_talloc_t::max
size_t max
Maximum size of the buffer.
Definition sbuff.h:142
fr_sbuff_term_elem_t::len
size_t len
Length of string.
Definition sbuff.h:163
fr_sbuff_uctx_file_t::buff_end
char * buff_end
The true end of the buffer.
Definition sbuff.h:152
fr_sbuff_s::parent
fr_sbuff_t * parent
sbuff this sbuff was copied from.
Definition sbuff.h:128
fr_sbuff_s::is_const
uint8_t is_const
Can't be modified.
Definition sbuff.h:116
fr_sbuff_ptr_s::next
fr_sbuff_marker_t * next
Next m in the list.
Definition sbuff.h:89
fr_sbuff_uctx_file_t::eof
bool eof
are we at EOF?
Definition sbuff.h:155
fr_sbuff_s::adv_parent
uint8_t adv_parent
If true, advance the parent.
Definition sbuff.h:117
fr_sbuff_term_t::elem
fr_sbuff_term_elem_t * elem
A sorted list of terminal strings.
Definition sbuff.h:173
fr_slen_t
ssize_t fr_slen_t
Represents number of bytes parsed or location of parse error.
Definition sbuff.h:51
fr_sbuff_ptr_s::parent
fr_sbuff_t * parent
Owner of the marker.
Definition sbuff.h:90
fr_sbuff_s::eof
fr_sbuff_eof_t eof
Function to determine if the buffer is at EOF.
Definition sbuff.h:124
fr_sbuff_extend_t
size_t(* fr_sbuff_extend_t)(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t req_extension)
Extension callback.
Definition sbuff.h:76
fr_sbuff_uctx_file_t::file
FILE * file
FILE * we're reading from.
Definition sbuff.h:151
fr_sbuff_uctx_file_t::max
size_t max
Maximum number of bytes to read.
Definition sbuff.h:153
fr_sbuff_extend_status_t
fr_sbuff_extend_status_t
Whether the buffer is currently extendable and whether it was extended.
Definition sbuff.h:64
FR_SBUFF_FLAG_EXTEND_ERROR
@ FR_SBUFF_FLAG_EXTEND_ERROR
The last call to an extend function resulted in an error.
Definition sbuff.h:66
FR_SBUFF_FLAG_EXTENDED
@ FR_SBUFF_FLAG_EXTENDED
The last call to extend function actually extended the buffer.
Definition sbuff.h:65
fr_sbuff_ptr_s
Definition sbuff.h:84
fr_sbuff_s
Definition sbuff.h:93
fr_sbuff_term_elem_t
Terminal element with pre-calculated lengths.
Definition sbuff.h:161
fr_sbuff_term_t
Set of terminal elements.
Definition merged_model.c:161
fr_sbuff_uctx_file_t
File sbuff extension structure.
Definition sbuff.h:150
fr_sbuff_uctx_talloc_t
Talloc sbuff extension structure.
Definition sbuff.h:139
fr_sbuff_unescape_rules_t
Set of parsing rules for *unescape_until functions.
Definition merged_model.c:163
buff
static char buff[sizeof("18446744073709551615")+3]
Definition size_tests.c:41
fr_table_str_by_value
#define fr_table_str_by_value(_table, _number, _def)
Convert an integer to a string.
Definition table.h:772
fr_table_num_ordered_t
An element in an arbitrarily ordered array of name to num mappings.
Definition table.h:57
fr_strerror_const
#define fr_strerror_const(_msg)
Definition strerror.h:223
Generated by   doxygen 1.9.8