From: Arran Cudbard-Bell <a.cudbardb@freeradius.org>
Date: Mon, 28 Jun 2021 23:17:08 +0000 (-0500)
Subject: Change dbuff macro names to make auto-advancing the exception
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=09f376d22af7e6427aa59aef35b789f7801705e2;p=thirdparty%2Ffreeradius-server.git

Change dbuff macro names to make auto-advancing the exception
---

diff --git a/doc/antora/modules/developers/pages/dbuff.adoc b/doc/antora/modules/developers/pages/dbuff.adoc
index 360ae8a55bf..58f1951a9c0 100644
--- a/doc/antora/modules/developers/pages/dbuff.adoc
+++ b/doc/antora/modules/developers/pages/dbuff.adoc
@@ -113,21 +113,21 @@ will allow reading or writing outside of the buffer.
 A child dbuff operates on a portion of the buffer, starting where the
 parent left off. The creator can control two things about the child:
 
-* The space available to the child (`FR_DBUFF_MAX()` gives a child
+* The space available to the child (`FR_DBUFF_MAX_BIND_CURRENT()` gives a child
   dbuff with no more than a specified number of bytes available).
 * Whether the child's advances propagate up to its parents
-  (`FR_DBUFF_NO_ADVANCE()` gives a child dbuff whose advances don't
+  (`FR_DBUFF()` gives a child dbuff whose advances don't
   propagate).
 
 [IMPORTANT]
 ====
-`FR_DBUFF_MAX()` cannot fail.  It is like an ad promising "up to one
+`FR_DBUFF_MAX_BIND_CURRENT()` cannot fail.  It is like an ad promising "up to one
 million dollars!" where "up to" includes zero, so the child may have
 less space than the specified maximum.
 ====
 
-`FR_DBUFF_MAX()` typically shows up when a caller limits a callee to
-what will fit in a TLV in some context. `FR_DBUFF_NO_ADVANCE()` came
+`FR_DBUFF_MAX_BIND_CURRENT()` typically shows up when a caller limits a callee to
+what will fit in a TLV in some context. `FR_DBUFF()` came
 into existence to let an encoding function write a header and then
 take it back if it proved useless, but it can also be used to let one
 fill in a header when a length is finally known, and this schema has
@@ -137,7 +137,7 @@ become a convention:
 ----
 ssize_t encode_foo(fr_dbuff_t *dbuff, ...)
 {
-	fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t work_dbuff = FR_DBUFF(dbuff);
 
 	/* encode, operating on work_dbuff, returning on error */
 
diff --git a/src/lib/eap_aka_sim/encode.c b/src/lib/eap_aka_sim/encode.c
index 3ac1c42295a..3247cfff033 100644
--- a/src/lib/eap_aka_sim/encode.c
+++ b/src/lib/eap_aka_sim/encode.c
@@ -103,7 +103,7 @@ static ssize_t encode_iv(fr_dbuff_t *dbuff, void *encode_ctx)
 {
 	fr_aka_sim_ctx_t	*packet_ctx = encode_ctx;
 	uint32_t		iv[4];
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	/*
 	 *	One IV per packet
@@ -154,7 +154,7 @@ static ssize_t encode_encrypted_value(fr_dbuff_t *dbuff,
 			     	      uint8_t const *in, size_t inlen, void *encode_ctx)
 {
 	size_t			total_len, pad_len, encr_len, len = 0;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	uint8_t			*encr = NULL;
 	fr_aka_sim_ctx_t	*packet_ctx = encode_ctx;
 	EVP_CIPHER_CTX		*evp_ctx;
@@ -271,7 +271,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, int depth,
 			    fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_aka_sim_ctx_t	*packet_ctx = encode_ctx;
@@ -518,8 +518,8 @@ static ssize_t encode_array(fr_dbuff_t *dbuff,
 	size_t			pad_len;
 	size_t			element_len;
 	size_t			actual_len;
-	fr_dbuff_t		len_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		len_dbuff = FR_DBUFF(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_assert(da->flags.array);
 
@@ -588,8 +588,8 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
 	size_t			pad_len;
 	fr_dict_attr_t const	*da;
 	ssize_t			slen;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
-	fr_dbuff_t		hdr_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
+	fr_dbuff_t		hdr_dbuff = FR_DBUFF(dbuff);
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
 
@@ -623,10 +623,10 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
 	fr_dbuff_advance(&work_dbuff, 2);
 
 	if (da->flags.array) {
-		slen = encode_array(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
+		slen = encode_array(&FR_DBUFF_MAX_BIND_CURRENT(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
 				    da_stack, depth, cursor, encode_ctx);
 	} else {
-		slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
+		slen = encode_value(&FR_DBUFF_MAX_BIND_CURRENT(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
 				    da_stack, depth, cursor, encode_ctx);
 	}
 	if (slen <= 0) return slen;
@@ -652,7 +652,7 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 					  fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN);
 	fr_dbuff_t		value_dbuff;
 	fr_dbuff_marker_t	value_start;
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
@@ -660,7 +660,7 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 
 	FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00, 0x00);
 
-	value_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
+	value_dbuff = FR_DBUFF(&work_dbuff);
 	fr_dbuff_marker(&value_start, &value_dbuff);
 
 	for (;;) {
@@ -730,7 +730,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 	ssize_t			len;
 	fr_dict_attr_t const	*da;
 	fr_dbuff_t		tl_dbuff;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	VP_VERIFY(fr_dcursor_current(cursor));
 	FR_PROTO_STACK_PRINT(da_stack, depth);
@@ -755,13 +755,13 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 		len = encode_iv(&work_dbuff, encode_ctx);
 		if (len < 0) return len;
 	}
-	tl_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
+	tl_dbuff = FR_DBUFF(&work_dbuff);
 
 	FR_DBUFF_EXTEND_LOWAT_OR_RETURN(&work_dbuff, 2);
 	fr_dbuff_advance(&work_dbuff, 2);
 
 	da = da_stack->da[depth];
-	len = encode_tlv_internal(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
+	len = encode_tlv_internal(&FR_DBUFF_MAX_BIND_CURRENT(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
 				  da_stack, depth, cursor, encode_ctx);
 	if (len <= 0) return len;
 
@@ -781,7 +781,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_pair_t const		*vp;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	m;
 	ssize_t			slen;
 
@@ -820,7 +820,7 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 		da_stack.da[1] = NULL;
 		da_stack.depth = 1;
 		FR_PROTO_STACK_PRINT(&da_stack, 0);
-		return encode_rfc_hdr(&FR_DBUFF_MAX(dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
+		return encode_rfc_hdr(&FR_DBUFF_MAX_BIND_CURRENT(dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
 				      &da_stack, 0, cursor, encode_ctx);
 	}
 
@@ -837,13 +837,13 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 	 *	Supported types
 	 */
 	default:
-		slen = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
+		slen = encode_rfc_hdr(&FR_DBUFF_MAX_BIND_CURRENT(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
 				      &da_stack, 0, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		break;
 
 	case FR_TYPE_TLV:
-		slen = encode_tlv_hdr(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
+		slen = encode_tlv_hdr(&FR_DBUFF_MAX_BIND_CURRENT(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
 				      &da_stack, 0, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		break;
diff --git a/src/lib/util/base16.c b/src/lib/util/base16.c
index 3628e7da057..db12794dd0a 100644
--- a/src/lib/util/base16.c
+++ b/src/lib/util/base16.c
@@ -115,7 +115,7 @@ uint8_t const fr_base16_alphabet_decode_mc[UINT8_MAX] = {
 ssize_t fr_base16_encode_nstd(fr_sbuff_t *out, fr_dbuff_t *in, char const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t	our_out = FR_SBUFF_NO_ADVANCE(out);
-	fr_dbuff_t	our_in = FR_DBUFF_NO_ADVANCE(in);
+	fr_dbuff_t	our_in = FR_DBUFF(in);
 
 	while (fr_dbuff_extend(&our_in)) {
 		uint8_t a = *fr_dbuff_current(&our_in);
@@ -145,7 +145,7 @@ ssize_t fr_base16_decode_nstd(fr_sbuff_parse_error_t *err, fr_dbuff_t *out, fr_s
 			      bool no_trailing, uint8_t const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t	our_in = FR_SBUFF_NO_ADVANCE(in);
-	fr_dbuff_t	our_out = FR_DBUFF_NO_ADVANCE(out);
+	fr_dbuff_t	our_out = FR_DBUFF(out);
 
 	while (fr_sbuff_extend_lowat(NULL, &our_in, 2) >= 2) {
 		char	*p = fr_sbuff_current(&our_in);
diff --git a/src/lib/util/base32.c b/src/lib/util/base32.c
index d095421ea0e..87f69fbf5bc 100644
--- a/src/lib/util/base32.c
+++ b/src/lib/util/base32.c
@@ -192,7 +192,7 @@ ssize_t fr_base32_encode_nstd(fr_sbuff_t *out, fr_dbuff_t *in,
 			      bool add_padding, char const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t		our_out = FR_SBUFF_NO_ADVANCE(out);
-	fr_dbuff_t		our_in = FR_DBUFF_NO_ADVANCE(in);
+	fr_dbuff_t		our_in = FR_DBUFF(in);
 
 	fr_strerror_const("Insufficient buffer space");
 
@@ -317,7 +317,7 @@ ssize_t fr_base32_decode_nstd(fr_sbuff_parse_error_t *err, fr_dbuff_t *out, fr_s
 			      bool expect_padding, bool no_trailing, uint8_t const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t		our_in = FR_SBUFF_NO_ADVANCE(in);
-	fr_dbuff_t		our_out = FR_DBUFF_NO_ADVANCE(out);
+	fr_dbuff_t		our_out = FR_DBUFF(out);
 	fr_sbuff_marker_t	m_final;
 	size_t			len;
 	uint8_t			pad;
diff --git a/src/lib/util/base64.c b/src/lib/util/base64.c
index b9c112ab8a1..30c5bc43774 100644
--- a/src/lib/util/base64.c
+++ b/src/lib/util/base64.c
@@ -328,7 +328,7 @@ ssize_t fr_base64_encode_nstd(fr_sbuff_t *out, fr_dbuff_t *in,
 			      bool add_padding, char const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t		our_out = FR_SBUFF_NO_ADVANCE(out);
-	fr_dbuff_t		our_in = FR_DBUFF_NO_ADVANCE(in);
+	fr_dbuff_t		our_in = FR_DBUFF(in);
 
 	fr_strerror_const("Insufficient buffer space");
 
@@ -403,7 +403,7 @@ ssize_t	fr_base64_decode_nstd(fr_sbuff_parse_error_t *err, fr_dbuff_t *out, fr_s
 			      bool expect_padding, bool no_trailing, uint8_t const alphabet[static UINT8_MAX])
 {
 	fr_sbuff_t		our_in = FR_SBUFF_NO_ADVANCE(in);
-	fr_dbuff_t		our_out = FR_DBUFF_NO_ADVANCE(out);
+	fr_dbuff_t		our_out = FR_DBUFF(out);
 	fr_sbuff_marker_t	m_final;
 	uint8_t			pad;
 
diff --git a/src/lib/util/dbuff.h b/src/lib/util/dbuff.h
index 4d27d27693b..782cf94e6a0 100644
--- a/src/lib/util/dbuff.h
+++ b/src/lib/util/dbuff.h
@@ -55,7 +55,7 @@ extern "C" {
  * dbuffs are intended to be organised into hierarchies, with one dbuff per stack
  * frame, initialised from a parent in a higher stack frame.
  *
- * Each time a dbuff is copied (using one of the provided FR_DBUFF_COPY_* macros),
+ * Each time a dbuff is copied (using one of the provided FR_DBUFF_BIND_CURRENT_* macros),
  * the copy's 'start' position is updated to be the 'current' position of its
  * parent.  This ensures length macros report only spaced used/available in the
  * new dbuff and not its parent.
@@ -121,6 +121,11 @@ struct fr_dbuff_marker_s {
 	fr_dbuff_t		*parent;	//!< Owner of the marker.
 };
 
+#define FR_DBUFF_ADV_PARENT_CURRENT	0x01		//!< Advance current position of parent.
+							//!< Useful for nested encoders/decoders.
+#define FR_DBUFF_ADV_PARENT_END		0x02		//!< Advance end pointer of parent.
+							///< Useful for producer/consumer
+
 /** A dbuff
  * @private
  */
@@ -153,8 +158,8 @@ struct fr_dbuff_s {
 		uint8_t *p;				//!< Mutable 'current' pointer.
 	};
 
-	uint8_t			is_const:1;	//!< The buffer this dbuff wraps is const.
-	uint8_t			adv_parent:1;	//!< Whether we advance the parent
+	uint8_t			is_const:1;		//!< The buffer this dbuff wraps is const.
+	uint8_t			adv_parent:2;	//!< Whether we advance the parent
 						///< of this dbuff.
 
 	size_t			shifted;	//!< How many bytes this sbuff has been
@@ -192,7 +197,7 @@ do { \
  *
  * @private
  */
-#define _FR_DBUFF_COPY(_dbuff_or_marker, _start, _adv_parent) \
+#define _FR_DBUFF(_dbuff_or_marker, _start, _adv_parent) \
 ((fr_dbuff_t){ \
 	.buff		= fr_dbuff_buff(_dbuff_or_marker), \
 	.start		= (_start), \
@@ -207,38 +212,55 @@ do { \
 })
 /* @endcond */
 
-/** Prevent an dbuff being advanced by operations on its child
+/** Create a new dbuff pointing to the same underlying buffer
  *
- * @private
+ * - Parent will _NOT_ be advanced by operations on its child.
+ * - Child will have its `start` pointer set to the `p` pointer of the parent.
  *
  * @param[in] _dbuff_or_marker	to make an ephemeral copy of.
  */
-#define FR_DBUFF_NO_ADVANCE(_dbuff_or_marker) _FR_DBUFF_COPY(_dbuff_or_marker, fr_dbuff_current(_dbuff_or_marker), false)
+#define FR_DBUFF(_dbuff_or_marker) _FR_DBUFF(_dbuff_or_marker, fr_dbuff_current(_dbuff_or_marker), 0x00)
 
-/** Prevent an dbuff being advanced by operations on its child
+/** Create a new dbuff pointing to the same underlying buffer
  *
- * Does not change the start pointer of the new dbuff.
+ * - Parent will _NOT_ be advanced by operations on its child.
+ * - Child will have its `start` pointer set to the `start` pointer of the parent.
  *
  * @param[in] _dbuff_or_marker	to make an ephemeral copy of.
  */
-#define FR_DBUFF_NO_ADVANCE_ABS(_dbuff_or_marker) _FR_DBUFF_COPY(_dbuff_or_marker, fr_dbuff_start(_dbuff_or_marker), false)
+#define FR_DBUFF_ABS(_dbuff_or_marker) _FR_DBUFF(_dbuff_or_marker, fr_dbuff_start(_dbuff_or_marker), 0x00)
 
-/** Let the dbuff be advanced by operations on its child
+/** Create a new dbuff pointing to the same underlying buffer
+ *
+ * - Parent `p` pointer will be advanced with child's `p` pointer.
+ * - Child will have its `start` pointer set to the `p` pointer of the parent.
  *
  * @param[in] _dbuff_or_marker	to make an ephemeral copy of.
  */
-#define FR_DBUFF_COPY(_dbuff_or_marker) _FR_DBUFF_COPY(_dbuff_or_marker, fr_dbuff_current(_dbuff_or_marker), true)
+#define FR_DBUFF_BIND_CURRENT(_dbuff_or_marker) _FR_DBUFF(_dbuff_or_marker, fr_dbuff_current(_dbuff_or_marker), FR_DBUFF_ADV_PARENT_CURRENT)
 
-/** Let the dbuff be advanced by operations on its child
+/** Create a new dbuff pointing to the same underlying buffer
+ *
+ * - Parent `p` pointer will be advanced with child's `p` pointer.
+ * - Child will have its `start` pointer set to the `start` pointer of the parent.
+ *
+ * @param[in] _dbuff_or_marker	to make an ephemeral copy of.
+ */
+#define FR_DBUFF_BIND_CURRENT_ABS(_dbuff_or_marker) FR_DBUFF_ABS(_dbuff_or_marker, fr_dbuff_start(_dbuff_or_marker), FR_DBUFF_ADV_PARENT_CURRENT)
+
+/** Create a new dbuff pointing to the same underlying buffer
+ *
+ * This is used to create the producer of a producer/consumer pairs of dbuffs.
  *
- * Does not change the start pointer of the new dbuff.
+ * - Parent `end` pointer will be advanced with child's `p` pointer.
+ * - Child will have its `start` pointer set to the `start` pointer of the parent.
  *
  * @param[in] _dbuff_or_marker	to make an ephemeral copy of.
  */
-#define FR_DBUFF_COPY_ABS(_dbuff_or_marker) _FR_DBUFF_COPY_ABS(_dbuff_or_marker, fr_dbuff_start(_dbuff_or_marker), true)
+#define FR_DBUFF_BIND_END_ABS(_dbuff_or_marker) _FR_DBUFF(_dbuff_or_marker, fr_dbuff_start(_dbuff_or_marker), FR_DBUFF_ADV_PARENT_END)
 
 /** @cond */
-/** Limit available bytes in the dbufft to _max when passing it to another function
+/** Limit available bytes in the dbuff to _max when passing it to another function
  *
  * @private
  */
@@ -260,7 +282,11 @@ do { \
 /** Limit the maximum number of bytes available in the dbuff when passing it to another function
  *
  @code{.c}
- my_child_encoder(&FR_DBUFF_MAX(dbuff, 253), vp);
+ fr_dbuff_t tlv = FR_DBUFF_MAX(dbuff, UINT8_MAX);
+
+ if (my_child_encoder(&tlv, vp) < 0) return -1;
+
+ return fr_dbuff_advance(dbuff, fr_dbuff_used(tlv))
  @endcode
  *
  * @note Do not use to re-initialise the contents of _dbuff, i.e. to
@@ -272,16 +298,12 @@ do { \
  * @param[in] _dbuff_or_marker	to reserve bytes in.
  * @param[in] _max		The maximum number of bytes the caller is allowed to write to.
  */
-#define FR_DBUFF_MAX(_dbuff_or_marker,  _max) _FR_DBUFF_MAX(_dbuff_or_marker, _max, true)
+#define FR_DBUFF_MAX(_dbuff_or_marker,  _max) _FR_DBUFF_MAX(_dbuff_or_marker, _max, 0x00)
 
 /** Limit the maximum number of bytes available in the dbuff when passing it to another function
  *
  @code{.c}
- fr_dbuff_t tlv = FR_DBUFF_MAX_NO_ADVANCE(dbuff, UINT8_MAX);
-
- if (my_child_encoder(&tlv, vp) < 0) return -1;
-
- return fr_dbuff_advance(dbuff, fr_dbuff_used(tlv))
+ my_child_encoder(&FR_DBUFF_MAX_BIND_CURRENT(dbuff, 253), vp);
  @endcode
  *
  * @note Do not use to re-initialise the contents of _dbuff, i.e. to
@@ -293,7 +315,7 @@ do { \
  * @param[in] _dbuff_or_marker	to reserve bytes in.
  * @param[in] _max		The maximum number of bytes the caller is allowed to write to.
  */
-#define FR_DBUFF_MAX_NO_ADVANCE(_dbuff_or_marker,  _max) _FR_DBUFF_MAX(_dbuff_or_marker, _max, false)
+#define FR_DBUFF_MAX_BIND_CURRENT(_dbuff_or_marker,  _max) _FR_DBUFF_MAX(_dbuff_or_marker, _max, FR_DBUFF_ADV_PARENT_CURRENT)
 
 /** Does the actual work of initialising a dbuff
  * @private
@@ -877,10 +899,12 @@ size_t	fr_dbuff_shift(fr_dbuff_t *dbuff, size_t shift);
 /** Set a new 'current' position in a dbuff or marker
  * @private
  */
-static inline void _fr_dbuff_set_recurse(fr_dbuff_t *dbuff, uint8_t const *p)
+static inline void _fr_dbuff_set_recurse(fr_dbuff_t *dbuff, uint8_t adv_parent_flags, uint8_t const *p)
 {
-	dbuff->p_i = p;
-	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, p);
+	if (adv_parent_flags & FR_DBUFF_ADV_PARENT_CURRENT) dbuff->p_i = p;
+	if (adv_parent_flags & FR_DBUFF_ADV_PARENT_END) dbuff->end_i = p;
+
+	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, dbuff->adv_parent, p);
 }
 
 /** Set a new 'current' position in a dbuff or marker
@@ -903,7 +927,7 @@ static inline ssize_t _fr_dbuff_set(uint8_t **pos_p, fr_dbuff_t *dbuff, uint8_t
 	if (unlikely(p < dbuff->start)) return 0;
 
 	c = *pos_p;
-	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, p);
+	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, dbuff->adv_parent, p);
 	*pos_p = UNCONST(uint8_t *, p);
 
 	return p - c;
@@ -1043,7 +1067,7 @@ static inline ssize_t _fr_dbuff_advance_extend(uint8_t **pos_p, fr_dbuff_t *dbuf
 		*pos_p += len;
 	}
 
-	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, *pos_p);
+	if (dbuff->adv_parent && dbuff->parent) _fr_dbuff_set_recurse(dbuff->parent, dbuff->adv_parent, *pos_p);
 
 	return len;
 }
@@ -1069,7 +1093,7 @@ static inline ssize_t _fr_dbuff_advance_extend(uint8_t **pos_p, fr_dbuff_t *dbuf
 			  	int : (size_t)(_len) \
 			  )))
 
-#define FR_DBUFF_ADVANCE_EXTEND_RETURN(_dbuff_or_marker, _len) FR_DBUFF_RETURN(fr_dbuff_advance_extend, _dbuff_or_marker, _len)
+#define FR_DBUFF_BIND_EXTEND_RETURN(_dbuff_or_marker, _len) FR_DBUFF_RETURN(fr_dbuff_advance_extend, _dbuff_or_marker, _len)
 
 /** Reset the 'current' position of the dbuff or marker to the 'start' of the buffer
  *
diff --git a/src/lib/util/dbuff_tests.c b/src/lib/util/dbuff_tests.c
index 8ced1bee86b..ebdf70e2849 100644
--- a/src/lib/util/dbuff_tests.c
+++ b/src/lib/util/dbuff_tests.c
@@ -82,10 +82,10 @@ static void test_dbuff_max(void)
 	TEST_CASE("Confirm max constrains available space");
 	fr_dbuff_init(&dbuff, in, sizeof(in));
 
-	max_dbuff = FR_DBUFF_MAX(&dbuff, 4);
+	max_dbuff = FR_DBUFF_MAX_BIND_CURRENT(&dbuff, 4);
 	TEST_CHECK(fr_dbuff_remaining(&max_dbuff) == 4);
 
-	max_dbuff = FR_DBUFF_MAX(&dbuff, 2 * sizeof(in));
+	max_dbuff = FR_DBUFF_MAX_BIND_CURRENT(&dbuff, 2 * sizeof(in));
 	TEST_CHECK(fr_dbuff_remaining(&max_dbuff) == sizeof(in));
 }
 
@@ -235,7 +235,7 @@ static void test_dbuff_no_advance(void)
 	TEST_CASE("Confirm no-advance dbuff operations don't affect ancestors' position");
 	fr_dbuff_init(&dbuff, in, sizeof(in));
 
-	no_advance_dbuff = FR_DBUFF_NO_ADVANCE(&dbuff);
+	no_advance_dbuff = FR_DBUFF(&dbuff);
 	init_remaining = fr_dbuff_remaining(&dbuff);
 	fr_dbuff_in_bytes(&no_advance_dbuff, 0x11, 0x12, 0x13);
 	TEST_CHECK(init_remaining == fr_dbuff_remaining(&dbuff));
@@ -334,15 +334,15 @@ static void test_dbuff_talloc_extend_multi_level(void)
 	TEST_CHECK(fr_dbuff_used(&dbuff1) == 0);
 	TEST_CHECK(fr_dbuff_remaining(&dbuff1) == 0);
 
-	dbuff2 = FR_DBUFF_NO_ADVANCE(&dbuff1);
+	dbuff2 = FR_DBUFF(&dbuff1);
 	TEST_CASE("Check that dbuff2 inherits extend fields");
 	TEST_CHECK(dbuff2.extend == dbuff1.extend);
 	TEST_CHECK(dbuff2.uctx == dbuff1.uctx);
 	TEST_CHECK(fr_dbuff_used(&dbuff2) == 0);
 	TEST_CHECK(fr_dbuff_remaining(&dbuff2) == 0);
 
-	dbuff2 = FR_DBUFF_MAX(&dbuff1, 8);
-	TEST_CASE("Check that FR_DBUFF_MAX() is not extensible");
+	dbuff2 = FR_DBUFF_MAX_BIND_CURRENT(&dbuff1, 8);
+	TEST_CASE("Check that FR_DBUFF_MAX_BIND_CURRENT() is not extensible");
 	TEST_CHECK(dbuff2.extend == NULL);
 	TEST_CHECK(dbuff2.uctx == NULL);
 	TEST_CHECK(fr_dbuff_used(&dbuff2) == 0);
diff --git a/src/lib/util/struct.c b/src/lib/util/struct.c
index 1d17bee355d..f7a3b9cd77e 100644
--- a/src/lib/util/struct.c
+++ b/src/lib/util/struct.c
@@ -408,8 +408,8 @@ ssize_t fr_struct_to_network(fr_dbuff_t *dbuff,
 			     fr_dcursor_t *parent_cursor, void *encode_ctx,
 			     fr_encode_dbuff_t encode_value, fr_encode_dbuff_t encode_tlv)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
-	fr_dbuff_t		hdr_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
+	fr_dbuff_t		hdr_dbuff = FR_DBUFF(dbuff);
 	int			offset = 0;
 	unsigned int		child_num = 1;
 	bool			do_length = false;
diff --git a/src/lib/util/value.c b/src/lib/util/value.c
index f0dd169c982..f3921612e90 100644
--- a/src/lib/util/value.c
+++ b/src/lib/util/value.c
@@ -1189,7 +1189,7 @@ size_t fr_value_box_network_length(fr_value_box_t *value)
 ssize_t fr_value_box_to_network(fr_dbuff_t *dbuff, fr_value_box_t const *value)
 {
 	size_t		min, max;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	/*
 	 *	Variable length types
@@ -1519,7 +1519,7 @@ ssize_t fr_value_box_from_network_dbuff(TALLOC_CTX *ctx,
 					bool tainted)
 {
 	size_t		min, max;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	min = network_min_size(type);
 	max = network_max_size(type);
diff --git a/src/protocols/arp/base.c b/src/protocols/arp/base.c
index 86b5d5441ae..ac921195882 100644
--- a/src/protocols/arp/base.c
+++ b/src/protocols/arp/base.c
@@ -150,7 +150,7 @@ ssize_t fr_arp_encode(fr_dbuff_t *dbuff, uint8_t const *original, fr_pair_list_t
 	fr_arp_packet_t		*arp;
 	fr_dcursor_t		cursor;
 	fr_da_stack_t		da_stack;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	if (fr_pair_list_empty(vps)) {
 		fr_strerror_const("Cannot encode empty packet");
diff --git a/src/protocols/dhcpv4/base.c b/src/protocols/dhcpv4/base.c
index 4005d696582..3375724b320 100644
--- a/src/protocols/dhcpv4/base.c
+++ b/src/protocols/dhcpv4/base.c
@@ -299,7 +299,7 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
 	fr_dcursor_t	cursor;
 	fr_pair_t	*vp;
 	ssize_t	len;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	/*
 	 *	@todo: Make this work again.
diff --git a/src/protocols/dhcpv4/encode.c b/src/protocols/dhcpv4/encode.c
index cb14f6bfb2a..5ef8cedd9ce 100644
--- a/src/protocols/dhcpv4/encode.c
+++ b/src/protocols/dhcpv4/encode.c
@@ -54,7 +54,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_dcursor_t *cursor, UNUSED fr_dhcpv4_ctx_t *encode_ctx)
 {
 	fr_pair_t	*vp = fr_dcursor_current(cursor);
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 	ssize_t		slen;
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
@@ -212,7 +212,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 	fr_dbuff_marker_t	hdr, hdr_io;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_pair_t		*vp = fr_dcursor_current(cursor);
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
 
@@ -337,7 +337,7 @@ static ssize_t encode_option_data(fr_dbuff_t *dbuff,
 
 do_child:
 	fr_dcursor_init(&child_cursor, &vp->vp_group);
-	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	work_dbuff = FR_DBUFF(dbuff);
 
 	while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
 		fr_proto_da_stack_build(da_stack, vp->da);
@@ -387,7 +387,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_dcursor_t *cursor, fr_dhcpv4_ctx_t *encode_ctx)
 {
 	ssize_t			len;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr, next_hdr, dest, hdr_io;
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
@@ -489,7 +489,7 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
 			       fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, 255 - 4 - 1 - 2);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, 255 - 4 - 1 - 2);
 	fr_dbuff_marker_t	hdr;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_dict_attr_t const	*dv;
@@ -599,7 +599,7 @@ ssize_t fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *e
 	unsigned int		depth = 0;
 	fr_da_stack_t		da_stack;
 	ssize_t			len;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	vp = fr_dcursor_current(cursor);
 	if (!vp) return -1;
diff --git a/src/protocols/dhcpv6/base.c b/src/protocols/dhcpv6/base.c
index c2b5cba1040..2ee1d6a28f5 100644
--- a/src/protocols/dhcpv6/base.c
+++ b/src/protocols/dhcpv6/base.c
@@ -776,7 +776,7 @@ void *fr_dhcpv6_next_encodable(fr_dlist_head_t *list, void *to_eval, void *uctx)
  */
 ssize_t	fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t length, int msg_type, fr_pair_list_t *vps)
 {
-	fr_dbuff_t		frame_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		frame_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t		*vp;
 	fr_dict_attr_t const	*root;
 	ssize_t			slen;
diff --git a/src/protocols/dhcpv6/encode.c b/src/protocols/dhcpv6/encode.c
index dcf0ba66ae4..48fbec22e45 100644
--- a/src/protocols/dhcpv6/encode.c
+++ b/src/protocols/dhcpv6/encode.c
@@ -84,7 +84,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 
@@ -379,7 +379,7 @@ static inline ssize_t encode_array(fr_dbuff_t *dbuff,
 {
 	ssize_t			slen;
 	size_t			element_len;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t		*vp;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 
@@ -413,7 +413,7 @@ static inline ssize_t encode_array(fr_dbuff_t *dbuff,
 
 	while (fr_dbuff_extend(&work_dbuff)) {
 		bool		len_field = false;
-		fr_dbuff_t	element_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
+		fr_dbuff_t	element_dbuff = FR_DBUFF(&work_dbuff);
 
 		element_len = fr_dhcpv6_option_len(fr_dcursor_current(cursor));
 
@@ -513,7 +513,7 @@ static ssize_t encode_option_data(fr_dbuff_t *dbuff,
 
 do_child:
 	fr_dcursor_init(&child_cursor, &vp->vp_group);
-	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	work_dbuff = FR_DBUFF(dbuff);
 
 	while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
 		fr_proto_da_stack_build(da_stack, vp->da);
@@ -548,7 +548,7 @@ static ssize_t encode_tlv(fr_dbuff_t *dbuff,
 			  fr_da_stack_t *da_stack, unsigned int depth,
 			  fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	ssize_t			len;
@@ -589,7 +589,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
 			      fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	ssize_t			len;
@@ -627,7 +627,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
 			      fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	ssize_t			len;
@@ -684,7 +684,7 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
 			       fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_dict_attr_t const	*dv;
@@ -819,7 +819,7 @@ ssize_t fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *
 	fr_pair_t		*vp;
 	unsigned int		depth = 0;
 	fr_da_stack_t		da_stack;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, DHCPV6_OPT_HDR_LEN + UINT16_MAX);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, DHCPV6_OPT_HDR_LEN + UINT16_MAX);
 	ssize_t			len;
 
 	vp = fr_dcursor_current(cursor);
diff --git a/src/protocols/internal/decode.c b/src/protocols/internal/decode.c
index 9ff23ff10e3..1ac2cda8da4 100644
--- a/src/protocols/internal/decode.c
+++ b/src/protocols/internal/decode.c
@@ -47,7 +47,7 @@ static ssize_t internal_decode_pair_value(TALLOC_CTX *ctx, fr_pair_list_t *head,
 {
 	fr_pair_t	*vp;
 	ssize_t		slen;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	vp = fr_pair_afrom_da(ctx, parent_da);
 	if (!vp) return PAIR_DECODE_OOM;
@@ -76,7 +76,7 @@ static ssize_t internal_decode_tlv(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dic
 	ssize_t		slen;
 	fr_pair_list_t	children;
 	fr_dcursor_t	cursor;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	FR_PROTO_TRACE("Decoding TLV - %s (%zu bytes)", parent_da->name, fr_dbuff_len(&work_dbuff));
 
@@ -126,7 +126,7 @@ static ssize_t internal_decode_group(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_d
 {
 	fr_pair_t	*vp;
 	ssize_t		slen;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	FR_PROTO_TRACE("Decoding group - %s", parent_da->name);
 
@@ -161,7 +161,7 @@ static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_di
 	uint64_t		len = 0, type = 0;
 	size_t			remaining, needed;
 	bool			tainted, extended, unknown = false, internal = false;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	/*
 	 * The first byte of each attribute describes the encoding format.
@@ -360,7 +360,7 @@ ssize_t fr_internal_decode_pair_dbuff(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_
 	fr_pair_list_t	list;
 	fr_dcursor_t	tmp_cursor;
 	ssize_t		slen;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t	work_dbuff = FR_DBUFF(dbuff);
 
 	fr_pair_list_init(&list);
 
diff --git a/src/protocols/internal/encode.c b/src/protocols/internal/encode.c
index d198c3a25ef..49ec0e1a1c2 100644
--- a/src/protocols/internal/encode.c
+++ b/src/protocols/internal/encode.c
@@ -52,7 +52,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
 			       fr_dcursor_t *cursor, void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	enc_field, len_field, value_field;
 	fr_dbuff_t		value_dbuff;
 	fr_dict_attr_t const	*da = da_stack->da[depth];
@@ -123,7 +123,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 	 *	if the length field needs more than one byte will guard
 	 *	against insufficient space.
 	 */
-	value_dbuff = FR_DBUFF_COPY(&work_dbuff);
+	value_dbuff = FR_DBUFF_BIND_CURRENT(&work_dbuff);
 	fr_dbuff_marker(&value_field, &value_dbuff);
 
 	switch (da->type) {
diff --git a/src/protocols/radius/base.c b/src/protocols/radius/base.c
index 99b4a4d1bb3..44643854721 100644
--- a/src/protocols/radius/base.c
+++ b/src/protocols/radius/base.c
@@ -237,7 +237,7 @@ ssize_t fr_radius_ascend_secret(fr_dbuff_t *dbuff, uint8_t const *in, size_t inl
 	fr_md5_ctx_t		*md5_ctx;
 	size_t			i;
 	uint8_t			digest[MD5_DIGEST_LENGTH];
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	FR_DBUFF_EXTEND_LOWAT_OR_RETURN(&work_dbuff, sizeof(digest));
 
@@ -921,10 +921,10 @@ ssize_t fr_radius_encode_dbuff(fr_dbuff_t *dbuff, uint8_t const *original,
 	/*
 	 *	The RADIUS header can't do more than 64K of data.
 	 */
-	work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, 65535);
+	work_dbuff = FR_DBUFF_MAX(dbuff, 65535);
 
 	FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, code, id);
-	length_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
+	length_dbuff = FR_DBUFF(&work_dbuff);
 	FR_DBUFF_IN_RETURN(&work_dbuff, (uint16_t) RADIUS_HEADER_LENGTH);
 
 	switch (code) {
diff --git a/src/protocols/radius/encode.c b/src/protocols/radius/encode.c
index b81e5ec256a..d7b4291effa 100644
--- a/src/protocols/radius/encode.c
+++ b/src/protocols/radius/encode.c
@@ -139,7 +139,7 @@ static ssize_t encode_tunnel_password(fr_dbuff_t *dbuff, fr_dbuff_marker_t *in,
 	uint32_t	r;
 	size_t		len;
 	ssize_t		slen;
-	fr_dbuff_t	work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, RADIUS_MAX_STRING_LENGTH);
+	fr_dbuff_t	work_dbuff = FR_DBUFF_MAX(dbuff, RADIUS_MAX_STRING_LENGTH);
 
 	/*
 	 *	Limit the maximum size of the in password.  2 bytes
@@ -242,7 +242,7 @@ static ssize_t encode_tlv_children(fr_dbuff_t *dbuff,
 	ssize_t		slen;
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, RADIUS_MAX_STRING_LENGTH);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, RADIUS_MAX_STRING_LENGTH);
 
 	for (;;) {
 		FR_PROTO_STACK_PRINT(da_stack, depth);
@@ -350,7 +350,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
 	fr_radius_ctx_t		*packet_ctx = encode_ctx;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_t		value_dbuff;
 	fr_dbuff_marker_t	value_start, src, dest;
 	bool			encrypted = false;
@@ -430,7 +430,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 	/*
 	 * Starting here is a value that may require encryption.
 	 */
-	value_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
+	value_dbuff = FR_DBUFF(&work_dbuff);
 	fr_dbuff_marker(&value_start, &value_dbuff);
 	fr_dbuff_marker(&src, &value_dbuff);
 	fr_dbuff_marker(&dest, &value_dbuff);
@@ -654,7 +654,7 @@ static ssize_t attr_fragment(fr_dbuff_t *data, size_t data_len, fr_dbuff_marker_
 {
 	unsigned int		num_fragments, i = 0;
 	size_t			max_frag_data = UINT8_MAX - hdr_len;
-	fr_dbuff_t		frag_data = FR_DBUFF_NO_ADVANCE_ABS(hdr);
+	fr_dbuff_t		frag_data = FR_DBUFF_ABS(hdr);
 	fr_dbuff_marker_t	frag_hdr, frag_hdr_p;
 
 	if (unlikely(!data_len)) return 0;	/* Shouldn't have been called */
@@ -734,8 +734,8 @@ static ssize_t attr_fragment(fr_dbuff_t *data, size_t data_len, fr_dbuff_marker_
 		/*
 		 *	Shift remaining data by hdr_len.
 		 */
-		FR_DBUFF_IN_MEMCPY_RETURN(&FR_DBUFF_NO_ADVANCE(&frag_data), &frag_hdr, data_len - (i * max_frag_data));
-		fr_dbuff_in_memcpy(&FR_DBUFF_NO_ADVANCE(&frag_hdr), hdr, hdr_len);	/* Copy the old header over */
+		FR_DBUFF_IN_MEMCPY_RETURN(&FR_DBUFF(&frag_data), &frag_hdr, data_len - (i * max_frag_data));
+		fr_dbuff_in_memcpy(&FR_DBUFF(&frag_hdr), hdr, hdr_len);	/* Copy the old header over */
 	}
 
 	return fr_dbuff_set(data, &frag_data);
@@ -766,9 +766,9 @@ static ssize_t encode_extended(fr_dbuff_t *dbuff,
 	 *	"long" extended type.
 	 */
 	if (extra) {
-		work_dbuff = FR_DBUFF_COPY(dbuff);
+		work_dbuff = FR_DBUFF_BIND_CURRENT(dbuff);
 	} else {
-		work_dbuff = FR_DBUFF_MAX(dbuff, UINT8_MAX);
+		work_dbuff = FR_DBUFF_MAX_BIND_CURRENT(dbuff, UINT8_MAX);
 	}
 	fr_dbuff_marker(&hdr, &work_dbuff);
 
@@ -849,7 +849,7 @@ static ssize_t encode_concat(fr_dbuff_t *dbuff,
 	uint8_t const		*p;
 	size_t			data_len;
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr;
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
@@ -899,7 +899,7 @@ static ssize_t encode_attribute(fr_dbuff_t *dbuff,
 	ssize_t 		slen;
 	uint8_t			hlen;
 	fr_dbuff_marker_t	hdr;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, UINT8_MAX);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, UINT8_MAX);
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
 	fr_dbuff_marker(&hdr, &work_dbuff);
@@ -929,7 +929,7 @@ static ssize_t encode_vendor_attr(fr_dbuff_t *dbuff,
 	size_t			hdr_len;
 	fr_dbuff_marker_t	hdr, length_field, vsa_length_field;
 	fr_dict_attr_t const	*da, *dv;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, UINT8_MAX);
+	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX(dbuff, UINT8_MAX);
 
 	FR_PROTO_STACK_PRINT(da_stack, depth);
 
@@ -1029,7 +1029,7 @@ static ssize_t encode_wimax(fr_dbuff_t *dbuff,
 				fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr, length_field, vsa_length_field;
 	fr_dict_attr_t const	*dv;
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
@@ -1139,7 +1139,7 @@ static ssize_t encode_vendor(fr_dbuff_t *dbuff,
 	 */
 	vp = fr_dcursor_current(cursor);
 	fr_assert(vp->da == da);
-	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	work_dbuff = FR_DBUFF(dbuff);
 
 	fr_dcursor_init(&child_cursor, &vp->vp_group);
 	while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
@@ -1191,7 +1191,7 @@ static ssize_t encode_vsa(fr_dbuff_t *dbuff,
 		return encode_vendor(dbuff, da_stack, depth + 1, cursor, encode_ctx);
 	}
 
-	work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	work_dbuff = FR_DBUFF(dbuff);
 
 	vp = fr_dcursor_current(cursor);
 	if (vp->da != da_stack->da[depth]) {
@@ -1235,7 +1235,7 @@ static ssize_t encode_nas_filter_rule(fr_dbuff_t *dbuff,
 				      fr_da_stack_t *da_stack, NDEBUG_UNUSED unsigned int depth,
 				      fr_dcursor_t *cursor, UNUSED void *encode_ctx)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr, frag_hdr;
 	fr_pair_t		*vp = fr_dcursor_current(cursor);
 	size_t			attr_len = 2;
@@ -1342,7 +1342,7 @@ static ssize_t encode_rfc(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned i
 			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	start;
 
 	fr_dbuff_marker(&start, &work_dbuff);
@@ -1437,7 +1437,7 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 {
 	fr_pair_t const		*vp;
 	ssize_t			slen;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 
 	fr_da_stack_t		da_stack;
 	fr_dict_attr_t const	*da = NULL;
diff --git a/src/protocols/tacacs/encode.c b/src/protocols/tacacs/encode.c
index bf1a8428d23..6e8095c19ab 100644
--- a/src/protocols/tacacs/encode.c
+++ b/src/protocols/tacacs/encode.c
@@ -44,7 +44,7 @@ static uint8_t tacacs_encode_body_arg_n_len(fr_dbuff_t *dbuff, fr_pair_list_t *v
 {
 	uint8_t     arg_cnt = 0;
 	fr_pair_t   *vp;
-	fr_dbuff_t  work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t  work_dbuff = FR_DBUFF(dbuff);
 
 	for (vp = fr_pair_list_head(vps);
 	     vp;
@@ -68,7 +68,7 @@ static ssize_t tacacs_encode_body_arg_n(fr_dbuff_t *dbuff, fr_pair_list_t *vps,
 {
 	fr_pair_t   *vp;
 	uint8_t     arg_cnt = 0;
-	fr_dbuff_t  work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t  work_dbuff = FR_DBUFF(dbuff);
 
 	for (vp = fr_pair_list_head(vps);
 	     vp;
@@ -90,7 +90,7 @@ static ssize_t tacacs_encode_body_arg_n(fr_dbuff_t *dbuff, fr_pair_list_t *vps,
 static ssize_t tacacs_encode_field(fr_dbuff_t *dbuff, fr_pair_list_t *vps, fr_dict_attr_t const *da, size_t max_len)
 {
 	fr_pair_t  *vp;
-	fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t work_dbuff = FR_DBUFF(dbuff);
 
 	vp = fr_pair_find_by_da(vps, da, 0);
 	if (!vp || !vp->vp_length || (vp->vp_length > max_len)) return 0;
@@ -129,7 +129,7 @@ ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char
 	fr_da_stack_t 		da_stack;
 	ssize_t			len = 0;
 	size_t 			body_len, packet_len;
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_dbuff_marker_t	hdr, body, hdr_io;
 	uint8_t			version_byte = 0;
 
diff --git a/src/protocols/tftp/tftp.c b/src/protocols/tftp/tftp.c
index a0b6753043e..d0c65b8c8a7 100644
--- a/src/protocols/tftp/tftp.c
+++ b/src/protocols/tftp/tftp.c
@@ -273,7 +273,7 @@ done:
 
 ssize_t fr_tftp_encode(fr_dbuff_t *dbuff, fr_pair_list_t *vps)
 {
-	fr_dbuff_t 	work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, FR_TFTP_BLOCK_MAX_SIZE);
+	fr_dbuff_t 	work_dbuff = FR_DBUFF_MAX(dbuff, FR_TFTP_BLOCK_MAX_SIZE);
 	fr_pair_t 	*vp;
 	uint16_t 	opcode;
 	char const 	*buf;
diff --git a/src/protocols/vmps/vmps.c b/src/protocols/vmps/vmps.c
index 0fdb88c3fb7..e5e30276f92 100644
--- a/src/protocols/vmps/vmps.c
+++ b/src/protocols/vmps/vmps.c
@@ -266,7 +266,7 @@ static int contents[5][VQP_MAX_ATTRIBUTES] = {
 ssize_t fr_vmps_encode(fr_dbuff_t *dbuff, uint8_t const *original,
 		       int code, uint32_t seq_no, fr_dcursor_t *cursor)
 {
-	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
+	fr_dbuff_t		work_dbuff = FR_DBUFF(dbuff);
 	fr_pair_t 		*vp;
 	fr_dbuff_marker_t	hdr, io;
 	uint8_t			data_count = 0;