23RCSID(
"$Id: 342ef71c3a55c9d438f3f1d8d3ab48a89b72e8ab $")
25#include <freeradius-devel/util/misc.h>
26#include <freeradius-devel/util/syserror.h>
27#include <freeradius-devel/util/atexit.h>
40static_assert(
sizeof(
long long) >=
sizeof(int64_t),
"long long must be as wide or wider than an int64_t");
41static_assert(
sizeof(
unsigned long long) >=
sizeof(uint64_t),
"long long must be as wide or wider than an uint64_t");
54#if defined(STATIC_ANALYZER) || !defined(NDEBUG)
55# define CHECK_SBUFF_INIT(_sbuff) do { if (!(_sbuff)->extend && (unlikely(!(_sbuff)->buff) || unlikely(!(_sbuff)->start) || unlikely(!(_sbuff)->end) || unlikely(!(_sbuff)->p))) return 0; } while (0)
57# define CHECK_SBUFF_INIT(_sbuff)
67 [
'+'] =
true, [
'-'] =
true
72 [
'-'] =
true, [
'+'] =
true, [
'e'] =
true, [
'E'] =
true, [
'.'] =
true,
98 [
'-'] =
true, [
'_'] =
true,
101 [
'\t'] =
true, [
'\n'] =
true, [
'\r'] =
true, [
'\f'] =
true, [
'\v'] =
true, [
' '] =
true,
105 [
'\n'] =
true, [
'\r'] =
true
109 [
'\t'] =
true, [
' '] =
true,
124 char const *i_start,
char const *i_end)
127 size_t i_len = i_end - i_start;
129 if (
unlikely((o_end < o_start) || (i_end < i_start)))
return 0;
131 diff = (o_end - o_start) - (i_len);
132 if (diff < 0)
return diff;
134 if ((i_start > o_end) || (i_end < o_start)) {
135 memcpy(o_start, i_start, i_len);
137 memmove(o_start, i_start, i_len);
143static inline CC_HINT(always_inline)
size_t min(
size_t x,
size_t y)
145 return x < y ? x : y;
161 old_buff = sbuff->buff;
169 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
172 sbuff_i->buff = new_buff;
173 sbuff_i->start = new_buff +
min(new_len, sbuff_i->start - old_buff);
174 sbuff_i->end = sbuff_i->buff + new_len;
175 *(sbuff_i->end) =
'\0';
177 sbuff_i->
p = new_buff +
min(new_len, sbuff_i->
p - old_buff);
179 for (m_i = sbuff_i->m; m_i; m_i = m_i->
next) m_i->p = new_buff +
min(new_len, m_i->p - old_buff);
201 size_t max_shift = shift;
202 bool reterminate =
false;
215 reterminate = (sbuff->
p < sbuff->end) && (*sbuff->
p ==
'\0') && !sbuff->is_const;
223 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
226 max_shift =
min(max_shift, sbuff_i->
p -
buff);
227 if (!max_shift)
return 0;
229 for (m_i = sbuff_i->m; m_i; m_i = m_i->
next) {
230 max_shift =
min(max_shift, m_i->p -
buff);
231 if (!max_shift)
return 0;
242 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
244 char *start = sbuff_i->start;
246 sbuff_i->start -=
min(max_shift, sbuff_i->start -
buff);
247 sbuff_i->
p -= max_shift;
248 if (move_end) sbuff_i->end -= max_shift;
249 sbuff_i->shifted += (max_shift - (start - sbuff_i->start));
250 for (m_i = sbuff_i->m; m_i; m_i = m_i->
next) m_i->p -= max_shift;
257 if ((
buff + max_shift) < end) memmove(
buff,
buff + max_shift, end - (
buff + max_shift));
259 if (reterminate) *sbuff->
p =
'\0';
270 size_t read, available, total_read, shift;
276 if (fctx->
eof)
return 0;
278 if (extension == SIZE_MAX) extension = 0;
280 total_read = fctx->
shifted + (sbuff->end - sbuff->buff);
281 if (total_read >= fctx->
max) {
311 available = fctx->
buff_end - sbuff->end;
312 if (available > (fctx->
max - total_read)) available = fctx->
max - total_read;
313 if (available < extension) {
318 read = fread(sbuff->end, 1, available, fctx->
file);
319 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
320 sbuff_i->end += read;
325 if (read < available) {
326 if (!feof(fctx->
file)) {
360 size_t clen, nlen, elen = extension;
365 clen = sbuff->buff ? talloc_array_length(sbuff->buff) : 0;
373 if ((clen + elen) < tctx->
init) {
374 elen = (tctx->
init - clen) + 1;
379 }
else if (elen < clen) {
387 if (tctx->
max && ((clen + elen) > tctx->
max)) {
388 elen = tctx->
max - clen;
391 "%zu bytes, max is %zu bytes",
392 extension, clen + extension, tctx->
max);
399 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, nlen);
423 size_t clen = 0, nlen = 1;
429 if (sbuff->buff) clen = talloc_array_length(sbuff->buff);
431 if (len != SIZE_MAX) {
433 }
else if (sbuff->buff){
434 nlen += (sbuff->
p - sbuff->start);
438 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, nlen);
462 fr_sbuff_set_to_start(sbuff);
468 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, tctx->
init);
471 talloc_array_length(sbuff->buff), tctx->
init);
474 sbuff->buff = new_buff;
487#define FILL_OR_GOTO_DONE(_out, _in, _len) if (fr_sbuff_move(_out, _in, _len) < (size_t)(_len)) goto done
496#define CONSTRAINED_END(_sbuff, _max, _used) \
497 (((_max) - (_used)) > fr_sbuff_remaining(_sbuff) ? (_sbuff)->end : (_sbuff)->p + ((_max) - (_used)))
511 size_t i, len, max = 0;
517 for (i = 0; i < term->
len; i++) {
519 if (len > max) max = len;
524 if (i > 0) *needle_len = max;
554 if (!term)
return false;
559 if (!term_idx)
return false;
565 if ((remaining == 0) && !fr_sbuff_is_extendable(
in)) {
566 if (idx[
'\0'] != 0)
return true;
570 if (remaining < needle_len) {
572 "Caller failed to extend buffer by %zu bytes before calling fr_sbuff_terminal_search",
583 while (start <= end) {
588 elem = &term->
elem[mid];
591 ret = memcmp(p, elem->
str, tlen < (
size_t)remaining ? tlen : (
size_t)remaining);
596 if (remaining >= tlen)
return true;
611 mid = start + ((end - start) / 2);
636 for (i = 0; i < len; i++)
FR_FAULT_LOG(
"\t\"%s\" (%zu)", elem[i] ? elem[i]->str :
"NULL", elem[i] ? elem[i]->len : 0);
658#if !defined(NDEBUG) && defined(WITH_VERIFY_PTR)
671 while ((i < a->len) && (j < b->len)) {
677 tmp[num++] = &a->
elem[i++];
679 }
else if (cmp < 0) {
680 tmp[num++] = &a->
elem[i++];
682 }
else if (cmp > 0) {
683 tmp[num++] = &b->
elem[j++];
692 while (i < a->len) tmp[num++] = &a->
elem[i++];
693 while (j < b->len) tmp[num++] = &b->
elem[j++];
705 for (i = 0; i < num; i++)
out->elem[i] = *tmp[i];
707#if !defined(NDEBUG) && defined(WITH_VERIFY_PTR)
740 if (chunk_len > remaining) chunk_len = remaining;
771 fr_sbuff_marker(&m,
out);
779 fr_sbuff_marker_release(&m);
784 if (chunk_len > remaining) chunk_len = remaining;
794 fr_sbuff_marker_release(&m);
795 return -(remaining - (chunk_len + copied));
819 bool const allowed[
static UINT8_MAX + 1])
834 while ((p < end) && allowed[(
uint8_t)*p]) p++;
869 bool do_escape =
false;
872 size_t needle_len = 1;
873 char escape_chr = u_rules ? u_rules->
chr :
'\0';
894 if (escape_chr ==
'\0') {
900 }
else if (*p == escape_chr) {
942 bool do_escape =
false;
948 size_t needle_len = 1;
964 fr_sbuff_marker(&c_s, &our_in);
965 fr_sbuff_marker(&end, &our_in);
966 fr_sbuff_marker_update_end(&end, len);
968 fr_sbuff_marker(&o_s,
out);
993 fr_sbuff_marker(&m, &our_in);
996 if (fr_sbuff_out_uint8_hex(NULL, &escape, &our_in,
false) != 2) {
998 fr_sbuff_marker_release(&m);
1004 fr_sbuff_marker_release(&m);
1007 fr_sbuff_marker_release(&m);
1019 fr_sbuff_marker(&m, &our_in);
1021 if (fr_sbuff_out_uint8_oct(NULL, &escape, &our_in,
false) != 3) {
1023 fr_sbuff_marker_release(&m);
1029 fr_sbuff_marker_release(&m);
1032 fr_sbuff_marker_release(&m);
1046 if (u_rules->
subs[c] ==
'\0') {
1047 if (u_rules->
skip[c] ==
true)
goto next;
1100 return fr_sbuff_marker_release_behind(&o_s);
1115 static bool const bool_prefix[
UINT8_MAX + 1] = {
1116 [
't'] =
true, [
'T'] =
true,
1117 [
'f'] =
true, [
'F'] =
true,
1118 [
'y'] =
true, [
'Y'] =
true,
1119 [
'n'] =
true, [
'N'] =
true,
1122 if (fr_sbuff_is_in_charset(&our_in, bool_prefix)) {
1159 fr_strerror_const(
"Not a valid boolean value. Accepted values are 'yes', 'no', 'true', 'false'");
1175#define SBUFF_PARSE_INT_DEF(_name, _type, _min, _max, _max_char, _base) \
1176fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1178 char buff[_max_char + 1]; \
1179 char *end, *a_end; \
1183 fr_sbuff_t our_in = FR_SBUFF(in); \
1185 len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
1187 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1191 num = strtoll(buff, &end, _base); \
1192 cast_num = (_type)(num); \
1193 if (end == buff) { \
1194 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1197 if (num > cast_num) { \
1199 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1200 *out = (_type)(_max); \
1203 if (((errno == EINVAL) && (num == 0)) || ((errno == ERANGE) && (num == LLONG_MAX))) goto overflow; \
1204 if (num < cast_num) { \
1206 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1207 *out = (_type)(_min); \
1210 if ((errno == ERANGE) && (num == LLONG_MIN)) goto underflow; \
1211 if (no_trailing && (((a_end = in->p + (end - buff)) + 1) < in->end)) { \
1212 if (isdigit((uint8_t) *a_end) || (((_base > 10) || ((_base == 0) && (len > 2) && (buff[0] == '0') && (buff[1] == 'x'))) && \
1213 ((tolower((uint8_t) *a_end) >= 'a') && (tolower((uint8_t) *a_end) <= 'f')))) { \
1214 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1215 *out = (_type)(_max); \
1216 FR_SBUFF_ERROR_RETURN(&our_in); \
1220 if (err) *err = FR_SBUFF_PARSE_OK; \
1223 return fr_sbuff_advance(in, end - buff); \
1242#define SBUFF_PARSE_UINT_DEF(_name, _type, _max, _max_char, _base) \
1243fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1245 char buff[_max_char + 1]; \
1246 char *end, *a_end; \
1248 unsigned long long num; \
1250 fr_sbuff_t our_in = FR_SBUFF(in); \
1252 len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
1254 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1257 if (buff[0] == '-') { \
1258 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1262 num = strtoull(buff, &end, _base); \
1263 cast_num = (_type)(num); \
1264 if (end == buff) { \
1265 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1268 if (num > cast_num) { \
1270 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1271 *out = (_type)(_max); \
1274 if (((errno == EINVAL) && (num == 0)) || ((errno == ERANGE) && (num == ULLONG_MAX))) goto overflow; \
1275 if (no_trailing && (((a_end = in->p + (end - buff)) + 1) < in->end)) { \
1276 if (isdigit((uint8_t) *a_end) || (((_base > 10) || ((_base == 0) && (len > 2) && (buff[0] == '0') && (buff[1] == 'x'))) && \
1277 ((tolower((uint8_t) *a_end) >= 'a') && (tolower((uint8_t) *a_end) <= 'f')))) { \
1278 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1279 *out = (_type)(_max); \
1280 FR_SBUFF_ERROR_RETURN(&our_in); \
1282 if (err) *err = FR_SBUFF_PARSE_OK; \
1285 if (err) *err = FR_SBUFF_PARSE_OK; \
1288 return fr_sbuff_advance(in, end - buff); \
1326#define SBUFF_PARSE_FLOAT_DEF(_name, _type, _func, _max_char) \
1327fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1329 char buff[_max_char + 1] = ""; \
1331 fr_sbuff_t our_in = FR_SBUFF(in); \
1334 len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(buff, sizeof(buff)), &our_in, SIZE_MAX, sbuff_char_class_float); \
1335 if (len == sizeof(buff)) { \
1336 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1338 } else if (len == 0) { \
1339 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1343 res = _func(buff, &end); \
1344 if (errno == ERANGE) { \
1346 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1348 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1352 if (no_trailing && (*end != '\0')) { \
1353 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1354 FR_SBUFF_ERROR_RETURN(&our_in); \
1357 return fr_sbuff_advance(in, end - buff); \
1381 size_t to_copy = len;
1382 if (to_copy > o_remaining) to_copy = o_remaining;
1383 if (to_copy > i_remaining) to_copy = i_remaining;
1401 size_t to_copy = len;
1402 if (to_copy > o_remaining) to_copy = o_remaining;
1403 if (to_copy > i_remaining) to_copy = i_remaining;
1421 size_t to_copy = len;
1422 if (to_copy > o_remaining) to_copy = o_remaining;
1423 if (to_copy > i_remaining) to_copy = i_remaining;
1441 size_t to_copy = len;
1442 if (to_copy > o_remaining) to_copy = o_remaining;
1443 if (to_copy > i_remaining) to_copy = i_remaining;
1462 if (
unlikely(sbuff->is_const))
return 0;
1467 safecpy(sbuff->
p, sbuff->end, str, str + len);
1468 sbuff->
p[len] =
'\0';
1486 if (
unlikely(sbuff->is_const))
return 0;
1490 safecpy(sbuff->
p, sbuff->end, str, str + len);
1491 sbuff->
p[len] =
'\0';
1510 if (
unlikely(sbuff->is_const))
return 0;
1512 len = talloc_array_length(str) - 1;
1516 safecpy(sbuff->
p, sbuff->end, str, str + len);
1517 sbuff->
p[len] =
'\0';
1533 TALLOC_CTX *scratch;
1542 scratch = talloc_pool(NULL, 4096);
1566 TALLOC_CTX *scratch;
1573 if (
unlikely(sbuff->is_const))
return 0;
1602 if (
unlikely(sbuff->is_const))
return 0;
1633 if (
unlikely(sbuff->is_const))
return 0;
1656 sub = e_rules->subs[c];
1667 if (e_rules->esc[c]) {
1672 if (e_rules->do_oct) {
1675 }
else if (e_rules->do_hex) {
1701 if (
unlikely(sbuff->is_const))
return 0;
1720 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
1729 found = memmem(sbuff->
p, needle_len, needle, needle_len);
1730 if (!found)
return 0;
1747 char const *p, *n_p;
1752 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
1762 end = p + needle_len;
1764 for (p = sbuff->
p, n_p = needle; p < end; p++, n_p++) {
1785 size_t needle_len = 0;
1791 while (total < len) {
1798 while ((p < end) && allowed[(
uint8_t)*p]) {
1799 if (needle_len == 0) {
1839 if (p != end)
break;
1858 bool do_escape =
false;
1861 size_t needle_len = 1;
1871 while (total < len) {
1879 if (escape_chr ==
'\0') {
1885 }
else if (*p == escape_chr) {
1895 if (p != end)
break;
1917 size_t clen = strlen(chr);
1924 if (len < clen)
return NULL;
1926 while (total <= (len - clen)) {
1965 while (total < len) {
1972 found = memchr(our_sbuff.
p, c, end - our_sbuff.
p);
2001 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
2002 if (!needle_len)
return 0;
2007 if (len < needle_len)
return NULL;
2009 while (total <= (len - needle_len)) {
2020 found = memmem(our_sbuff.
p, end - our_sbuff.
p, needle, needle_len);
2031 total +=
fr_sbuff_set(&our_sbuff, (end - needle_len) + 1);
2054 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
2055 if (!needle_len)
return 0;
2060 if (len < needle_len)
return NULL;
2062 while (total <= (len - needle_len)) {
2068 for (p = our_sbuff.
p, n_p = needle, end = our_sbuff.
p + needle_len;
2096 if (*sbuff->
p != c)
return false;
2117 if (*sbuff->
p == c)
return false;
2132 char *p = sbuff->
p - 1;
2135 while ((p >= sbuff->start) && to_trim[(
uint8_t)*p]) p--;
2138 if (slen != 0) fr_sbuff_terminate(sbuff);
2157 size_t needle_len = 1;
2189 static bool const unprintables[
UINT8_MAX + 1] = {
2194 static _Thread_local
char str[10][5];
2195 static _Thread_local
size_t i = 0;
2222 if (unprintables[(
uint8_t)c]) {
2223 snprintf(str[i],
sizeof(str[i]),
"\\x%x", c);
2268 if (p_rules->escapes) {
2275 if (p_rules->terminals) {
static int const char * fmt
#define fr_atexit_thread_local(_name, _free, _uctx)
#define MEMCMP_RETURN(_a, _b, _field, _len_field)
Return if the contents of the specified field is not identical between the specified structures.
#define L(_str)
Helper for initialising arrays of string literals.
#define fr_assert_msg(_x, _msg,...)
Calls panic_action ifndef NDEBUG, else logs error and causes the server to exit immediately with code...
#define FR_FAULT_LOG(_fmt,...)
static const bool escapes[UINT8_MAX+1]
@ FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW
Integer type would overflow.
@ FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW
Integer type would underflow.
@ FR_SBUFF_PARSE_ERROR_NOT_FOUND
String does not contain a token matching the output type.
@ FR_SBUFF_PARSE_ERROR_FORMAT
Format of data was invalid.
@ FR_SBUFF_PARSE_OK
No error.
@ FR_SBUFF_PARSE_ERROR_OUT_OF_SPACE
No space available in output buffer.
@ FR_SBUFF_PARSE_ERROR_TRAILING
Trailing characters found.
char const * fr_utf8_strchr(int *out_chr_len, char const *str, ssize_t inlen, char const *chr)
Return a pointer to the first UTF8 char in a string.
size_t fr_utf8_char(uint8_t const *str, ssize_t inlen)
Checks for utf-8, taken from http://www.w3.org/International/questions/qa-forms-utf-8.
char * fr_vasprintf(TALLOC_CTX *ctx, char const *fmt, va_list ap)
int fr_sbuff_trim_talloc(fr_sbuff_t *sbuff, size_t len)
Trim a talloced sbuff to the minimum length required to represent the contained string.
ssize_t fr_sbuff_in_strcpy(fr_sbuff_t *sbuff, char const *str)
Copy bytes into the sbuff up to the first \0.
#define SBUFF_PARSE_FLOAT_DEF(_name, _type, _func, _max_char)
Used to define a number parsing functions for floats.
size_t fr_sbuff_adv_past_allowed(fr_sbuff_t *sbuff, size_t len, bool const allowed[static UINT8_MAX+1], fr_sbuff_term_t const *tt)
Wind position past characters in the allowed set.
ssize_t fr_sbuff_in_escape(fr_sbuff_t *sbuff, char const *in, size_t inlen, fr_sbuff_escape_rules_t const *e_rules)
Print an escaped string to an sbuff.
bool const sbuff_char_class_float[UINT8_MAX+1]
static _Thread_local char * sbuff_scratch
#define FILL_OR_GOTO_DONE(_out, _in, _len)
Fill as much of the output buffer we can and break on partial copy.
char * fr_sbuff_adv_to_chr_utf8(fr_sbuff_t *sbuff, size_t len, char const *chr)
Wind position to first instance of specified multibyte utf8 char.
size_t fr_sbuff_extend_talloc(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t extension)
Reallocate the current buffer.
bool fr_sbuff_eof_file(fr_sbuff_t *sbuff)
Accessor function for the EOF state of the file extendor.
#define SBUFF_PARSE_UINT_DEF(_name, _type, _max, _max_char, _base)
Used to define a number parsing functions for signed integers.
size_t fr_sbuff_out_unescape_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len, fr_sbuff_term_t const *tt, fr_sbuff_unescape_rules_t const *u_rules)
Copy as many allowed characters as possible from a sbuff to a sbuff.
static bool fr_sbuff_terminal_search(fr_sbuff_t *in, char const *p, uint8_t idx[static UINT8_MAX+1], fr_sbuff_term_t const *term, size_t needle_len)
Efficient terminal string search.
#define CHECK_SBUFF_INIT(_sbuff)
void fr_sbuff_terminal_debug(fr_sbuff_term_t const *tt)
void fr_sbuff_update(fr_sbuff_t *sbuff, char *new_buff, size_t new_len)
Update all markers and pointers in the set of sbuffs to point to new_buff.
static int sbuff_scratch_init(TALLOC_CTX **out)
bool const sbuff_char_line_endings[UINT8_MAX+1]
bool const sbuff_char_class_hex[UINT8_MAX+1]
char * fr_sbuff_adv_to_str(fr_sbuff_t *sbuff, size_t len, char const *needle, size_t needle_len)
Wind position to the first instance of the specified needle.
bool const sbuff_char_class_uint[UINT8_MAX+1]
void fr_sbuff_unescape_debug(fr_sbuff_unescape_rules_t const *escapes)
size_t _fr_sbuff_move_marker_to_sbuff(fr_sbuff_t *out, fr_sbuff_marker_t *in, size_t len)
Move data from a marker to an sbuff.
size_t sbuff_parse_error_table_len
ssize_t fr_sbuff_in_escape_buffer(fr_sbuff_t *sbuff, char const *in, fr_sbuff_escape_rules_t const *e_rules)
Print an escaped string to an sbuff taking a talloced buffer as input.
char * fr_sbuff_adv_to_strcase(fr_sbuff_t *sbuff, size_t len, char const *needle, size_t needle_len)
Wind position to the first instance of the specified needle.
static size_t min(size_t x, size_t y)
size_t fr_sbuff_extend_file(fr_sbuff_extend_status_t *status, fr_sbuff_t *sbuff, size_t extension)
Refresh the buffer with more data from the file.
void fr_sbuff_parse_rules_debug(fr_sbuff_parse_rules_t const *p_rules)
ssize_t fr_sbuff_out_bstrncpy_exact(fr_sbuff_t *out, fr_sbuff_t *in, size_t len)
Copy exactly len bytes from a sbuff to a sbuff or fail.
size_t fr_sbuff_adv_past_str(fr_sbuff_t *sbuff, char const *needle, size_t needle_len)
Return true and advance past the end of the needle if needle occurs next in the sbuff.
bool const sbuff_char_class_zero[UINT8_MAX+1]
size_t fr_sbuff_trim(fr_sbuff_t *sbuff, bool const to_trim[static UINT8_MAX+1])
Trim trailing characters from a string we're composing.
size_t fr_sbuff_shift(fr_sbuff_t *sbuff, size_t shift, bool move_end)
Shift the contents of the sbuff, returning the number of bytes we managed to shift.
size_t fr_sbuff_out_bstrncpy_until(fr_sbuff_t *out, fr_sbuff_t *in, size_t len, fr_sbuff_term_t const *tt, fr_sbuff_unescape_rules_t const *u_rules)
Copy as many allowed characters as possible from a sbuff to a sbuff.
char * fr_sbuff_adv_to_chr(fr_sbuff_t *sbuff, size_t len, char c)
Wind position to first instance of specified char.
bool const sbuff_char_class_hostname[UINT8_MAX+1]
int fr_sbuff_reset_talloc(fr_sbuff_t *sbuff)
Reset a talloced buffer to its initial length, clearing any data stored.
static char const * sbuff_print_char(char c)
Print a char in a friendly format.
bool fr_sbuff_is_terminal(fr_sbuff_t *in, fr_sbuff_term_t const *tt)
Efficient terminal string search.
fr_slen_t fr_sbuff_out_bool(bool *out, fr_sbuff_t *in)
See if the string contains a truth value.
size_t _fr_sbuff_move_marker_to_marker(fr_sbuff_marker_t *out, fr_sbuff_marker_t *in, size_t len)
Move data from one marker to another.
size_t _fr_sbuff_move_sbuff_to_marker(fr_sbuff_marker_t *out, fr_sbuff_t *in, size_t len)
Move data from an sbuff to a marker.
ssize_t fr_sbuff_in_bstrncpy(fr_sbuff_t *sbuff, char const *str, size_t len)
Copy bytes into the sbuff up to the first \0.
size_t fr_sbuff_adv_past_strcase(fr_sbuff_t *sbuff, char const *needle, size_t needle_len)
Return true and advance past the end of the needle if needle occurs next in the sbuff.
static ssize_t safecpy(char *o_start, char *o_end, char const *i_start, char const *i_end)
Copy function that allows overlapping memory ranges to be copied.
bool fr_sbuff_next_unless_char(fr_sbuff_t *sbuff, char c)
Return true and advance if the next char does not match.
size_t fr_sbuff_adv_until(fr_sbuff_t *sbuff, size_t len, fr_sbuff_term_t const *tt, char escape_chr)
Wind position until we hit a character in the terminal set.
#define CONSTRAINED_END(_sbuff, _max, _used)
Constrain end pointer to prevent advancing more than the amount the caller specified.
static int8_t terminal_cmp(fr_sbuff_term_elem_t const *a, fr_sbuff_term_elem_t const *b)
Compare two terminal elements for ordering purposes.
static void fr_sbuff_terminal_idx_init(size_t *needle_len, uint8_t idx[static UINT8_MAX+1], fr_sbuff_term_t const *term)
Populate a terminal index.
bool const sbuff_char_whitespace[UINT8_MAX+1]
ssize_t fr_sbuff_in_bstrcpy_buffer(fr_sbuff_t *sbuff, char const *str)
Copy bytes into the sbuff up to the first \0.
size_t fr_sbuff_out_bstrncpy(fr_sbuff_t *out, fr_sbuff_t *in, size_t len)
Copy as many bytes as possible from a sbuff to a sbuff.
bool const sbuff_char_blank[UINT8_MAX+1]
fr_sbuff_term_t * fr_sbuff_terminals_amerge(TALLOC_CTX *ctx, fr_sbuff_term_t const *a, fr_sbuff_term_t const *b)
Merge two sets of terminal strings.
size_t _fr_sbuff_move_sbuff_to_sbuff(fr_sbuff_t *out, fr_sbuff_t *in, size_t len)
Move data from one sbuff to another.
#define SBUFF_PARSE_INT_DEF(_name, _type, _min, _max, _max_char, _base)
Used to define a number parsing functions for signed integers.
bool const sbuff_char_class_int[UINT8_MAX+1]
fr_table_num_ordered_t const sbuff_parse_error_table[]
ssize_t fr_sbuff_in_sprintf(fr_sbuff_t *sbuff, char const *fmt,...)
Print using a fmt string to an sbuff.
bool fr_sbuff_next_if_char(fr_sbuff_t *sbuff, char c)
Return true if the current char matches, and if it does, advance.
bool const sbuff_char_word[UINT8_MAX+1]
bool const sbuff_char_alpha_num[UINT8_MAX+1]
static _Thread_local bool sbuff_scratch_freed
When true, prevent use of the scratch space.
size_t fr_sbuff_out_bstrncpy_allowed(fr_sbuff_t *out, fr_sbuff_t *in, size_t len, bool const allowed[static UINT8_MAX+1])
Copy as many allowed characters as possible from a sbuff to a sbuff.
ssize_t fr_sbuff_in_vsprintf(fr_sbuff_t *sbuff, char const *fmt, va_list ap)
Print using a fmt string to an sbuff.
static int _sbuff_scratch_free(void *arg)
Free the scratch buffer used for printf.
TALLOC_CTX * ctx
Context to alloc new buffers in.
#define SBUFF_CHAR_CLASS_HEX
bool skip[UINT8_MAX+1]
Characters that are escaped, but left in the output along with the escape character.
#define SBUFF_CHAR_CLASS_NUM
#define FR_SBUFF_IN_CHAR_RETURN(_sbuff,...)
#define fr_sbuff_set(_dst, _src)
#define fr_sbuff_diff(_a, _b)
size_t shifted
How much we've read from this file.
#define FR_SBUFF_BIND_CURRENT(_sbuff_or_marker)
#define fr_sbuff_adv_past_strcase_literal(_sbuff, _needle)
#define fr_sbuff_was_extended(_status)
char const * str
Terminal string.
#define fr_sbuff_current(_sbuff_or_marker)
#define fr_sbuff_char(_sbuff_or_marker, _eob)
size_t init
How much to allocate initially.
char chr
Character at the start of an escape sequence.
bool do_oct
Process oct sequences i.e.
#define fr_sbuff_extend(_sbuff_or_marker)
#define fr_sbuff_buff(_sbuff_or_marker)
#define fr_sbuff_used_total(_sbuff_or_marker)
size_t len
Length of the list.
#define SBUFF_CHAR_CLASS_ALPHA_NUM
#define fr_sbuff_is_char(_sbuff_or_marker, _c)
#define FR_SBUFF_SET_RETURN(_dst, _src)
#define fr_sbuff_is_digit(_sbuff_or_marker)
#define FR_SBUFF_IN_SPRINTF_RETURN(...)
bool do_hex
Process hex sequences i.e.
size_t max
Maximum size of the buffer.
#define fr_sbuff_end(_sbuff_or_marker)
#define SBUFF_CHAR_UNPRINTABLES_EXTENDED
#define FR_SBUFF(_sbuff_or_marker)
size_t len
Length of string.
#define FR_SBUFF_IN_BSTRNCPY_RETURN(...)
#define fr_sbuff_advance(_sbuff_or_marker, _len)
char * buff_end
The true end of the buffer.
#define fr_sbuff_remaining(_sbuff_or_marker)
#define FR_SBUFF_EXTEND_LOWAT_OR_RETURN(_sbuff, _len)
char subs[UINT8_MAX+1]
Special characters and their substitutions.
#define SBUFF_CHAR_UNPRINTABLES_LOW
fr_sbuff_marker_t * next
Next m in the list.
#define fr_sbuff_used(_sbuff_or_marker)
fr_sbuff_term_elem_t * elem
A sorted list of terminal strings.
#define fr_sbuff_behind(_sbuff_or_marker)
#define fr_sbuff_extend_lowat(_status, _sbuff_or_marker, _lowat)
FILE * file
FILE * we're reading from.
size_t max
Maximum number of bytes to read.
fr_sbuff_extend_status_t
Whether the buffer is currently extendable and whether it was extended.
@ FR_SBUFF_FLAG_EXTEND_ERROR
The last call to an extend function resulted in an error.
#define fr_sbuff_in_char(_sbuff,...)
Terminal element with pre-calculated lengths.
Set of terminal elements.
File sbuff extension structure.
Talloc sbuff extension structure.
Set of parsing rules for *unescape_until functions.
static char buff[sizeof("18446744073709551615")+3]
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
An element in an arbitrarily ordered array of name to num mappings.
#define talloc_pooled_object(_ctx, _type, _num_subobjects, _total_subobjects_size)
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
#define fr_strerror_const(_msg)
static size_t char fr_sbuff_t size_t inlen
static size_t char ** out