23RCSID(
"$Id: 50f338084e38c11d9e1de8d2f667be97166c4102 $")
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)
56# define CHECK_SBUFF_WRITEABLE(_sbuff) do { CHECK_SBUFF_INIT(_sbuff); if (unlikely((_sbuff)->is_const)) return 0; } while (0)
59# define CHECK_SBUFF_INIT(_sbuff)
60# define CHECK_SBUFF_WRITEABLE(_sbuff)
70 [
'+'] =
true, [
'-'] =
true
75 [
'-'] =
true, [
'+'] =
true, [
'e'] =
true, [
'E'] =
true, [
'.'] =
true,
101 [
'-'] =
true, [
'_'] =
true,
104 [
'\t'] =
true, [
'\n'] =
true, [
'\r'] =
true, [
'\f'] =
true, [
'\v'] =
true, [
' '] =
true,
108 [
'\n'] =
true, [
'\r'] =
true
112 [
'\t'] =
true, [
' '] =
true,
127 char const *i_start,
char const *i_end)
130 size_t i_len = i_end - i_start;
132 if (
unlikely((o_end < o_start) || (i_end < i_start)))
return 0;
134 diff = (o_end - o_start) - (i_len);
135 if (diff < 0)
return diff;
137 if ((i_start > o_end) || (i_end < o_start)) {
138 memcpy(o_start, i_start, i_len);
140 memmove(o_start, i_start, i_len);
146static inline CC_HINT(always_inline)
size_t min(
size_t x,
size_t y)
148 return x < y ? x : y;
164 old_buff = sbuff->buff;
172 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
175 sbuff_i->buff = new_buff;
176 sbuff_i->start = new_buff +
min(new_len, sbuff_i->start - old_buff);
177 sbuff_i->end = sbuff_i->buff + new_len;
178 *(sbuff_i->end) =
'\0';
180 sbuff_i->
p = new_buff +
min(new_len, sbuff_i->
p - old_buff);
182 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);
204 size_t max_shift = shift;
205 bool reterminate =
false;
218 reterminate = (sbuff->
p < sbuff->end) && (*sbuff->
p ==
'\0') && !sbuff->is_const;
226 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
229 max_shift =
min(max_shift, sbuff_i->
p -
buff);
230 if (!max_shift)
return 0;
232 for (m_i = sbuff_i->m; m_i; m_i = m_i->
next) {
233 max_shift =
min(max_shift, m_i->p -
buff);
234 if (!max_shift)
return 0;
245 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
247 char *start = sbuff_i->start;
249 sbuff_i->start -=
min(max_shift, sbuff_i->start -
buff);
250 sbuff_i->
p -= max_shift;
251 if (move_end) sbuff_i->end -= max_shift;
252 sbuff_i->shifted += (max_shift - (start - sbuff_i->start));
253 for (m_i = sbuff_i->m; m_i; m_i = m_i->
next) m_i->p -= max_shift;
260 if ((
buff + max_shift) < end) memmove(
buff,
buff + max_shift, end - (
buff + max_shift));
262 if (reterminate) *sbuff->
p =
'\0';
273 size_t read, available, total_read, shift;
279 if (fctx->
eof)
return 0;
281 if (extension == SIZE_MAX) extension = 0;
283 total_read = fctx->
shifted + (sbuff->end - sbuff->buff);
284 if (total_read >= fctx->
max) {
314 available = fctx->
buff_end - sbuff->end;
315 if (available > (fctx->
max - total_read)) available = fctx->
max - total_read;
316 if (available < extension) {
321 read = fread(sbuff->end, 1, available, fctx->
file);
322 for (sbuff_i = sbuff; sbuff_i; sbuff_i = sbuff_i->parent) {
323 sbuff_i->end += read;
328 if (read < available) {
329 if (!feof(fctx->
file)) {
363 size_t clen, nlen, elen = extension;
368 clen = sbuff->buff ? talloc_array_length(sbuff->buff) : 0;
376 if ((clen + elen) < tctx->
init) {
377 elen = (tctx->
init - clen) + 1;
382 }
else if (elen < clen) {
390 if (tctx->
max && ((clen + elen) > tctx->
max)) {
391 elen = tctx->
max - clen;
394 "%zu bytes, max is %zu bytes",
395 extension, clen + extension, tctx->
max);
402 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, nlen);
426 size_t clen = 0, nlen = 1;
432 if (sbuff->buff) clen = talloc_array_length(sbuff->buff);
434 if (len != SIZE_MAX) {
436 }
else if (sbuff->buff){
437 nlen += (sbuff->
p - sbuff->start);
441 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, nlen);
465 fr_sbuff_set_to_start(sbuff);
471 new_buff = talloc_realloc(tctx->
ctx, sbuff->buff,
char, tctx->
init);
474 talloc_array_length(sbuff->buff), tctx->
init);
477 sbuff->buff = new_buff;
490#define FILL_OR_GOTO_DONE(_out, _in, _len) if (fr_sbuff_move(_out, _in, _len) < (size_t)(_len)) goto done
499#define CONSTRAINED_END(_sbuff, _max, _used) \
500 (((_max) - (_used)) > fr_sbuff_remaining(_sbuff) ? (_sbuff)->end : (_sbuff)->p + ((_max) - (_used)))
514 size_t i, len, max = 0;
520 for (i = 0; i < term->
len; i++) {
522 if (len > max) max = len;
527 if (i > 0) *needle_len = max;
557 if (!term)
return false;
562 if (!term_idx)
return false;
568 if ((remaining == 0) && !fr_sbuff_is_extendable(
in)) {
569 if (idx[
'\0'] != 0)
return true;
573 if (remaining < needle_len) {
575 "Caller failed to extend buffer by %zu bytes before calling fr_sbuff_terminal_search",
586 while (start <= end) {
591 elem = &term->
elem[mid];
594 ret = memcmp(p, elem->
str, tlen < (
size_t)remaining ? tlen : (
size_t)remaining);
599 if (remaining >= tlen)
return true;
614 mid = start + ((end - start) / 2);
639 for (i = 0; i < len; i++)
FR_FAULT_LOG(
"\t\"%s\" (%zu)", elem[i] ? elem[i]->str :
"NULL", elem[i] ? elem[i]->len : 0);
661#if !defined(NDEBUG) && defined(WITH_VERIFY_PTR)
674 while ((i < a->len) && (j < b->len)) {
680 tmp[num++] = &a->
elem[i++];
682 }
else if (cmp < 0) {
683 tmp[num++] = &a->
elem[i++];
685 }
else if (cmp > 0) {
686 tmp[num++] = &b->
elem[j++];
695 while (i < a->len) tmp[num++] = &a->
elem[i++];
696 while (j < b->len) tmp[num++] = &b->
elem[j++];
708 for (i = 0; i < num; i++)
out->elem[i] = *tmp[i];
710#if !defined(NDEBUG) && defined(WITH_VERIFY_PTR)
743 if (chunk_len > remaining) chunk_len = remaining;
774 fr_sbuff_marker(&m,
out);
782 fr_sbuff_marker_release(&m);
787 if (chunk_len > remaining) chunk_len = remaining;
797 fr_sbuff_marker_release(&m);
798 return -(remaining - (chunk_len + copied));
822 bool const allowed[
static UINT8_MAX + 1])
837 while ((p < end) && allowed[(
uint8_t)*p]) p++;
872 bool do_escape =
false;
875 size_t needle_len = 1;
876 char escape_chr = u_rules ? u_rules->
chr :
'\0';
897 if (escape_chr ==
'\0') {
903 }
else if (*p == escape_chr) {
945 bool do_escape =
false;
951 size_t needle_len = 1;
967 fr_sbuff_marker(&c_s, &our_in);
968 fr_sbuff_marker(&end, &our_in);
969 fr_sbuff_marker_update_end(&end, len);
971 fr_sbuff_marker(&o_s,
out);
996 fr_sbuff_marker(&m, &our_in);
999 if (fr_sbuff_out_uint8_hex(NULL, &escape, &our_in,
false) != 2) {
1001 fr_sbuff_marker_release(&m);
1007 fr_sbuff_marker_release(&m);
1010 fr_sbuff_marker_release(&m);
1022 fr_sbuff_marker(&m, &our_in);
1024 if (fr_sbuff_out_uint8_oct(NULL, &escape, &our_in,
false) != 3) {
1026 fr_sbuff_marker_release(&m);
1032 fr_sbuff_marker_release(&m);
1035 fr_sbuff_marker_release(&m);
1049 if (u_rules->
subs[c] ==
'\0') {
1050 if (u_rules->
skip[c] ==
true)
goto next;
1103 return fr_sbuff_marker_release_behind(&o_s);
1118 static bool const bool_prefix[
UINT8_MAX + 1] = {
1119 [
't'] =
true, [
'T'] =
true,
1120 [
'f'] =
true, [
'F'] =
true,
1121 [
'y'] =
true, [
'Y'] =
true,
1122 [
'n'] =
true, [
'N'] =
true,
1125 if (fr_sbuff_is_in_charset(&our_in, bool_prefix)) {
1162 fr_strerror_const(
"Not a valid boolean value. Accepted values are 'yes', 'no', 'true', 'false'");
1178#define SBUFF_PARSE_INT_DEF(_name, _type, _min, _max, _max_char, _base) \
1179fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1181 char buff[_max_char + 1]; \
1182 char *end, *a_end; \
1186 fr_sbuff_t our_in = FR_SBUFF(in); \
1188 len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
1190 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1194 num = strtoll(buff, &end, _base); \
1195 cast_num = (_type)(num); \
1196 if (end == buff) { \
1197 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1200 if (num > cast_num) { \
1202 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1203 *out = (_type)(_max); \
1206 if (((errno == EINVAL) && (num == 0)) || ((errno == ERANGE) && (num == LLONG_MAX))) goto overflow; \
1207 if (num < cast_num) { \
1209 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1210 *out = (_type)(_min); \
1213 if ((errno == ERANGE) && (num == LLONG_MIN)) goto underflow; \
1214 if (no_trailing && (((a_end = in->p + (end - buff)) + 1) < in->end)) { \
1215 if (isdigit((uint8_t) *a_end) || (((_base > 10) || ((_base == 0) && (len > 2) && (buff[0] == '0') && (buff[1] == 'x'))) && \
1216 ((tolower((uint8_t) *a_end) >= 'a') && (tolower((uint8_t) *a_end) <= 'f')))) { \
1217 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1218 *out = (_type)(_max); \
1219 FR_SBUFF_ERROR_RETURN(&our_in); \
1223 if (err) *err = FR_SBUFF_PARSE_OK; \
1226 return fr_sbuff_advance(in, end - buff); \
1245#define SBUFF_PARSE_UINT_DEF(_name, _type, _max, _max_char, _base) \
1246fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1248 char buff[_max_char + 1]; \
1249 char *end, *a_end; \
1251 unsigned long long num; \
1253 fr_sbuff_t our_in = FR_SBUFF(in); \
1255 len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
1257 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1260 if (buff[0] == '-') { \
1261 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1265 num = strtoull(buff, &end, _base); \
1266 cast_num = (_type)(num); \
1267 if (end == buff) { \
1268 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1271 if (num > cast_num) { \
1273 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1274 *out = (_type)(_max); \
1277 if (((errno == EINVAL) && (num == 0)) || ((errno == ERANGE) && (num == ULLONG_MAX))) goto overflow; \
1278 if (no_trailing && (((a_end = in->p + (end - buff)) + 1) < in->end)) { \
1279 if (isdigit((uint8_t) *a_end) || (((_base > 10) || ((_base == 0) && (len > 2) && (buff[0] == '0') && (buff[1] == 'x'))) && \
1280 ((tolower((uint8_t) *a_end) >= 'a') && (tolower((uint8_t) *a_end) <= 'f')))) { \
1281 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1282 *out = (_type)(_max); \
1283 FR_SBUFF_ERROR_RETURN(&our_in); \
1285 if (err) *err = FR_SBUFF_PARSE_OK; \
1288 if (err) *err = FR_SBUFF_PARSE_OK; \
1291 return fr_sbuff_advance(in, end - buff); \
1329#define SBUFF_PARSE_FLOAT_DEF(_name, _type, _func, _max_char) \
1330fr_slen_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t *in, bool no_trailing) \
1332 char buff[_max_char + 1] = ""; \
1334 fr_sbuff_t our_in = FR_SBUFF(in); \
1337 len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(buff, sizeof(buff)), &our_in, SIZE_MAX, sbuff_char_class_float); \
1338 if (len == sizeof(buff)) { \
1339 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1341 } else if (len == 0) { \
1342 if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
1346 res = _func(buff, &end); \
1347 if (errno == ERANGE) { \
1349 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_OVERFLOW; \
1351 if (err) *err = FR_SBUFF_PARSE_ERROR_NUM_UNDERFLOW; \
1355 if (no_trailing && (*end != '\0')) { \
1356 if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
1357 FR_SBUFF_ERROR_RETURN(&our_in); \
1360 return fr_sbuff_advance(in, end - buff); \
1384 size_t to_copy = len;
1385 if (to_copy > o_remaining) to_copy = o_remaining;
1386 if (to_copy > i_remaining) to_copy = i_remaining;
1404 size_t to_copy = len;
1405 if (to_copy > o_remaining) to_copy = o_remaining;
1406 if (to_copy > i_remaining) to_copy = i_remaining;
1424 size_t to_copy = len;
1425 if (to_copy > o_remaining) to_copy = o_remaining;
1426 if (to_copy > i_remaining) to_copy = i_remaining;
1444 size_t to_copy = len;
1445 if (to_copy > o_remaining) to_copy = o_remaining;
1446 if (to_copy > i_remaining) to_copy = i_remaining;
1468 safecpy(sbuff->
p, sbuff->end, str, str + len);
1469 sbuff->
p[len] =
'\0';
1489 safecpy(sbuff->
p, sbuff->end, str, str + len);
1490 sbuff->
p[len] =
'\0';
1509 len = talloc_array_length(str) - 1;
1513 safecpy(sbuff->
p, sbuff->end, str, str + len);
1514 sbuff->
p[len] =
'\0';
1530 TALLOC_CTX *scratch;
1539 scratch = talloc_pool(NULL, 4096);
1563 TALLOC_CTX *scratch;
1649 sub = e_rules->subs[c];
1660 if (e_rules->esc[c]) {
1665 if (e_rules->do_oct) {
1668 }
else if (e_rules->do_hex) {
1711 char const *
const * p;
1713 .name = __FUNCTION__,
1717 if (sep) e_rules.subs[(
uint8_t)*sep] = *sep;
1721 for (p = array; *p; p++) {
1746 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
1755 found = memmem(sbuff->
p, needle_len, needle, needle_len);
1756 if (!found)
return 0;
1773 char const *p, *n_p;
1778 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
1788 end = p + needle_len;
1790 for (p = sbuff->
p, n_p = needle; p < end; p++, n_p++) {
1811 size_t needle_len = 0;
1817 while (total < len) {
1824 while ((p < end) && allowed[(
uint8_t)*p]) {
1825 if (needle_len == 0) {
1865 if (p != end)
break;
1884 bool do_escape =
false;
1887 size_t needle_len = 1;
1897 while (total < len) {
1905 if (escape_chr ==
'\0') {
1911 }
else if (*p == escape_chr) {
1921 if (p != end)
break;
1943 size_t clen = strlen(chr);
1950 if (len < clen)
return NULL;
1952 while (total <= (len - clen)) {
1991 while (total < len) {
1998 found = memchr(our_sbuff.
p, c, end - our_sbuff.
p);
2027 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
2028 if (!needle_len)
return 0;
2033 if (len < needle_len)
return NULL;
2035 while (total <= (len - needle_len)) {
2046 found = memmem(our_sbuff.
p, end - our_sbuff.
p, needle, needle_len);
2057 total +=
fr_sbuff_set(&our_sbuff, (end - needle_len) + 1);
2080 if (needle_len == SIZE_MAX) needle_len = strlen(needle);
2081 if (!needle_len)
return 0;
2086 if (len < needle_len)
return NULL;
2088 while (total <= (len - needle_len)) {
2094 for (p = our_sbuff.
p, n_p = needle, end = our_sbuff.
p + needle_len;
2122 if (*sbuff->
p != c)
return false;
2143 if (*sbuff->
p == c)
return false;
2158 char *p = sbuff->
p - 1;
2161 while ((p >= sbuff->start) && to_trim[(
uint8_t)*p]) p--;
2164 if (slen != 0) fr_sbuff_terminate(sbuff);
2183 size_t needle_len = 1;
2215 static bool const unprintables[
UINT8_MAX + 1] = {
2220 static _Thread_local
char str[10][5];
2221 static _Thread_local
size_t i = 0;
2248 if (unprintables[(
uint8_t)c]) {
2249 snprintf(str[i],
sizeof(str[i]),
"\\x%x", c);
2265 fprintf(fp,
"do_hex : %s\n",
escapes->do_hex ?
"yes" :
"no");
2266 fprintf(fp,
"do_oct : %s\n",
escapes->do_oct ?
"yes" :
"no");
2268 fprintf(fp,
"substitutions:\n");
2274 fprintf(fp,
"skipes:\n");
2284 fprintf(fp,
"Terminal count %zu\n", tt->
len);
2286 for (i = 0; i < tt->
len; i++) fprintf(fp,
"\t\"%s\" (%zu)\n", tt->
elem[i].
str, tt->
elem[i].
len);
2291 fprintf(fp,
"Parse rules %p\n", p_rules);
2294 if (p_rules->escapes) {
2297 fprintf(fp,
"<none>\n");
2301 if (p_rules->terminals) {
2304 fprintf(fp,
"<none>\n");
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_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]
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)
void fr_sbuff_unescape_debug(FILE *fp, fr_sbuff_unescape_rules_t const *escapes)
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.
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]
void fr_sbuff_terminal_debug(FILE *fp, fr_sbuff_term_t const *tt)
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.
#define CHECK_SBUFF_WRITEABLE(_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.
void fr_sbuff_parse_rules_debug(FILE *fp, fr_sbuff_parse_rules_t const *p_rules)
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.
fr_slen_t fr_sbuff_in_array(fr_sbuff_t *out, char const *const *array, char const *sep)
Concat an array of strings (NULL terminated), with a string separator.
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_RETURN(_func, _sbuff,...)
#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