Use different sbuff initialisers for printing and parsing

Zero terminate buffers used for printing

diff --git a/src/lib/json/json.c b/src/lib/json/json.c
index e2a15b0d04b5bfe411100d5f7769d3b35524f340..f78745541bcdafa17415405a829ea861c51e657b 100644 (file)
--- a/src/lib/json/json.c
+++ b/src/lib/json/json.c
@@ -558,7 +558,7 @@ static json_object *json_object_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t
                /*
                 *      Get attribute name and value.
                 */
-               fr_sbuff_init(&attr_name, buf, sizeof(buf));
+               fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);
                if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {
                        return NULL;
                }
@@ -686,7 +686,7 @@ static json_object *json_smplobj_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t
                /*
                 *      Get attribute name and value.
                 */
-               fr_sbuff_init(&attr_name, buf, sizeof(buf));
+               fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);
                if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {
                        return NULL;
                }
@@ -808,7 +808,7 @@ static struct json_object *json_array_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_l
                /*
                 *      Get attribute name and value.
                 */
-               fr_sbuff_init(&attr_name, buf, sizeof(buf));
+               fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);
                if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {
                        return NULL;
                }
@@ -982,7 +982,7 @@ static struct json_object *json_attr_array_afrom_pair_list(UNUSED TALLOC_CTX *ct
 
                if (vp->da->flags.is_raw) continue;
 
-               fr_sbuff_init(&attr_name, buf, sizeof(buf));
+               fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);
                if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {
                        return NULL;
                }

diff --git a/src/lib/server/log.c b/src/lib/server/log.c
index 3ac0ace718575c691bd2f1ac7de07bacc99fe2d2..1dd209c7844a00d3cad8acfa0651d75094788c57 100644 (file)
--- a/src/lib/server/log.c
+++ b/src/lib/server/log.c
@@ -956,7 +956,7 @@ void log_request_fd_event(UNUSED fr_event_list_t *el, int fd, UNUSED int flags,
                return;
        }
 
-       fr_sbuff_init(&sbuff, buffer, sizeof(buffer));
+       fr_sbuff_init_in(&sbuff, buffer, sizeof(buffer) - 1);
        fr_sbuff_marker(&m_start, &sbuff);
        fr_sbuff_marker(&m_end, &sbuff);
 

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 80cea64ea73697484ac2fde1cd8d531319f0e6d7..9a27e0dde61802ac3a20dd61a720de945d0a7fa2 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -1426,7 +1426,7 @@ static xlat_action_t xlat_func_lpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
                        return XLAT_ACTION_FAIL;
                }
 
-               fr_sbuff_init(&sbuff, buff, pad_len + 1);
+               fr_sbuff_init_in(&sbuff, buff, pad_len);
                fr_sbuff_marker(&m_data, &sbuff);
                fr_sbuff_advance(&m_data, pad_len - len);       /* Mark where we want the data to go */
                fr_sbuff_move(&FR_SBUFF(&m_data), &FR_SBUFF(&sbuff), len); /* Shift the data */
@@ -1507,7 +1507,7 @@ static xlat_action_t xlat_func_rpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
                        return XLAT_ACTION_FAIL;
                }
 
-               fr_sbuff_init(&sbuff, buff, pad_len + 1);
+               fr_sbuff_init_in(&sbuff, buff, pad_len);
                fr_sbuff_advance(&sbuff, len);
 
                if (fill_len == 1) {

diff --git a/src/lib/util/base_16_32_64_tests.c b/src/lib/util/base_16_32_64_tests.c
index ec2ef73b17dce4bd4da27c4dd75a4ce6cb0f7d96..1fcec426eb248b0ce35129e21116ea9a737194f1 100644 (file)
--- a/src/lib/util/base_16_32_64_tests.c
+++ b/src/lib/util/base_16_32_64_tests.c
@@ -64,7 +64,7 @@ static void test_base16_encode(void)
        fr_sbuff_t      out;
        size_t          i;
 
-       fr_sbuff_init(&out, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&out, buffer, sizeof(buffer));
 
        for (i = 0; i < NUM_ELEMENTS(base16_vectors); i++) {
                fr_sbuff_set_to_start(&out);
@@ -108,7 +108,7 @@ static void test_base32_encode(void)
        fr_sbuff_t      out;
        size_t          i;
 
-       fr_sbuff_init(&out, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&out, buffer, sizeof(buffer));
 
        for (i = 0; i < NUM_ELEMENTS(base32_vectors); i++) {
                fr_sbuff_set_to_start(&out);
@@ -155,7 +155,7 @@ static void test_base32_hex_encode(void)
        fr_sbuff_t      out;
        size_t          i;
 
-       fr_sbuff_init(&out, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&out, buffer, sizeof(buffer));
 
        for (i = 0; i < NUM_ELEMENTS(base32_hex_vectors); i++) {
                fr_sbuff_set_to_start(&out);
@@ -202,7 +202,7 @@ static void test_base64_encode(void)
        fr_sbuff_t      out;
        size_t          i;
 
-       fr_sbuff_init(&out, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&out, buffer, sizeof(buffer));
 
        for (i = 0; i < NUM_ELEMENTS(base64_vectors); i++) {
                fr_sbuff_set_to_start(&out);

diff --git a/src/lib/util/dict_util.c b/src/lib/util/dict_util.c
index 74b0da71a0bf0b4702be8da2e1838d865935f238..390f4ec81f6bce64336bf06d07be0795c64d5c5c 100644 (file)
--- a/src/lib/util/dict_util.c
+++ b/src/lib/util/dict_util.c
@@ -2578,7 +2578,7 @@ fr_dict_attr_t const *fr_dict_attr_search_by_qualified_oid(fr_dict_attr_err_t *e
        fr_sbuff_t              our_name;
        fr_dict_attr_t const    *da;
 
-       fr_sbuff_init(&our_name, name, strlen(name) + 1);
+       fr_sbuff_init_in(&our_name, name, strlen(name));
 
        slen = fr_dict_attr_search_by_qualified_oid_substr(err, &da, dict_def, &our_name, NULL, internal, foreign);
        if (slen <= 0) return NULL;

diff --git a/src/lib/util/log.c b/src/lib/util/log.c
index 5f2302587a997258482b854d6282fc311f021b45..f91f352e6f2ca6ad229ca01aa8ec9bbf9807ce93 100644 (file)
--- a/src/lib/util/log.c
+++ b/src/lib/util/log.c
@@ -189,7 +189,7 @@ void fr_log_fd_event(UNUSED fr_event_list_t *el, int fd, UNUSED int flags, void
                return;
        }
 
-       fr_sbuff_init(&sbuff, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&sbuff, buffer, sizeof(buffer));
        fr_sbuff_marker(&m_start, &sbuff);
        fr_sbuff_marker(&m_end, &sbuff);
 

diff --git a/src/lib/util/pair_print.c b/src/lib/util/pair_print.c
index 32e071d840d7e0f144266db8ea41e3f9c8fad084..1b7bb5cb3f4f6c643936de2f6f029a6a489bdeaf 100644 (file)
--- a/src/lib/util/pair_print.c
+++ b/src/lib/util/pair_print.c
@@ -201,7 +201,7 @@ void _fr_pair_list_log(fr_log_t const *log, int lvl, fr_pair_t *parent, fr_pair_
        fr_sbuff_t sbuff;
        char buffer[1024];
 
-       fr_sbuff_init(&sbuff, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&sbuff, buffer, sizeof(buffer));
 
        fr_pair_list_log_sbuff(log, lvl, parent, list, file, line, &sbuff);
 }
@@ -223,7 +223,7 @@ void fr_pair_debug(fr_pair_t const *pair)
        fr_sbuff_t sbuff;
        char buffer[1024];
 
-       fr_sbuff_init(&sbuff, buffer, sizeof(buffer));
+       fr_sbuff_init_out(&sbuff, buffer, sizeof(buffer));
 
        fr_pair_print(&sbuff, NULL, pair);
 

diff --git a/src/lib/util/sbuff.h b/src/lib/util/sbuff.h
index 36bb7bb1695b8b8fcbcfa8395c4c0fb639a904c9..5be27d947837d75deab95a9f06916ecdb577a856 100644 (file)
--- a/src/lib/util/sbuff.h
+++ b/src/lib/util/sbuff.h
@@ -579,7 +579,7 @@ static inline void fr_sbuff_terminate(fr_sbuff_t *sbuff)
        *sbuff->p = '\0';
 }
 
-static inline void _fr_sbuff_init(fr_sbuff_t *out, char const *start, char const *end, bool is_const)
+static inline void _fr_sbuff_init(fr_sbuff_t *out, char const *start, char const *end, bool is_const, bool nul_term)
 {
        if (unlikely(end < start)) end = start; /* Could be an assert? */
 
@@ -590,16 +590,20 @@ static inline void _fr_sbuff_init(fr_sbuff_t *out, char const *start, char const
                .end_i = end,
                .is_const = is_const
        };
+
+       if (nul_term) *out->start = '\0';
 }
 
-/** Initialise an sbuff around a stack allocated buffer for printing or parsing
+/** Initialise an sbuff around a stack allocated buffer for printing
+ *
+ * Will \0 terminate the output buffer.
  *
  * @param[out] _out            Pointer to buffer.
  * @param[in] _start           Start of the buffer.
  * @param[in] _len_or_end      Either an end pointer or the length
  *                             of the buffer.
  */
-#define fr_sbuff_init(_out, _start, _len_or_end) \
+#define fr_sbuff_init_out(_out, _start, _len_or_end) \
 _fr_sbuff_init(_out, _start, \
 _Generic((_len_or_end), \
        size_t          : (char const *)(_start) + ((size_t)(_len_or_end) - 1), \
@@ -608,7 +612,25 @@ _Generic((_len_or_end), \
        char *          : (char const *)(_len_or_end), \
        char const *    : (char const *)(_len_or_end) \
 ), \
-IS_CONST(char *, _start))
+IS_CONST(char *, _start), true)
+
+/** Initialise an sbuff around a stack allocated buffer for parsing
+ *
+ * @param[out] _out            Pointer to buffer.
+ * @param[in] _start           Start of the buffer.
+ * @param[in] _len_or_end      Either an end pointer or the length
+ *                             of the buffer.
+ */
+#define fr_sbuff_init_in(_out, _start, _len_or_end) \
+_fr_sbuff_init(_out, _start, \
+_Generic((_len_or_end), \
+       size_t          : (char const *)(_start) + (size_t)(_len_or_end), \
+       long            : (char const *)(_start) + (size_t)(_len_or_end), \
+       int             : (char const *)(_start) + (size_t)(_len_or_end), \
+       char *          : (char const *)(_len_or_end), \
+       char const *    : (char const *)(_len_or_end) \
+), \
+IS_CONST(char *, _start), false)
 
 /** Initialise a special sbuff which automatically reads in more data as the buffer is exhausted
  *

diff --git a/src/lib/util/sbuff_tests.c b/src/lib/util/sbuff_tests.c
index 5760569c02aca499457c486c8ee83642ee472aef..4cf3ea1fef792f84247bbbac99e32ba0adcb586f 100644 (file)
--- a/src/lib/util/sbuff_tests.c
+++ b/src/lib/util/sbuff_tests.c
@@ -51,21 +51,21 @@ static void test_parse_init(void)
        fr_sbuff_t      sbuff;
 
        TEST_CASE("Parse init with size");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        TEST_CHECK(sbuff.start == in);
        TEST_CHECK(sbuff.p == in);
        TEST_CHECK(sbuff.end == in + (sizeof(in) - 1));
 
        TEST_CASE("Parse init with end");
-       fr_sbuff_init(&sbuff, in, in + strlen(in));
+       fr_sbuff_init_in(&sbuff, in, in + strlen(in));
 
        TEST_CHECK(sbuff.start == in);
        TEST_CHECK(sbuff.p == in);
        TEST_CHECK(sbuff.end == in + strlen(in));
 
        TEST_CASE("Parse init with const end");
-       fr_sbuff_init(&sbuff, in, (char const *)(in + strlen(in)));
+       fr_sbuff_init_in(&sbuff, in, (char const *)(in + strlen(in)));
 
        TEST_CHECK(sbuff.start == in);
        TEST_CHECK(sbuff.p == in);
@@ -80,7 +80,7 @@ static void test_bstrncpy_exact(void)
        fr_sbuff_t      sbuff;
        ssize_t         slen;
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        TEST_CASE("Copy 5 bytes to out");
        slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5);
@@ -101,7 +101,7 @@ static void test_bstrncpy_exact(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
-       fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
+       fr_sbuff_init_in(&sbuff, in_long, sizeof(in_long) - 1);
 
        slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(slen, -7);
@@ -132,7 +132,7 @@ static void test_bstrncpy(void)
        fr_sbuff_t      sbuff;
        ssize_t         slen;
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        TEST_CASE("Copy 5 bytes to out");
        slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5);
@@ -153,7 +153,7 @@ static void test_bstrncpy(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
-       fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
+       fr_sbuff_init_in(&sbuff, in_long, sizeof(in_long) - 1);
 
        slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(slen, 18);
@@ -202,7 +202,7 @@ static void test_bstrncpy_allowed(void)
        fr_sbuff_t      sbuff;
        ssize_t         slen;
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        /*
         *      Should behave identically to bstrncpy
@@ -228,7 +228,7 @@ static void test_bstrncpy_allowed(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
-       fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
+       fr_sbuff_init_in(&sbuff, in_long, sizeof(in_long));
 
        slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, allow_lowercase_and_space);
        TEST_CHECK_SLEN(slen, 18);
@@ -290,7 +290,7 @@ static void test_bstrncpy_until(void)
        fr_sbuff_t      sbuff;
        ssize_t         slen;
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        /*
         *      Should behave identically to bstrncpy
@@ -324,7 +324,7 @@ static void test_bstrncpy_until(void)
        TEST_CHECK_STRCMP(sbuff.p, "");
 
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
-       fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
+       fr_sbuff_init_in(&sbuff, in_long, sizeof(in_long) - 1);
 
        slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, NULL, NULL);
        TEST_CHECK_SLEN(slen, 18);
@@ -418,7 +418,7 @@ static void test_unescape_until(void)
                                        .do_oct = true
                                };
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        /*
         *      Should behave identically to bstrncpy
         *      where there's no restrictions on char
@@ -443,7 +443,7 @@ static void test_unescape_until(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
-       fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
+       fr_sbuff_init_in(&sbuff, in_long, sizeof(in_long) - 1);
 
        slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, NULL, &rules);
        TEST_CHECK_SLEN(slen, 18);
@@ -500,7 +500,7 @@ static void test_unescape_until(void)
         *      Escapes and substitution
         */
        TEST_CASE("Escape with substition to same char");
-       fr_sbuff_init(&sbuff, in_escapes, sizeof(in_escapes));
+       fr_sbuff_init_in(&sbuff, in_escapes, sizeof(in_escapes) - 1);
        slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
                                           &FR_SBUFF_TERM("g"), &pipe_rules);
        TEST_CHECK_SLEN(slen, 20);
@@ -508,7 +508,7 @@ static void test_unescape_until(void)
        TEST_CHECK_STRCMP(sbuff.p, "");
 
        TEST_CASE("Escape with substition to different char");
-       fr_sbuff_init(&sbuff, in_escapes, sizeof(in_escapes));
+       fr_sbuff_init_in(&sbuff, in_escapes, sizeof(in_escapes) - 1);
        slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
                                           &FR_SBUFF_TERM("g"), &pipe_rules_sub);
        TEST_CHECK_SLEN(slen, 20);
@@ -519,7 +519,7 @@ static void test_unescape_until(void)
                char    tmp_out[24 + 1];
 
                TEST_CASE("Escape with hex substitutions (insufficient output space)");
-               fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
+               fr_sbuff_init_in(&sbuff, in_escapes_seq, sizeof(in_escapes_seq) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   &FR_SBUFF_TERM("g"), &pipe_rules_sub_hex);
                TEST_CHECK_SLEN(slen, 24);
@@ -531,7 +531,7 @@ static void test_unescape_until(void)
                char    tmp_out[25 + 1];
 
                TEST_CASE("Escape with hex substitutions (sufficient output space)");
-               fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
+               fr_sbuff_init_in(&sbuff, in_escapes_seq, sizeof(in_escapes_seq) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   &FR_SBUFF_TERM("g"), &pipe_rules_sub_hex);
                TEST_CHECK_SLEN(slen, 25);
@@ -543,7 +543,7 @@ static void test_unescape_until(void)
                char    tmp_out[28 + 1];
 
                TEST_CASE("Escape with oct substitutions (insufficient output space)");
-               fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
+               fr_sbuff_init_in(&sbuff, in_escapes_seq, sizeof(in_escapes_seq) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   &FR_SBUFF_TERM("g"), &pipe_rules_sub_oct);
                TEST_CHECK_SLEN(slen, 28);
@@ -555,7 +555,7 @@ static void test_unescape_until(void)
                char    tmp_out[29 + 1];
 
                TEST_CASE("Escape with oct substitutions (sufficient output space)");
-               fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
+               fr_sbuff_init_in(&sbuff, in_escapes_seq, sizeof(in_escapes_seq) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   &FR_SBUFF_TERM("g"), &pipe_rules_sub_oct);
                TEST_CHECK_SLEN(slen, 29);
@@ -567,7 +567,7 @@ static void test_unescape_until(void)
                char    tmp_out[26 + 1];
 
                TEST_CASE("Escape with hex and oct substitutions (sufficient output space)");
-               fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
+               fr_sbuff_init_in(&sbuff, in_escapes_seq, sizeof(in_escapes_seq) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   &FR_SBUFF_TERM("g"), &pipe_rules_both);
                TEST_CHECK_SLEN(slen, 26);
@@ -580,7 +580,7 @@ static void test_unescape_until(void)
                char const      in_escapes_collapse[] = "||";
 
                TEST_CASE("Collapse double escapes");
-               fr_sbuff_init(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse));
+               fr_sbuff_init_in(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX, NULL, &pipe_rules);
                TEST_CHECK_SLEN(slen, 1);
@@ -592,7 +592,7 @@ static void test_unescape_until(void)
                char    in_escapes_collapse[] = "||foo||";
 
                TEST_CASE("Collapse double escapes overlapping");
-               fr_sbuff_init(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse));
+               fr_sbuff_init_in(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(in_escapes_collapse, sizeof(in_escapes_collapse)),
                                                   &sbuff, SIZE_MAX, NULL, &pipe_rules);
                TEST_CHECK_SLEN(slen, 5);
@@ -640,7 +640,7 @@ static void test_unescape_until(void)
                };
 
                TEST_CASE("Check unit test test strings");
-               fr_sbuff_init(&sbuff, in_escapes_unit, sizeof(in_escapes_unit));
+               fr_sbuff_init_in(&sbuff, in_escapes_unit, sizeof(in_escapes_unit) - 1);
                slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)), &sbuff, SIZE_MAX,
                                                   NULL, &double_quote_rules);
                TEST_CHECK_SLEN(slen, 28);
@@ -681,7 +681,7 @@ static void test_unescape_multi_char_terminals(void)
                                );
        char                    out[100];
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, &tt, NULL);
        TEST_CHECK(slen == 3);
@@ -714,7 +714,7 @@ static void test_eof_terminal(void)
                                );
        char                    out[100];
 
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
 
        slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, &tt_eof, NULL);
        TEST_CHECK(slen == 3);
@@ -737,7 +737,7 @@ static void test_no_advance(void)
        fr_sbuff_t      sbuff;
        ssize_t         slen;
 
-       fr_sbuff_init(&sbuff, in, strlen(in));
+       fr_sbuff_init_in(&sbuff, in, strlen(in));
 
        TEST_CASE("Copy 5 bytes to out - no advance");
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -991,26 +991,26 @@ static void test_adv_past_str(void)
        char const      in[] = "i am a test string";
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_str(&sbuff, "i am a", SIZE_MAX), 6);
        TEST_CHECK_STRCMP(sbuff.p, " test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_str(&sbuff, " am a", SIZE_MAX), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token larger than the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_str(&sbuff, "i am a test string ", SIZE_MAX), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK_LEN(fr_sbuff_adv_past_str(&sbuff, "i am a", SIZE_MAX), 0);
 
        TEST_CASE("Check for token that is the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_str(&sbuff, "i am a test string", SIZE_MAX), 18);
        TEST_CHECK_STRCMP(sbuff.p, "");
        TEST_CHECK(sbuff.p == sbuff.end);
@@ -1022,26 +1022,26 @@ static void test_adv_past_strcase(void)
        char const      in[] = "i am a test string";
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_strcase(&sbuff, "i AM a", SIZE_MAX), 6);
        TEST_CHECK_STRCMP(sbuff.p, " test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_strcase(&sbuff, " AM a", SIZE_MAX), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token larger than the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_strcase(&sbuff, "i AM a TEST string ", SIZE_MAX), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK_LEN(fr_sbuff_adv_past_strcase(&sbuff, "i AM a", SIZE_MAX), 0);
 
        TEST_CASE("Check for token that is the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_strcase(&sbuff, "i AM a TEST string", SIZE_MAX), 18);
        TEST_CHECK_STRCMP(sbuff.p, "");
        TEST_CHECK(sbuff.p == sbuff.end);
@@ -1055,30 +1055,30 @@ static void test_adv_past_whitespace(void)
        char const      in_ws[] = "     ";
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, SIZE_MAX, NULL), 5);
        TEST_CHECK_STRCMP(sbuff.p, "i am a         test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in_ns, sizeof(in_ns));
+       fr_sbuff_init_in(&sbuff, in_ns, sizeof(in_ns) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, SIZE_MAX, NULL), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, SIZE_MAX, NULL), 0);
 
        TEST_CASE("Check for token that is the string");
-       fr_sbuff_init(&sbuff, in_ws, sizeof(in_ws));
+       fr_sbuff_init_in(&sbuff, in_ws, sizeof(in_ws) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, SIZE_MAX, NULL), 5);
 
        TEST_CASE("Length constraint with token match");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, 2, NULL), 2);
        TEST_CHECK_STRCMP(sbuff.p, "   i am a         test string");
 
        TEST_CASE("Length constraint without token match");
-       fr_sbuff_init(&sbuff, in_ns, sizeof(in_ns));
+       fr_sbuff_init_in(&sbuff, in_ns, sizeof(in_ns) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_whitespace(&sbuff, 2, NULL), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 }
@@ -1091,32 +1091,32 @@ static void test_adv_past_allowed(void)
        char const      in_ws[] = "     ";
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, SIZE_MAX, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 5);
        TEST_CHECK_STRCMP(sbuff.p, "i am a         test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in_ns, sizeof(in_ns));
+       fr_sbuff_init_in(&sbuff, in_ns, sizeof(in_ns) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, SIZE_MAX, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, SIZE_MAX, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 0);
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Check for token at the end of the string");
-       fr_sbuff_init(&sbuff, in_ws, sizeof(in_ws));
+       fr_sbuff_init_in(&sbuff, in_ws, sizeof(in_ws) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, SIZE_MAX, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 5);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Length constraint with token match");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, 2, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 2);
        TEST_CHECK_STRCMP(sbuff.p, "   i am a         test string");
 
        TEST_CASE("Length constraint with token match");
-       fr_sbuff_init(&sbuff, in_ns, sizeof(in_ns));
+       fr_sbuff_init_in(&sbuff, in_ns, sizeof(in_ns) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_past_allowed(&sbuff, 2, (bool[UINT8_MAX + 1]){ [' '] = true }, NULL), 0);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 }
@@ -1127,32 +1127,32 @@ static void test_adv_until(void)
        char const      in[] = " abcdefgh ijklmnopp";
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, SIZE_MAX, &FR_SBUFF_TERM(" "), '\0'), 0);
        TEST_CHECK_STRCMP(sbuff.p, " abcdefgh ijklmnopp");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, SIZE_MAX, &FR_SBUFF_TERM("a"), '\0'), 1);
        TEST_CHECK_STRCMP(sbuff.p, "abcdefgh ijklmnopp");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, SIZE_MAX, &FR_SBUFF_TERM("a"), '\0'), 0);
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Check for token that is not in the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, SIZE_MAX, &FR_SBUFF_TERM("|"), '\0'), 19);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Check escapes");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, SIZE_MAX, &FR_SBUFF_TERM("p"), 'o'), 18);
        TEST_CHECK_STRCMP(sbuff.p, "p");
 
        TEST_CASE("Check for token that is not in the string with length constraint");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK_LEN(fr_sbuff_adv_until(&sbuff, 5, &FR_SBUFF_TERM("|"), '\0'), 5);
        TEST_CHECK(sbuff.p == (sbuff.start + 5));
 }
@@ -1164,55 +1164,55 @@ static void test_adv_to_utf8(void)
        char            *p;
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, SIZE_MAX, "🥺");
        TEST_CHECK(p == sbuff.p);
        TEST_CHECK_STRCMP(sbuff.p, "🥺🥺🥺🥺🍪😀");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, SIZE_MAX, "🍪");
        TEST_CHECK(p == (sbuff.start + (sizeof("🥺🥺🥺🥺") - 1)));
        TEST_CHECK_STRCMP(p, "🍪😀");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, SIZE_MAX, "🍪");
        TEST_CHECK(p == NULL);
        TEST_CHECK(sbuff.start == sbuff.p);
 
        TEST_CASE("Check for token at the end of the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, SIZE_MAX, "😀");
        TEST_CHECK(p == sbuff.start + (sizeof("🥺🥺🥺🥺🍪") - 1));
 
        TEST_CASE("Check for token not in the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, SIZE_MAX, "🍆 ");
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token at the end of the string within len contraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr_utf8(&sbuff, (sizeof("🥺🥺🥺🥺🍪😀") - 1), "😀");
        TEST_CHECK(p == sbuff.start + (sizeof("🥺🥺🥺🥺🍪") - 1));
 
        TEST_CASE("Check for token at the end of the string outside len constraints #1");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_chr_utf8(&sbuff, (sizeof("🥺🥺🥺🥺🍪😀") - 2), "😀"));
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Check for token at the end of the string outside len constraints #2");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_chr_utf8(&sbuff, (sizeof("🥺🥺🥺🥺🍪😀") - 3), "😀"));
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Check for token at the end of the string outside len constraints #3");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_chr_utf8(&sbuff, (sizeof("🥺🥺🥺🥺🍪😀") - 4), "😀"));
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Check for token at the end of the string outside len constraints #4");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_chr_utf8(&sbuff, (sizeof("🥺🥺🥺🥺🍪😀") - 5), "😀"));
        TEST_CHECK(sbuff.p == sbuff.start);
 }
@@ -1224,40 +1224,40 @@ static void test_adv_to_chr(void)
        char            *p;
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, 'A');
        TEST_CHECK(p == sbuff.p);
        TEST_CHECK_STRCMP(sbuff.p, "AAAAbC");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, 'b');
        TEST_CHECK(p == (sbuff.start + (sizeof("AAAA") - 1)));
        TEST_CHECK_STRCMP(p, "bC");
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        TEST_CHECK(!fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, 'b'));
        TEST_CHECK(sbuff.start == sbuff.p);
 
        TEST_CASE("Check for token at the end of the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, 'C');
        TEST_CHECK(p == sbuff.start + (sizeof("AAAAb") - 1));
 
        TEST_CASE("Check for token not in the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr(&sbuff, SIZE_MAX, 'D');
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token not at beginning of string within length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_chr(&sbuff, 5, 'b');
        TEST_CHECK(p == (sbuff.start + (sizeof("AAAA") - 1)));
        TEST_CHECK_STRCMP(p, "bC");
 
        TEST_CASE("Check for token not at beginning of string outside length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_chr(&sbuff, 4, 'b'));
        TEST_CHECK(sbuff.p == sbuff.start);
 }
@@ -1269,56 +1269,56 @@ static void test_adv_to_str(void)
        char            *p;
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "i am a test", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "test", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "test string");
 
        TEST_CASE("Check for token at the end of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "ing", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "ing");
 
        TEST_CASE("Check for token larger than the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "i am a test string ", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token shorter than string, not in the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "ng ", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "i am a", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token that is the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, SIZE_MAX, "i am a test string", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(p, "i am a test string");
 
        TEST_CASE("Check for token not at beginning of string within length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_str(&sbuff, 11, "test", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "test string");
 
        TEST_CASE("Check for token not at beginning of string outside length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_str(&sbuff, 10, "test", SIZE_MAX));
        TEST_CHECK(sbuff.p == sbuff.start);
 }
@@ -1330,56 +1330,56 @@ static void test_adv_to_strcase(void)
        char            *p;
 
        TEST_CASE("Check for token at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "i AM a TEST", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "i am a test string");
 
        TEST_CASE("Check for token not at beginning of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "tEst", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "test string");
 
        TEST_CASE("Check for token at the end of string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "Ing", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "ing");
 
        TEST_CASE("Check for token larger than the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "i aM a tEst stRIng ", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token shorter than string, not in the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "nG ", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token with zero length string");
-       fr_sbuff_init(&sbuff, in, 0 + 1);
+       fr_sbuff_init_in(&sbuff, in, 0);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "i AM a", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(p == NULL);
 
        TEST_CASE("Check for token that is the string");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, SIZE_MAX, "i AM a teST stRIng", SIZE_MAX);
        TEST_CHECK(sbuff.p == sbuff.start);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(p, "i am a test string");
 
        TEST_CASE("Check for token not at beginning of string within length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        p = fr_sbuff_adv_to_strcase(&sbuff, 11, "tEst", SIZE_MAX);
        TEST_CHECK(sbuff.p == p);
        TEST_CHECK_STRCMP(sbuff.p, "test string");
 
        TEST_CASE("Check for token not at beginning of string outside length constraints");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(!fr_sbuff_adv_to_strcase(&sbuff, 10, "tEst", SIZE_MAX));
        TEST_CHECK(sbuff.p == sbuff.start);
 }
@@ -1390,7 +1390,7 @@ static void test_next_if_char(void)
        char const      in[] = "i ";
 
        TEST_CASE("Check for advancement on match");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(fr_sbuff_next_if_char(&sbuff, 'i') == true);
        TEST_CHECK_STRCMP(sbuff.p, " ");
 
@@ -1413,7 +1413,7 @@ static void test_next_unless_char(void)
        char const      in[] = "i ";
 
        TEST_CASE("Check for advancement on non-match");
-       fr_sbuff_init(&sbuff, in, sizeof(in));
+       fr_sbuff_init_in(&sbuff, in, sizeof(in) - 1);
        TEST_CHECK(fr_sbuff_next_unless_char(&sbuff, ' ') == true);
        TEST_CHECK_STRCMP(sbuff.p, " ");
 

diff --git a/src/lib/util/uri.c b/src/lib/util/uri.c
index 12868a76f88bb805d678d0bc4ef5c08642dc3129..3cd3ea08d1d84b4ff65358611e756ff58dfd7969 100644 (file)
--- a/src/lib/util/uri.c
+++ b/src/lib/util/uri.c
@@ -88,7 +88,7 @@ int fr_uri_escape(fr_value_box_list_t *uri, fr_uri_part_t const *uri_parts, void
                /*
                 *      Look for URI part terminator
                 */
-               fr_sbuff_init(&sbuff, uri_vb->vb_strvalue, uri_vb->length);
+               fr_sbuff_init_in(&sbuff, uri_vb->vb_strvalue, uri_vb->length);
 
                do {
                        fr_sbuff_adv_until(&sbuff, SIZE_MAX, uri_part->terminals, '\0');