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