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 360ae8a55bf102e158a39977d7cea12165732c39..58f1951a9c0975ef259c69626540c0a14c3457e1 100644 (file)
--- 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 3ac1c42295a5d3008d09fc5f9df3c1c08568df55..3247cfff0339115e6e0cf67e5f3428179622c202 100644 (file)
--- 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 3628e7da0574b3d261b6bad3fb29c1ece2f9aaa5..db12794dd0a5a6fb96838118e29e5bed20971b3d 100644 (file)
--- 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 d095421ea0edb6ed64a209e5b70a6180a5ce9a5d..87f69fbf5bcc204e3dde3cf3900b8656aa1ea667 100644 (file)
--- 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 b9c112ab8a17d3093d243cbe3dc304147b943f96..30c5bc43774aae830728fcaa4802512b7956049a 100644 (file)
--- 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 4d27d27693b634eeffc316665fa3578a61ad8d58..782cf94e6a0b9ef34d7b72031ecd39727aea3b2d 100644 (file)
--- 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 8ced1bee86b42144bad2c158ed408be9fc5489fb..ebdf70e28492014090c93a7f95a4133104caef16 100644 (file)
--- 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 1d17bee355d8d9c11daa44110f14983218238483..f7a3b9cd77eddcd7a50903deb627d7460d214374 100644 (file)
--- 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 f0dd169c9821f4be93dca431ee4cdc7f5d0d5014..f3921612e90db1bde4048768b931fc7061f5ffe3 100644 (file)
--- 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 86b5d5441aee3b59716dac0d28e286ec8012fc92..ac9211958829acb17f7a214cf315c3c543ae24e7 100644 (file)
--- 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 4005d69658205364cd2c59155dcd6bd8bb8763f4..3375724b32005ef44081906215f6272c2c300a54 100644 (file)
--- 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 cb14f6bfb2a3399b66707d55256c70a2e925aabf..5ef8cedd9ce61f56ef6fc8747faef853a2d6655c 100644 (file)
--- 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 c2b5cba10408c39ec3763317ca3b7d30b0c2d257..2ee1d6a28f59fbb95ce6b982ace75ff232d68938 100644 (file)
--- 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 dcf0ba66ae427a8cb0722caa3af9250bc6f09f76..48fbec22e45b225799f4d95a3618b77cbfacaf4c 100644 (file)
--- 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 9ff23ff10e330ede4924c3aed7e7c58a85f8ec1c..1ac2cda8da4d03ce536b4d51f3120d28a7f377c9 100644 (file)
--- 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 d198c3a25ef205f22248aa44edd229b4d871faad..49ec0e1a1c24bda67f89e34eaf894f5a70b11052 100644 (file)
--- 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 99b4a4d1bb397c664f0eb22e57e5854413ded800..4464385472194dce3b9ea0deeea9de27e0689dcd 100644 (file)
--- 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 b81e5ec256ad815a193256974b36771b8867c3cb..d7b4291effa64012cc1f43d64d8785d8d98f265c 100644 (file)
--- 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 bf1a8428d234c01f51af48caa3c635f8d6aec77d..6e8095c19ab4a84cee5cadc44a9879fe07826953 100644 (file)
--- 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 a0b6753043e096fe8509f993412e02841117be63..d0c65b8c8a7cc92b5724dc80f6101b054d87ab4d 100644 (file)
--- 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 0fdb88c3fb746b5686bd709f593ed27fe38ca378..e5e30276f929c0034e3150e7b5b86d41789b0a12 100644 (file)
--- 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;