sbuff: Switch to distinct in/out initialisers

diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c
index da84cb44d21fa43989141d512c8ce0f27f64bcfb..f4f8c4e41f2d90336fecba329800dd8c11522160 100644 (file)
--- a/src/bin/unit_test_attribute.c
+++ b/src/bin/unit_test_attribute.c
@@ -2146,7 +2146,7 @@ static size_t command_xlat_normalise(command_result_t *result, command_file_ctx_
        /*
         *      Process special chars, octal escape sequences and hex sequences
         */
-       len = fr_value_str_aunescape(NULL, &fmt, &FR_SBUFF_TMP(in, input_len + 1), SIZE_MAX, '\"');
+       len = fr_value_str_aunescape(NULL, &fmt, &FR_SBUFF_IN(in, input_len), SIZE_MAX, '\"');
        fr_assert(fmt);
        dec_len = xlat_tokenize(fmt, &head, fmt, len,
                                &(vp_tmpl_rules_t) { .dict_def = cc->active_dict ? cc->active_dict : cc->config->dict });

diff --git a/src/lib/server/tmpl.c b/src/lib/server/tmpl.c
index 081ce6881a61ccb2d057858d092f898fec763a12..9938a2433b3fa47d88e16d309fe14f2d293224b7 100644 (file)
--- a/src/lib/server/tmpl.c
+++ b/src/lib/server/tmpl.c
@@ -1053,8 +1053,7 @@ int tmpl_attr_resolve_unparsed(vp_tmpl_t *vpt, vp_tmpl_rules_t const *rules)
                ssize_t         slen;
 
                slen = fr_dict_attr_child_by_name_substr(NULL, &da, parent,
-                                                        &FR_SBUFF_TMP(ar->unknown.name,
-                                                        strlen(ar->unknown.name)),
+                                                        &FR_SBUFF_IN(ar->unknown.name, strlen(ar->unknown.name)),
                                                         false);
                if (slen <= 0) {
                        fr_dict_attr_t  *unknown_da;
@@ -1357,7 +1356,7 @@ ssize_t tmpl_afrom_attr_substr(TALLOC_CTX *ctx, attr_ref_error_t *err,
         *      parsing the configuration files.
         */
        slen = fr_dict_attr_by_qualified_name_substr(NULL, &da,
-                                                    rules->dict_def, &FR_SBUFF_TMP(p, strlen(p) + 1),
+                                                    rules->dict_def, &FR_SBUFF_IN(p, strlen(p)),
                                                     !rules->disallow_internal);
        if (slen <= 0) {
                fr_dict_attr_t *unknown_da;
@@ -2148,8 +2147,8 @@ ssize_t _tmpl_to_type(void *out,
                 *
                 *      @fixme We need a way of signalling xlat not to escape things.
                 */
-               len = fr_value_str_unescape(&FR_SBUFF_TMP((char *)buff, slen + 1),
-                                           &FR_SBUFF_TMP((char *)buff, slen + 1), SIZE_MAX, '"');
+               len = fr_value_str_unescape(&FR_SBUFF_IN((char *)buff, slen),
+                                           &FR_SBUFF_IN((char *)buff, slen), SIZE_MAX, '"');
                fr_assert(buff);
                fr_value_box_bstrndup_shallow(&value_to_cast, NULL, (char *)buff, len, true);
                src_type = FR_TYPE_STRING;
@@ -2178,8 +2177,8 @@ ssize_t _tmpl_to_type(void *out,
                 *
                 *      @fixme We need a way of signalling xlat not to escape things.
                 */
-               len = fr_value_str_unescape(&FR_SBUFF_TMP((char *)buff, slen + 1),
-                                           &FR_SBUFF_TMP((char *)buff, slen + 1), SIZE_MAX, '"');
+               len = fr_value_str_unescape(&FR_SBUFF_IN((char *)buff, slen),
+                                           &FR_SBUFF_IN((char *)buff, slen), SIZE_MAX, '"');
                fr_assert(buff);
                fr_value_box_bstrndup_shallow(&value_to_cast, NULL, (char *)buff, len, true);
                src_type = FR_TYPE_STRING;

diff --git a/src/lib/util/dict_tokenize.c b/src/lib/util/dict_tokenize.c
index cb40be48df075c5dcefb2b1248f9d057c0ec57d4..27b344847c01697ac779f9f421a815414a8e2260 100644 (file)
--- a/src/lib/util/dict_tokenize.c
+++ b/src/lib/util/dict_tokenize.c
@@ -687,7 +687,7 @@ static int dict_read_process_attribute(dict_tokenize_ctx_t *ctx, char **argv, in
                /*
                 *      Get / skip protocol name.
                 */
-               slen = dict_by_protocol_substr(NULL, &dict, &FR_SBUFF_TMP(ref, strlen(ref) + 1), ctx->dict);
+               slen = dict_by_protocol_substr(NULL, &dict, &FR_SBUFF_IN(ref, strlen(ref)), ctx->dict);
                if (slen < 0) {
                        talloc_free(ref);
                        return -1;
@@ -1508,7 +1508,7 @@ static int fr_dict_finalise(dict_tokenize_ctx_t *ctx)
                         *      Get / skip protocol name.
                         */
                        slen = dict_by_protocol_substr(NULL,
-                                                      &dict, &FR_SBUFF_TMP(this->ref, strlen(this->ref) + 1),
+                                                      &dict, &FR_SBUFF_IN(this->ref, strlen(this->ref)),
                                                       ctx->dict);
                        if (slen <= 0) {
                                fr_dict_t *other;

diff --git a/src/lib/util/dict_util.c b/src/lib/util/dict_util.c
index 881b3fe240eea84e421c1f29ec65199d1f368d06..4ac538074d9db236bea3b5dafffcd00feac71c19 100644 (file)
--- a/src/lib/util/dict_util.c
+++ b/src/lib/util/dict_util.c
@@ -1335,7 +1335,7 @@ ssize_t dict_by_protocol_substr(fr_dict_attr_err_t *err,
         *      Advance p until we get something that's not part of
         *      the dictionary attribute name.
         */
-       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(buffer, sizeof(buffer)),
+       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(buffer, sizeof(buffer)),
                                            &our_name, SIZE_MAX,
                                            fr_dict_attr_allowed_chars);
        if (len == 0) {
@@ -1734,7 +1734,7 @@ ssize_t fr_dict_attr_by_name_substr(fr_dict_attr_err_t *err, fr_dict_attr_t cons
 
        INTERNAL_IF_NULL(dict, 0);
 
-       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(buffer, sizeof(buffer)),
+       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(buffer, sizeof(buffer)),
                                            &our_name, SIZE_MAX,
                                            fr_dict_attr_allowed_chars);
        if (len == 0) {

diff --git a/src/lib/util/pair_legacy.c b/src/lib/util/pair_legacy.c
index b0f0f9272e38031e280415a4f4c2d023a83517c3..b2d541fb67c54ad12abf8428b4f0bb3a66c56be2 100644 (file)
--- a/src/lib/util/pair_legacy.c
+++ b/src/lib/util/pair_legacy.c
@@ -416,7 +416,7 @@ static ssize_t fr_pair_list_afrom_substr(TALLOC_CTX *ctx, fr_dict_t const *dict,
                /*
                 *      Parse the name.
                 */
-               slen = fr_dict_attr_by_qualified_name_substr(NULL, &da, dict, &FR_SBUFF_TMP(p, strlen(p) + 1), true);
+               slen = fr_dict_attr_by_qualified_name_substr(NULL, &da, dict, &FR_SBUFF_IN(p, strlen(p)), true);
                if (slen <= 0) {
 
                        slen = fr_dict_unknown_afrom_oid_substr(ctx, &da_unknown, root, p);

diff --git a/src/lib/util/pair_tokenize.c b/src/lib/util/pair_tokenize.c
index 4019721b1fd32294ae7e3daa0c89c143037dc382..f3868255fb108fc3db72c88447ae96e67c1a2a97 100644 (file)
--- a/src/lib/util/pair_tokenize.c
+++ b/src/lib/util/pair_tokenize.c
@@ -191,7 +191,7 @@ static ssize_t fr_pair_afrom_str(fr_pair_ctx_t *pair_ctx, char const *start, cha
        VALUE_PAIR *vp;
        fr_token_t op;
 
-       slen = fr_dict_attr_by_name_substr(NULL, &da, pair_ctx->parent->dict, &FR_SBUFF_TMP(p, end - p));
+       slen = fr_dict_attr_by_name_substr(NULL, &da, pair_ctx->parent->dict, &FR_SBUFF_IN(p, end));
        if (slen <= 0) return slen - (in - start);
 
        if (da->parent != pair_ctx->parent) {
@@ -305,7 +305,7 @@ static ssize_t fr_pair_ctx_set(fr_pair_ctx_t *pair_ctx, char const *in, size_t i
         *      Parse the attribute name.
         */
        while (p < end) {
-               slen = fr_dict_attr_by_name_substr(NULL, &da, parent->dict, &FR_SBUFF_TMP(p, end - p));
+               slen = fr_dict_attr_by_name_substr(NULL, &da, parent->dict, &FR_SBUFF_IN(p, end));
                if (slen <= 0) return slen - (p - in);
 
                if (da->parent != parent) {
@@ -440,7 +440,7 @@ ssize_t fr_pair_ctx_afrom_str(fr_pair_ctx_t *pair_ctx, char const *in, size_t in
                /*
                 *      We allow a leaf OR a reference here.
                 */
-               slen = fr_dict_attr_by_name_substr(NULL, &da, pair_ctx->parent->dict, &FR_SBUFF_TMP(p, end - p));
+               slen = fr_dict_attr_by_name_substr(NULL, &da, pair_ctx->parent->dict, &FR_SBUFF_IN(p, end));
                if (slen <= 0) return slen - (p - in);
 
                /*

diff --git a/src/lib/util/sbuff.c b/src/lib/util/sbuff.c
index 852cf6225c3cb7b78c82269d4fcd28d3ba7d6247..f56659ca4bba3c9172267db5998fa1b579b6c141 100644 (file)
--- a/src/lib/util/sbuff.c
+++ b/src/lib/util/sbuff.c
@@ -711,7 +711,7 @@ size_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t
        size_t          len; \
        long long       num; \
        fr_sbuff_t      our_in = FR_SBUFF_NO_ADVANCE(in); \
-       len = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(buff, sizeof(buff)), &our_in, (_max_char) + 1); \
+       len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
        if (len == 0) { \
                if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
                return 0; \
@@ -764,7 +764,7 @@ size_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t
        size_t                  len; \
        unsigned long long      num; \
        fr_sbuff_t              our_in = FR_SBUFF_NO_ADVANCE(in); \
-       len = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(buff, sizeof(buff)), &our_in, (_max_char) + 1); \
+       len = fr_sbuff_out_bstrncpy(&FR_SBUFF_IN(buff, sizeof(buff)), &our_in, _max_char); \
        if (len == 0) { \
                if (err) *err = FR_SBUFF_PARSE_ERROR_NOT_FOUND; \
                return 0; \
@@ -823,7 +823,7 @@ size_t fr_sbuff_out_##_name(fr_sbuff_parse_error_t *err, _type *out, fr_sbuff_t
        fr_sbuff_t      our_in = FR_SBUFF_NO_ADVANCE(in); \
        size_t          len; \
        _type           res; \
-       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(buff, sizeof(buff)), &our_in, SIZE_MAX, sbuff_char_class_float); \
+       len = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(buff, sizeof(buff)), &our_in, SIZE_MAX, sbuff_char_class_float); \
        if (len == sizeof(buff)) { \
                if (err) *err = FR_SBUFF_PARSE_ERROR_TRAILING; \
                return 0; \

diff --git a/src/lib/util/sbuff.h b/src/lib/util/sbuff.h
index a5257e5aef10d249745daabbe9acead773623d95..7da48c8881586cc7bba59d5fb918e9c8a586f424 100644 (file)
--- a/src/lib/util/sbuff.h
+++ b/src/lib/util/sbuff.h
@@ -168,8 +168,6 @@ do { \
 }
 
 /** Creates a compound literal to pass into functions which accept a sbuff
- *
- * @note This should only be used as a temporary measure when refactoring code.
  *
  * @note The return value of the function should be used to determine how much
  *      data was written to the buffer.
@@ -177,7 +175,7 @@ do { \
  * @param[in] _start           of the buffer.
  * @param[in] _len_or_end      Length of the buffer or the end pointer.
  */
-#define FR_SBUFF_TMP(_start, _len_or_end) \
+#define FR_SBUFF_OUT(_start, _len_or_end) \
 (fr_sbuff_t){ \
        .buff_i         = _start, \
        .start_i        = _start, \
@@ -195,6 +193,33 @@ do { \
                        ) \
 }
 
+/** Creates a compound literal to pass into functions which accept a sbuff
+ *
+ * @note The return value of the function should be used to determine how much
+ *      data was written to the buffer.
+ *
+ * @param[in] _start           of the buffer.
+ * @param[in] _len_or_end      Length of the buffer or the end pointer.
+ */
+#define FR_SBUFF_IN(_start, _len_or_end) \
+(fr_sbuff_t){ \
+       .buff_i         = _start, \
+       .start_i        = _start, \
+       .end_i          = _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) \
+                       ), \
+       .p_i            = _start, \
+       .is_const       = _Generic((_start), \
+                               char *          : false, \
+                               char const *    : true \
+                       ) \
+}
+
+
 void   fr_sbuff_update(fr_sbuff_t *sbuff, char *new_buff, size_t new_len);
 
 size_t fr_sbuff_shift(fr_sbuff_t *sbuff, size_t shift);

diff --git a/src/lib/util/sbuff_tests.c b/src/lib/util/sbuff_tests.c
index b438ac422dc487081efd7748727a0c86ba23334e..7c4fbfead86e383b4e4de74c88514166d326c5e0 100644 (file)
--- a/src/lib/util/sbuff_tests.c
+++ b/src/lib/util/sbuff_tests.c
@@ -84,34 +84,34 @@ static void test_bstrncpy_exact(void)
        fr_sbuff_init(&sbuff, in, sizeof(in));
 
        TEST_CASE("Copy 5 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 5);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5);
        TEST_CHECK_SLEN(5, slen);
        TEST_CHECK_STRCMP("i am ", out);
        TEST_CHECK_STRCMP("a test string", sbuff.p);
 
        TEST_CASE("Copy 13 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 13);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 13);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("a test string", out);
        TEST_CHECK_STRCMP("", sbuff.p);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun input");
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 1);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 1);
        TEST_CHECK_SLEN(0, slen);
        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));
 
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(-7, slen);
        TEST_CHECK(sbuff.p == sbuff.start);
 
        TEST_CASE("Zero length output buffer");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, SIZE_MAX);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(-25, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -119,7 +119,7 @@ static void test_bstrncpy_exact(void)
        TEST_CASE("Zero length size");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, 0);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, 0);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -136,34 +136,34 @@ static void test_bstrncpy(void)
        fr_sbuff_init(&sbuff, in, sizeof(in));
 
        TEST_CASE("Copy 5 bytes to out");
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 5);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5);
        TEST_CHECK_SLEN(5, slen);
        TEST_CHECK_STRCMP("i am ", out);
        TEST_CHECK_STRCMP("a test string", sbuff.p);
 
        TEST_CASE("Copy 13 bytes to out");
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 13);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 13);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("a test string", out);
        TEST_CHECK_STRCMP("", sbuff.p);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun input");
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 1);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 1);
        TEST_CHECK_SLEN(0, slen);
        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));
 
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(18, slen);
        TEST_CHECK_STRCMP("i am a longer test", out);
 
        TEST_CASE("Zero length output buffer");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, SIZE_MAX);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, SIZE_MAX);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -171,7 +171,7 @@ static void test_bstrncpy(void)
        TEST_CASE("Zero length size");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, 0);
+       slen = fr_sbuff_out_bstrncpy(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, 0);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -211,34 +211,34 @@ static void test_bstrncpy_allowed(void)
         *      set.
         */
        TEST_CASE("Copy 5 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 5, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5, allow_lowercase_and_space);
        TEST_CHECK_SLEN(5, slen);
        TEST_CHECK_STRCMP("i am ", out);
        TEST_CHECK_STRCMP("a test string", sbuff.p);
 
        TEST_CASE("Copy 13 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 13, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 13, allow_lowercase_and_space);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("a test string", out);
        TEST_CHECK_STRCMP("", sbuff.p);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun input");
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 1, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 1, allow_lowercase_and_space);
        TEST_CHECK_SLEN(0, slen);
        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));
 
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX, allow_lowercase_and_space);
        TEST_CHECK_SLEN(18, slen);
        TEST_CHECK_STRCMP("i am a longer test", out);
 
        TEST_CASE("Zero length output buffer");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, SIZE_MAX, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, SIZE_MAX, allow_lowercase_and_space);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -246,7 +246,7 @@ static void test_bstrncpy_allowed(void)
        TEST_CASE("Zero length size");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, (size_t)1), &sbuff, SIZE_MAX, allow_lowercase_and_space);
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, (size_t)1), &sbuff, SIZE_MAX, allow_lowercase_and_space);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
        TEST_CHECK(sbuff.p == sbuff.start);
@@ -256,28 +256,28 @@ static void test_bstrncpy_allowed(void)
         */
        TEST_CASE("Copy until first t");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX,
                                             allow_lowercase_and_space_no_t);
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (same len as token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, 15), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, 15), &sbuff, SIZE_MAX,
                                             allow_lowercase_and_space_no_t);
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (one shorter than token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                             allow_lowercase_and_space_no_t);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("i am a longer", out);
 
        TEST_CASE("Zero length token (should still be terminated)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_allowed(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                             (bool[UINT8_MAX + 1]){});
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK_STRCMP("", out);
@@ -299,14 +299,14 @@ static void test_bstrncpy_until(void)
         *      set.
         */
        TEST_CASE("Copy 5 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 5,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5,
                                           (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(5, slen);
        TEST_CHECK_STRCMP("i am ", out);
        TEST_CHECK_STRCMP("a test string", sbuff.p);
 
        TEST_CASE("Copy 13 bytes to out");
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 13,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 13,
                                           (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("a test string", out);
@@ -314,14 +314,14 @@ static void test_bstrncpy_until(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun input");
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 1,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 1,
                                           (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Check escapes");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['g'] = true }, 'n');
        TEST_CHECK_SLEN(18, slen);
        TEST_CHECK_STRCMP("i am a test string", out);
@@ -330,7 +330,7 @@ static void test_bstrncpy_until(void)
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
        fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
 
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff,
                                           SIZE_MAX, (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(18, slen);
        TEST_CHECK_STRCMP("i am a longer test", out);
@@ -338,7 +338,7 @@ static void test_bstrncpy_until(void)
        TEST_CASE("Zero length output buffer");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, (size_t)1), &sbuff,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, (size_t)1), &sbuff,
                                           SIZE_MAX, (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
@@ -347,7 +347,7 @@ static void test_bstrncpy_until(void)
        TEST_CASE("Zero length size");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 0,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 0,
                                           (bool[UINT8_MAX + 1]){ }, '\0');
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
@@ -358,28 +358,28 @@ static void test_bstrncpy_until(void)
         */
        TEST_CASE("Copy until first t");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, '\0');
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (same len as token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, 15), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, 15), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, '\0');
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (one shorter than token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, '\0');
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("i am a longer", out);
 
        TEST_CASE("Zero length token (should still be terminated)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_bstrncpy_until(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['i'] = true }, '\0');
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK_STRCMP("", out);
@@ -436,14 +436,14 @@ static void test_unescape_until(void)
         *      set.
         */
        TEST_CASE("Copy 5 bytes to out");
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 5,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 5,
                                           (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(5, slen);
        TEST_CHECK_STRCMP("i am ", out);
        TEST_CHECK_STRCMP("a test string", sbuff.p);
 
        TEST_CASE("Copy 13 bytes to out");
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 13,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 13,
                                           (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("a test string", out);
@@ -451,7 +451,7 @@ static void test_unescape_until(void)
        TEST_CHECK(sbuff.p == sbuff.end);
 
        TEST_CASE("Copy would overrun input");
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 1,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 1,
                                           (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(sbuff.p == sbuff.end);
@@ -459,7 +459,7 @@ static void test_unescape_until(void)
        TEST_CASE("Copy would overrun output (and SIZE_MAX special value)");
        fr_sbuff_init(&sbuff, in_long, sizeof(in_long));
 
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff,
                                           SIZE_MAX, (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(18, slen);
        TEST_CHECK_STRCMP("i am a longer test", out);
@@ -467,7 +467,7 @@ static void test_unescape_until(void)
        TEST_CASE("Zero length output buffer");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, (size_t)1), &sbuff,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, (size_t)1), &sbuff,
                                           SIZE_MAX, (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
@@ -476,7 +476,7 @@ static void test_unescape_until(void)
        TEST_CASE("Zero length size");
        fr_sbuff_set_to_start(&sbuff);
        out[0] = 'a';
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, 0,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, 0,
                                           (bool[UINT8_MAX + 1]){ }, &rules);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK(out[0] == '\0');     /* should be set to \0 */
@@ -487,28 +487,28 @@ static void test_unescape_until(void)
         */
        TEST_CASE("Copy until first t");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, sizeof(out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, sizeof(out)), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, &rules);
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (same len as token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, 15), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, 15), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, &rules);
        TEST_CHECK_SLEN(14, slen);
        TEST_CHECK_STRCMP("i am a longer ", out);
 
        TEST_CASE("Copy until first t with length constraint (one shorter than token)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['t'] = true }, &rules);
        TEST_CHECK_SLEN(13, slen);
        TEST_CHECK_STRCMP("i am a longer", out);
 
        TEST_CASE("Zero length token (should still be terminated)");
        fr_sbuff_set_to_start(&sbuff);
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(out, 14), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(out, 14), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['i'] = true }, &rules);
        TEST_CHECK_SLEN(0, slen);
        TEST_CHECK_STRCMP("", out);
@@ -518,7 +518,7 @@ static void test_unescape_until(void)
         */
        TEST_CASE("Escape with substition to same char");
        fr_sbuff_init(&sbuff, in_escapes, sizeof(in_escapes));
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules);
        TEST_CHECK_SLEN(20, slen);
        TEST_CHECK_STRCMP("i am a |t|est string", escape_out);
@@ -526,7 +526,7 @@ static void test_unescape_until(void)
 
        TEST_CASE("Escape with substition to different char");
        fr_sbuff_init(&sbuff, in_escapes, sizeof(in_escapes));
-       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
+       slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(escape_out, sizeof(escape_out)), &sbuff, SIZE_MAX,
                                           (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_sub);
        TEST_CHECK_SLEN(20, slen);
        TEST_CHECK_STRCMP("i am a |t|est strinh", escape_out);
@@ -537,7 +537,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Escape with hex substitutions (insufficient output space)");
                fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_sub_hex);
                TEST_CHECK_SLEN(24, slen);
@@ -550,7 +550,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Escape with hex substitutions (sufficient output space)");
                fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_sub_hex);
                TEST_CHECK_SLEN(25, slen);
@@ -563,7 +563,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Escape with oct substitutions (insufficient output space)");
                fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_sub_oct);
                TEST_CHECK_SLEN(28, slen);
@@ -576,7 +576,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Escape with oct substitutions (sufficient output space)");
                fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_sub_oct);
                TEST_CHECK_SLEN(29, slen);
@@ -589,7 +589,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Escape with hex and oct substitutions (sufficient output space)");
                fr_sbuff_init(&sbuff, in_escapes_seq, sizeof(in_escapes_seq));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ ['g'] = true }, &pipe_rules_both);
                TEST_CHECK_SLEN(26, slen);
@@ -603,7 +603,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Collapse double escapes");
                fr_sbuff_init(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ }, &pipe_rules);
                TEST_CHECK_SLEN(1, slen);
@@ -616,7 +616,7 @@ static void test_unescape_until(void)
 
                TEST_CASE("Collapse double escapes overlapping");
                fr_sbuff_init(&sbuff, in_escapes_collapse, sizeof(in_escapes_collapse));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(in_escapes_collapse, sizeof(in_escapes_collapse)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(in_escapes_collapse, sizeof(in_escapes_collapse)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ }, &pipe_rules);
                TEST_CHECK_SLEN(5, slen);
@@ -665,7 +665,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));
-               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_TMP(tmp_out, sizeof(tmp_out)),
+               slen = fr_sbuff_out_unescape_until(&FR_SBUFF_OUT(tmp_out, sizeof(tmp_out)),
                                                   &sbuff, SIZE_MAX,
                                                   (bool[UINT8_MAX + 1]){ }, &double_quote_rules);
                TEST_CHECK_SLEN(28, slen);
@@ -681,7 +681,7 @@ static void test_unescape_until(void)
                size_t          len;
                char const      in_zero[] = "";
 
-               len = fr_sbuff_out_aunescape_until(NULL, &buff, &FR_SBUFF_TMP(in_zero, sizeof(in_zero)),
+               len = fr_sbuff_out_aunescape_until(NULL, &buff, &FR_SBUFF_IN(in_zero, sizeof(in_zero) - 1),
                                                   SIZE_MAX, (bool[UINT8_MAX + 1]){ }, &pipe_rules);
                TEST_CHECK_SLEN(0, len);
                talloc_get_type_abort(buff, char);
@@ -701,7 +701,7 @@ static void test_no_advance(void)
 
        TEST_CASE("Copy 5 bytes to out - no advance");
        TEST_CHECK(sbuff.p == sbuff.start);
-       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_TMP(out, sizeof(out)), &FR_SBUFF_NO_ADVANCE(&sbuff), 5);
+       slen = fr_sbuff_out_bstrncpy_exact(&FR_SBUFF_OUT(out, sizeof(out)), &FR_SBUFF_NO_ADVANCE(&sbuff), 5);
        TEST_CHECK(slen == 5);
        TEST_CHECK(strcmp(out, "i am ") == 0);
        TEST_CHECK(sbuff.p == sbuff.start);

diff --git a/src/lib/util/value.c b/src/lib/util/value.c
index ad52fbf96cc0acda7102c9a8eb9e530016fd4c3d..2b21c486e32ea4659fd3065815524711a83444d9 100644 (file)
--- a/src/lib/util/value.c
+++ b/src/lib/util/value.c
@@ -4354,11 +4354,11 @@ int fr_value_box_from_str(TALLOC_CTX *ctx, fr_value_box_t *dst,
 
                if (len > (sizeof(buffer) - 1)) {
                        name_len = fr_value_str_aunescape(NULL, &tmp,
-                                                         &FR_SBUFF_TMP(in, len + 1), SIZE_MAX, quote);
+                                                         &FR_SBUFF_IN(in, len), SIZE_MAX, quote);
                        name = tmp;
                } else {
-                       name_len = fr_value_str_unescape(&FR_SBUFF_TMP(buffer, sizeof(buffer)),
-                                                        &FR_SBUFF_TMP(in, len + 1), SIZE_MAX, quote);
+                       name_len = fr_value_str_unescape(&FR_SBUFF_OUT(buffer, sizeof(buffer)),
+                                                        &FR_SBUFF_IN(in, len), SIZE_MAX, quote);
                        name = buffer;
                }
                fr_assert(name);
@@ -4395,7 +4395,7 @@ parse:
        {
                char *buff;
 
-               ret = fr_value_str_aunescape(ctx, &buff, &FR_SBUFF_TMP(in, len + 1), SIZE_MAX, quote);
+               ret = fr_value_str_aunescape(ctx, &buff, &FR_SBUFF_IN(in, len), SIZE_MAX, quote);
                talloc_get_type_abort(buff, char);
                dst->vb_strvalue = buff;
        }
@@ -5214,8 +5214,8 @@ int fr_value_box_list_flatten_argv(TALLOC_CTX *ctx, char ***argv_p, fr_value_box
                         */
                        if ((argv[i][0] == '"') || (argv[i][0] == '\'')) {
                                size_t inlen = talloc_array_length(argv[i]);
-                               fr_value_substr_unescape(&FR_SBUFF_TMP(argv[i], inlen),
-                                                        &FR_SBUFF_TMP(argv[i] + 1, inlen - 1),
+                               fr_value_substr_unescape(&FR_SBUFF_OUT(argv[i], inlen),
+                                                        &FR_SBUFF_IN(argv[i] + 1, inlen - 1),
                                                         SIZE_MAX, *argv[i]);
                        }
 

diff --git a/src/modules/rlm_redis_ippool/rlm_redis_ippool_tool.c b/src/modules/rlm_redis_ippool/rlm_redis_ippool_tool.c
index e11f629712ecb5ae4b196a6b08f792cb0cbf7de0..f26f6b63826ba370ec7a75c1ef2c84f076ac0a95 100644 (file)
--- a/src/modules/rlm_redis_ippool/rlm_redis_ippool_tool.c
+++ b/src/modules/rlm_redis_ippool/rlm_redis_ippool_tool.c
@@ -1352,7 +1352,7 @@ do { \
 
                MEM(fr_sbuff_init_talloc(NULL, &out, &tctx, strlen(argv[1]), SIZE_MAX));
                len = fr_value_str_unescape(&out,
-                                           &FR_SBUFF_TMP(argv[1], strlen(argv[1]) + 1), SIZE_MAX, '"');
+                                           &FR_SBUFF_IN(argv[1], strlen(argv[1])), SIZE_MAX, '"');
                fr_sbuff_trim_talloc(&out, fr_sbuff_used(&out));        /* We don't want a NULL terminating byte */
                if (!fr_cond_assert(len)) fr_exit_now(EXIT_FAILURE);
                pool_arg = (uint8_t *)fr_sbuff_start(&out);
@@ -1365,7 +1365,7 @@ do { \
 
                MEM(fr_sbuff_init_talloc(NULL, &out, &tctx, strlen(argv[1]), SIZE_MAX));
                len = fr_value_str_unescape(&out,
-                                           &FR_SBUFF_TMP(argv[2], strlen(argv[2]) + 1), SIZE_MAX, '"');
+                                           &FR_SBUFF_IN(argv[2], strlen(argv[2])), SIZE_MAX, '"');
                fr_sbuff_trim_talloc(&out, fr_sbuff_used(&out));        /* We don't want a NULL terminating byte */
                if (!fr_cond_assert(len)) fr_exit_now(EXIT_FAILURE);
                range_arg = (uint8_t *)fr_sbuff_start(&out);