Remove dbuff_marker macros

diff --git a/src/lib/util/dbuff.c b/src/lib/util/dbuff.c
index fb138df3bc5db42f58eb13c9c074f1451a729ba9..585a101ba66a524e2231db3e73cd717910810ce7 100644 (file)
--- a/src/lib/util/dbuff.c
+++ b/src/lib/util/dbuff.c
@@ -85,7 +85,7 @@ size_t _fr_dbuff_move_dbuff_to_dbuff(fr_dbuff_t *out, fr_dbuff_t *in, size_t len
  * @note Do not call this function directly; use #fr_dbuff_move
  *
  * Both in and out will be advanced by
- * min {len, fr_dbuff_remaining(out), fr_dbuff_marker_remaining(in)}; eventually,
+ * min {len, fr_dbuff_remaining(out), fr_dbuff_remaining(in)}; eventually,
  * we'll attempt to extend dbuffs where possible and needed to make len bytes
  * available in both in and out.
  *
@@ -97,13 +97,13 @@ size_t _fr_dbuff_move_dbuff_to_dbuff(fr_dbuff_t *out, fr_dbuff_t *in, size_t len
 size_t _fr_dbuff_move_marker_to_dbuff(fr_dbuff_t *out, fr_dbuff_marker_t *in, size_t len)
 {
        size_t o_remaining = fr_dbuff_remaining(out);
-       size_t i_remaining = fr_dbuff_marker_remaining(in);
+       size_t i_remaining = fr_dbuff_remaining(in);
        size_t to_copy = len;
        if (to_copy > o_remaining) to_copy = o_remaining;
        if (to_copy > i_remaining) to_copy = i_remaining;
-       safecpy(out->p, out->end, fr_dbuff_marker_current(in),
-               fr_dbuff_marker_current(in) + to_copy);
-       return fr_dbuff_advance(out, fr_dbuff_marker_advance(in, to_copy));
+       safecpy(out->p, out->end, fr_dbuff_current(in),
+               fr_dbuff_current(in) + to_copy);
+       return fr_dbuff_advance(out, fr_dbuff_advance(in, to_copy));
 }
 
 /** Move data from one marker to another
@@ -111,7 +111,7 @@ size_t _fr_dbuff_move_marker_to_dbuff(fr_dbuff_t *out, fr_dbuff_marker_t *in, si
  * @note Do not call this function directly; use #fr_dbuff_move
  *
  * Both in and out will be advanced by
- * min {len, fr_dbuff_marker_remaining(out), fr_dbuff_marker_remaining(in)}; eventually,
+ * min {len, fr_dbuff_remaining(out), fr_dbuff_remaining(in)}; eventually,
  * we'll attempt to extend dbuffs where possible and needed to make len bytes
  * available in both in and out.
  *
@@ -122,14 +122,14 @@ size_t _fr_dbuff_move_marker_to_dbuff(fr_dbuff_t *out, fr_dbuff_marker_t *in, si
  */
 size_t _fr_dbuff_move_marker_to_marker(fr_dbuff_marker_t *out, fr_dbuff_marker_t *in, size_t len)
 {
-       size_t o_remaining = fr_dbuff_marker_remaining(out);
-       size_t i_remaining = fr_dbuff_marker_remaining(in);
+       size_t o_remaining = fr_dbuff_remaining(out);
+       size_t i_remaining = fr_dbuff_remaining(in);
        size_t to_copy = len;
        if (to_copy > o_remaining) to_copy = o_remaining;
        if (to_copy > i_remaining) to_copy = i_remaining;
-       safecpy(out->p, out->parent->end, fr_dbuff_marker_current(in),
-               fr_dbuff_marker_current(in) + to_copy);
-       return fr_dbuff_marker_advance(out, fr_dbuff_marker_advance(in, to_copy));
+       safecpy(out->p, out->parent->end, fr_dbuff_current(in),
+               fr_dbuff_current(in) + to_copy);
+       return fr_dbuff_advance(out, fr_dbuff_advance(in, to_copy));
 }
 
 /** Move data from a dbuff to a marker
@@ -137,7 +137,7 @@ size_t _fr_dbuff_move_marker_to_marker(fr_dbuff_marker_t *out, fr_dbuff_marker_t
  * @note Do not call this function directly; use #fr_dbuff_move
  *
  * Both in and out will be advanced by
- * min {len, fr_dbuff_marker_remaining(out), fr_dbuff_marker_remaining(in)}; eventually,
+ * min {len, fr_dbuff_remaining(out), fr_dbuff_remaining(in)}; eventually,
  * we'll attempt to extend dbuffs where possible and needed to make len bytes
  * available in both in and out.
  *
@@ -148,14 +148,14 @@ size_t _fr_dbuff_move_marker_to_marker(fr_dbuff_marker_t *out, fr_dbuff_marker_t
  */
 size_t _fr_dbuff_move_dbuff_to_marker(fr_dbuff_marker_t *out, fr_dbuff_t *in, size_t len)
 {
-       size_t o_remaining = fr_dbuff_marker_remaining(out);
+       size_t o_remaining = fr_dbuff_remaining(out);
        size_t i_remaining = fr_dbuff_remaining(in);
        size_t to_copy = len;
        if (to_copy > o_remaining) to_copy = o_remaining;
        if (to_copy > i_remaining) to_copy = i_remaining;
        safecpy(out->p, out->parent->end, fr_dbuff_current(in),
                fr_dbuff_current(in) + to_copy);
-       return fr_dbuff_marker_advance(out, fr_dbuff_advance(in, to_copy));
+       return fr_dbuff_advance(out, fr_dbuff_advance(in, to_copy));
 }
 
 static inline size_t   min(size_t x, size_t y)

diff --git a/src/lib/util/dbuff.h b/src/lib/util/dbuff.h
index 97b17f936b332b6f84aac633d34677febb105f81..d2990b4dc0eb31488cd308710477488921c7a3e0 100644 (file)
--- a/src/lib/util/dbuff.h
+++ b/src/lib/util/dbuff.h
@@ -700,13 +700,6 @@ static inline void fr_dbuff_marker_release(fr_dbuff_marker_t *m)
 #endif
 }
 
-/*
- * Preserve current set interface for markers pro tempore;
- * note that fr_dbuff_set() uses _fr_dbuff_marker_set(), so the
- * former fr_dbuff_marker_set() function remains under the new name.
- */
-#define fr_dbuff_marker_set(_marker, _p) fr_dbuff_set(_marker, _p)
-
 /** Change the position in the buffer a marker points to
  *
  * @param[in] m                marker to alter.
@@ -728,36 +721,6 @@ static inline ssize_t _fr_dbuff_marker_set(fr_dbuff_marker_t *m, uint8_t const *
 
        return p - current;
 }
-
-/*
- * Change the position in the buffer a marker points to
- */
-#define fr_dbuff_marker_advance(_marker, _n) fr_dbuff_advance(_marker, _n)
-
-/*
- * Reset the position in a dbuff to specified marker
- */
-#define fr_dbuff_set_to_marker(_marker) fr_dbuff_set(_marker->parent, _marker)
-
-/*
- * Return the current position of a marker.
- */
-#define fr_dbuff_marker_current(_marker) fr_dbuff_current(_marker)
-
-/*
- * How many free bytes remain in the buffer (calculated from marker).
- */
-#define fr_dbuff_marker_remaining(_marker) fr_dbuff_remaining(_marker)
-
-/*
- * How many bytes we've used in the buffer (calculated from marker)
- */
-#define fr_dbuff_marker_used(_marker) fr_dbuff_used(_marker)
-
-/* what is the end of the buffer (determined from marker)
- *
- */
-#define fr_dbuff_marker_end(_marker) fr_dbuff_end(_marker)
 /** @} */
 
 /** @name copy data to dbuff

diff --git a/src/lib/util/dbuff_tests.c b/src/lib/util/dbuff_tests.c
index 55887a057199763deeb1c8b0360050844c5440ef..69080a7ecef8a6d24d88f8fb48c37be7f727038f 100644 (file)
--- a/src/lib/util/dbuff_tests.c
+++ b/src/lib/util/dbuff_tests.c
@@ -261,22 +261,22 @@ static void test_dbuff_move(void)
        TEST_CHECK(memcmp(dbuff1.start, "ABCDEFGHIJKLMnopqrstuvwxyz", 26) == 0);
 
        TEST_CASE("move dbuff to marker");
-       fr_dbuff_marker_advance(&marker2, 4);
+       fr_dbuff_advance(&marker2, 4);
        TEST_CHECK(fr_dbuff_move(&marker2, &dbuff3, 10) == 10);
-       TEST_CHECK(fr_dbuff_marker_used(&marker2) == 14);
+       TEST_CHECK(fr_dbuff_used(&marker2) == 14);
        TEST_CHECK(memcmp(dbuff2.start, "ABCD0123456789OPQRSTUVWXYZ", 26) == 0);
 
        TEST_CASE("move marker to dbuff");
-       fr_dbuff_marker_advance(&marker1, 7);
+       fr_dbuff_advance(&marker1, 7);
        TEST_CHECK(fr_dbuff_move(&dbuff1, &marker1, 6) == 6);
        TEST_CHECK(fr_dbuff_used(&dbuff1) == 19);
-       TEST_CHECK(fr_dbuff_marker_used(&marker1) == 13);
+       TEST_CHECK(fr_dbuff_used(&marker1) == 13);
        TEST_CHECK(memcmp(dbuff1.start, "ABCDEFGHIJKLMHIJKLMtuvwxyz", 26) == 0);
 
        TEST_CASE("move marker to marker");
        TEST_CHECK(fr_dbuff_move(&marker2, &marker1, 8) == 8);
-       TEST_CHECK(fr_dbuff_marker_used(&marker1) == 21);
-       TEST_CHECK(fr_dbuff_marker_used(&marker2) == 22);
+       TEST_CHECK(fr_dbuff_used(&marker1) == 21);
+       TEST_CHECK(fr_dbuff_used(&marker2) == 22);
        TEST_CHECK(memcmp(dbuff2.start, "ABCD0123456789HIJKLMtuWXYZ", 26) == 0);
 }
 
@@ -301,7 +301,7 @@ static void test_dbuff_talloc_extend(void)
        TEST_CASE("Markers track extended buffer");
        TEST_CHECK(marker.p == dbuff.start);
        TEST_CASE("Already-written content stays with the buffer");
-       TEST_CHECK(memcmp(fr_dbuff_marker_current(&marker), value, sizeof(value)) == 0);
+       TEST_CHECK(memcmp(fr_dbuff_current(&marker), value, sizeof(value)) == 0);
        TEST_CASE("Refuse to extend past specified maximum");
        TEST_CHECK(fr_dbuff_in(&dbuff, (uint64_t) 0x123456789abcdef0) == -2);
 }

diff --git a/src/protocols/dhcpv6/encode.c b/src/protocols/dhcpv6/encode.c
index d0d981a6ab6d6ba2a8dd19f0b0bed3730470a17b..048ff63d20e46312a94d3b2d94cd953d77005af3 100644 (file)
--- a/src/protocols/dhcpv6/encode.c
+++ b/src/protocols/dhcpv6/encode.c
@@ -200,7 +200,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
                         *      zero.
                         */
                        if ((da->flags.subtype == FLAG_ENCODE_PARTIAL_DNS_LABEL) &&
-                           (*(fr_dbuff_marker_current(&p) + fr_dbuff_marker_current(&p)[0] + 1) == 0)) {
+                           (*(fr_dbuff_current(&p) + fr_dbuff_current(&p)[0] + 1) == 0)) {
                                fr_dbuff_set_to_start(&work_dbuff);
                                fr_dbuff_advance(&work_dbuff, slen - 1);
                        }

diff --git a/src/protocols/radius/base.c b/src/protocols/radius/base.c
index 085f68dfcb465d0a470543405cf31a82277e4571..8c53c08fa2232458bfc40a23cc69793344824111 100644 (file)
--- a/src/protocols/radius/base.c
+++ b/src/protocols/radius/base.c
@@ -261,7 +261,7 @@ ssize_t fr_radius_ascend_secret_dbuff(fr_dbuff_t *dbuff, uint8_t const *in, size
        fr_md5_final(digest, md5_ctx);
        fr_md5_ctx_free(&md5_ctx);
 
-       for (i = 0; i < RADIUS_AUTH_VECTOR_LENGTH; i++) fr_dbuff_marker_current(&start)[i] ^= digest[i];
+       for (i = 0; i < RADIUS_AUTH_VECTOR_LENGTH; i++) fr_dbuff_current(&start)[i] ^= digest[i];
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }

diff --git a/src/protocols/radius/encode.c b/src/protocols/radius/encode.c
index 0b5bc3f56421d8f3a4aa1ef8c1ee1026162a80c7..fedbccbeb3be697606f084e41ed54eec453ac58e 100644 (file)
--- a/src/protocols/radius/encode.c
+++ b/src/protocols/radius/encode.c
@@ -314,7 +314,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
        slen = encode_tlv_hdr_internal(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encoder_ctx);
        if (slen <= 0) return slen;
 
-       fr_dbuff_marker_current(&hdr)[1] += slen;
+       fr_dbuff_current(&hdr)[1] += slen;
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }
@@ -564,7 +564,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
                /*
                 *      Encode the password in place
                 */
-               slen = encode_password(&work_dbuff, fr_dbuff_marker_current(&value_start), fr_dbuff_used(&value_dbuff),
+               slen = encode_password(&work_dbuff, fr_dbuff_current(&value_start), fr_dbuff_used(&value_dbuff),
                                       packet_ctx->secret, packet_ctx->vector);
                if (slen < 0) return slen;
                encrypted = true;
@@ -583,7 +583,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
                 */
                if (flag_has_tag(&vp->da->flags)) fr_dbuff_advance(&work_dbuff, 1);
 
-               slen = encode_tunnel_password(&work_dbuff, fr_dbuff_marker_current(&value_start),
+               slen = encode_tunnel_password(&work_dbuff, fr_dbuff_current(&value_start),
                                              fr_dbuff_used(&value_dbuff), packet_ctx);
                if (slen < 0) {
                        fr_strerror_printf("%s too long", vp->da->name);
@@ -594,7 +594,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
                 *      Do this after so we don't mess up the input
                 *      value.
                 */
-               if (flag_has_tag(&vp->da->flags)) fr_dbuff_marker_current(&value_start)[0] = 0x00;
+               if (flag_has_tag(&vp->da->flags)) fr_dbuff_current(&value_start)[0] = 0x00;
                encrypted = true;
                break;
 
@@ -603,7 +603,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         *      always fits.
         */
        case FLAG_ENCRYPT_ASCEND_SECRET:
-               slen = fr_radius_ascend_secret_dbuff(&work_dbuff, fr_dbuff_marker_current(&value_start),
+               slen = fr_radius_ascend_secret_dbuff(&work_dbuff, fr_dbuff_current(&value_start),
                                                     fr_dbuff_used(&value_dbuff),
                                               packet_ctx->secret, packet_ctx->vector);
                if (slen < 0) return slen;
@@ -626,11 +626,11 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
                /*
                 *      Only 24bit integers are allowed here
                 */
-               if (fr_dbuff_marker_current(&value_start)[0] != 0) {
+               if (fr_dbuff_current(&value_start)[0] != 0) {
                        fr_strerror_printf("Integer overflow for tagged uint32 attribute");
                        return PAIR_ENCODE_SKIPPED;
                }
-               fr_dbuff_marker_current(&value_start)[0] = packet_ctx->tag;
+               fr_dbuff_current(&value_start)[0] = packet_ctx->tag;
        }
 
        FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), fr_dbuff_used(&work_dbuff), "value %s",
@@ -672,7 +672,7 @@ static ssize_t attr_shift(fr_dbuff_t *dbuff,
                          fr_dbuff_marker_t *ptr, int hdr_len, ssize_t len,
                          int flag_offset, int vsa_offset)
 {
-       int                     check_len = len - fr_dbuff_marker_current(ptr)[1];
+       int                     check_len = len - fr_dbuff_current(ptr)[1];
        int                     total = hdr_len;
        fr_dbuff_t              work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
        fr_dbuff_marker_t       hdr, next_hdr, next_data;
@@ -696,7 +696,7 @@ static ssize_t attr_shift(fr_dbuff_t *dbuff,
         *      lengths.
         */
        if (fr_dbuff_advance(&work_dbuff, total) < 0) {
-               return (fr_dbuff_marker_current(ptr) + fr_dbuff_marker_current(ptr)[1]) - fr_dbuff_start(&work_dbuff);
+               return (fr_dbuff_current(ptr) + fr_dbuff_current(ptr)[1]) - fr_dbuff_start(&work_dbuff);
        }
 
        /*
@@ -704,7 +704,7 @@ static ssize_t attr_shift(fr_dbuff_t *dbuff,
         *      accumulated there.
         */
        fr_dbuff_marker(&hdr, dbuff);
-       fr_dbuff_marker_set(&hdr, fr_dbuff_marker_current(ptr));
+       fr_dbuff_set(&hdr, fr_dbuff_current(ptr));
        fr_dbuff_marker(&next_hdr, dbuff);
        fr_dbuff_marker(&next_data, dbuff);
 
@@ -715,32 +715,32 @@ static ssize_t attr_shift(fr_dbuff_t *dbuff,
         */
        for (;;) {
                /* Extend current attribute as much as possible. */
-               int sublen = 255 - fr_dbuff_marker_current(&hdr)[1];
+               int sublen = 255 - fr_dbuff_current(&hdr)[1];
                if (len < sublen) sublen = len;
-               fr_dbuff_marker_current(&hdr)[1] += sublen;
+               fr_dbuff_current(&hdr)[1] += sublen;
 
                /* Adjust the other length field if it exists. */
-               if (vsa_offset) fr_dbuff_marker_current(&hdr)[vsa_offset] += sublen;
+               if (vsa_offset) fr_dbuff_current(&hdr)[vsa_offset] += sublen;
 
                /* If all data are accounted for, we're done. */
                len -= sublen;
                if (len == 0) break;
 
                /* This attribute isn't the last, so flag it. */
-               fr_dbuff_marker_current(&hdr)[flag_offset] |= 0x80;
+               fr_dbuff_current(&hdr)[flag_offset] |= 0x80;
 
                /* Make room for another header. */
-               fr_dbuff_marker_set(&next_hdr, fr_dbuff_marker_current(&hdr) + 255);
-               fr_dbuff_marker_set(&next_data, fr_dbuff_marker_current(&next_hdr) + hdr_len);
+               fr_dbuff_set(&next_hdr, fr_dbuff_current(&hdr) + 255);
+               fr_dbuff_set(&next_data, fr_dbuff_current(&next_hdr) + hdr_len);
                fr_dbuff_move(&next_data, &next_hdr, len);
 
                /* Copy current header into new header and advance to it... */
-               fr_dbuff_marker_set(&next_hdr, fr_dbuff_marker_current(&hdr) + 255);
+               fr_dbuff_set(&next_hdr, fr_dbuff_current(&hdr) + 255);
                fr_dbuff_move(&next_hdr, &hdr, hdr_len);
-               fr_dbuff_marker_advance(&hdr, 255 - hdr_len);
+               fr_dbuff_advance(&hdr, 255 - hdr_len);
 
                /* ...and set its length to that of the header. */
-               fr_dbuff_marker_current(&hdr)[1] = hdr_len;
+               fr_dbuff_current(&hdr)[1] = hdr_len;
        }
 
        /* Clear our markers from dbuff's list */
@@ -807,13 +807,13 @@ static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
                FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) da_stack->da[depth++]->attr);
                FR_DBUFF_BYTES_IN_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr);
 
-               fr_dbuff_marker_current(&hdr)[1] += 5;
+               fr_dbuff_current(&hdr)[1] += 5;
 
                FR_PROTO_STACK_PRINT(da_stack, depth);
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), fr_dbuff_marker_current(&hdr)[1],
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), fr_dbuff_current(&hdr)[1],
                                  "header extended vendor specific");
        } else {
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), fr_dbuff_marker_current(&hdr)[1], "header extended");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), fr_dbuff_current(&hdr)[1], "header extended");
        }
 
        /*
@@ -835,19 +835,19 @@ static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
         *      and copy the existing header over.  Set the "M" flag ONLY
         *      after copying the rest of the data.
         */
-       if (slen > (255 - fr_dbuff_marker_current(&hdr)[1])) {
+       if (slen > (255 - fr_dbuff_current(&hdr)[1])) {
                slen = attr_shift(&work_dbuff, &hdr, 4, slen, 3, 0);
                fr_dbuff_set(dbuff, &work_dbuff);
                return slen;
        }
 
-       fr_dbuff_marker_current(&hdr)[1] += slen;
+       fr_dbuff_current(&hdr)[1] += slen;
 
 #ifndef NDEBUG
        if (fr_debug_lvl > 3) {
                if (vsa_type == FR_TYPE_VENDOR) jump += 5;
 
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), jump, "header extended");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), jump, "header extended");
        }
 #endif
 
@@ -890,10 +890,10 @@ static ssize_t encode_concat(fr_dbuff_t *dbuff,
 
                FR_DBUFF_MEMCPY_IN_RETURN(&work_dbuff, p, left);
 
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr) + 2, left, "concat value octets");
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), 2, "concat header rfc");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr) + 2, left, "concat value octets");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), 2, "concat header rfc");
 
-               fr_dbuff_marker_current(&hdr)[1] += left;
+               fr_dbuff_current(&hdr)[1] += left;
                p += left;
                slen -= left;
        }
@@ -948,9 +948,9 @@ static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
        slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encoder_ctx);
        if (slen <= 0) return slen;
 
-       fr_dbuff_marker_current(&hdr)[1] += slen;
+       fr_dbuff_current(&hdr)[1] += slen;
 
-       FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), 2, "header rfc");
+       FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), 2, "header rfc");
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }
@@ -1039,9 +1039,9 @@ static ssize_t encode_vendor_attr_hdr(fr_dbuff_t *dbuff,
        }
        if (slen <= 0) return slen;
 
-       if (dv->flags.length) fr_dbuff_marker_current(&hdr)[hdr_len - 1] += slen;
+       if (dv->flags.length) fr_dbuff_current(&hdr)[hdr_len - 1] += slen;
 
-       FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), hdr_len, "header vsa");
+       FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), hdr_len, "header vsa");
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }
@@ -1106,16 +1106,16 @@ static ssize_t encode_wimax_hdr(fr_dbuff_t *dbuff,
         *      and copy the existing header over.  Set the "C" flag
         *      ONLY after copying the rest of the data.
         */
-       if (slen > (255 - fr_dbuff_marker_current(&hdr)[1])) {
-               slen = attr_shift(&work_dbuff, &hdr, fr_dbuff_marker_current(&hdr)[1], slen, 8, 7);
+       if (slen > (255 - fr_dbuff_current(&hdr)[1])) {
+               slen = attr_shift(&work_dbuff, &hdr, fr_dbuff_current(&hdr)[1], slen, 8, 7);
                fr_dbuff_set(dbuff, &work_dbuff);
                return slen;
        }
 
-       fr_dbuff_marker_current(&hdr)[1] += slen;
-       fr_dbuff_marker_current(&hdr)[7] += slen;
+       fr_dbuff_current(&hdr)[1] += slen;
+       fr_dbuff_current(&hdr)[7] += slen;
 
-       FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), 9, "header wimax");
+       FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), 9, "header wimax");
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }
@@ -1171,9 +1171,9 @@ static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
        len = encode_vendor_attr_hdr(&FR_DBUFF_MAX(&work_dbuff, 255 - 6), da_stack, depth, cursor, encoder_ctx);
        if (len < 0) return len;
 
-       fr_dbuff_marker_current(&hdr)[1] = fr_dbuff_used(&work_dbuff);
+       fr_dbuff_current(&hdr)[1] = fr_dbuff_used(&work_dbuff);
 
-       FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&hdr), 6, "header vsa");
+       FR_PROTO_HEX_DUMP(fr_dbuff_current(&hdr), 6, "header vsa");
 
        return fr_dbuff_set(dbuff, &work_dbuff);
 }
@@ -1225,7 +1225,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
        if ((vp->da == attr_chargeable_user_identity) && (vp->vp_length == 0)) {
                fr_dbuff_bytes_in(&work_dbuff, (uint8_t)vp->da->attr, 0x02);
 
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&start), 2, "header rfc");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&start), 2, "header rfc");
 
                vp = fr_cursor_next(cursor);
                fr_proto_da_stack_build(da_stack, vp ? vp->da : NULL);
@@ -1239,9 +1239,9 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
                FR_DBUFF_BYTES_IN_RETURN(&work_dbuff, (uint8_t)vp->da->attr, 18);
                FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, 16);
 
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&start) + 2, RADIUS_MESSAGE_AUTHENTICATOR_LENGTH,
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&start) + 2, RADIUS_MESSAGE_AUTHENTICATOR_LENGTH,
                                  "message-authenticator");
-               FR_PROTO_HEX_DUMP(fr_dbuff_marker_current(&start), 2, "header rfc");
+               FR_PROTO_HEX_DUMP(fr_dbuff_current(&start), 2, "header rfc");
 
                vp = fr_cursor_next(cursor);
                fr_proto_da_stack_build(da_stack, vp ? vp->da : NULL);

diff --git a/src/protocols/tacacs/encode.c b/src/protocols/tacacs/encode.c
index a140a69942f96f51c79d4d953c54b2fe1a09b44e..5e847f3b1d52e29e0a1bec24adeb9d71121d6c49 100644 (file)
--- a/src/protocols/tacacs/encode.c
+++ b/src/protocols/tacacs/encode.c
@@ -564,7 +564,7 @@ ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char
                        /*
                         *      Just to avoid malformed packet.
                         */
-                       if (!fr_dbuff_marker_current(&hdr)[0]) fr_dbuff_marker_current(&hdr)[0] = 0xc1; /* version 12.1 */
+                       if (!fr_dbuff_current(&hdr)[0]) fr_dbuff_current(&hdr)[0] = 0xc1; /* version 12.1 */
 
                        /*
                         *      If the caller didn't set a session ID, use a random one.
@@ -619,7 +619,7 @@ ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char
                         *      they have the correct values.
                         */
                        if (original) {
-                               if (!fr_dbuff_marker_current(&hdr)[0]) {
+                               if (!fr_dbuff_current(&hdr)[0]) {
                                        packet->hdr.version = original->version;
                                }
 
@@ -652,7 +652,7 @@ ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char
         *      include the size of the header.  But we tell the
         *      caller about the total length of the packet.
         */
-       packet_len = fr_dbuff_marker_used(&work_dbuff);
+       packet_len = fr_dbuff_used(&work_dbuff);
        body_len = (packet_len - sizeof(fr_tacacs_packet_hdr_t));
        fr_assert(packet_len < FR_TACACS_MAX_PACKET_SIZE);
        packet->hdr.length = htonl(body_len);
@@ -686,7 +686,7 @@ ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char
 
                FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), packet_len, "fr_tacacs_packet_t (unencrypted)");
 
-               if (fr_tacacs_body_xor(packet, fr_dbuff_marker_current(&body), body_len, secret, secret_len) != 0) return -1;
+               if (fr_tacacs_body_xor(packet, fr_dbuff_current(&body), body_len, secret, secret_len) != 0) return -1;
        }
 
        FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), packet_len, "fr_tacacs_packet_t (encoded)");

diff --git a/src/protocols/vmps/vmps.c b/src/protocols/vmps/vmps.c
index 6bf9f0cd7c7637626ae7a0bdebbae3639f321cb0..44450272554d81a48beb965f7c801933e0d6a488 100644 (file)
--- a/src/protocols/vmps/vmps.c
+++ b/src/protocols/vmps/vmps.c
@@ -297,20 +297,20 @@ ssize_t fr_vmps_encode(fr_dbuff_t *dbuff, uint8_t const *original,
                size_t len;
 
                if (vp->da == attr_packet_type) {
-                       fr_dbuff_marker_current(&hdr)[1] = (uint8_t)vp->vp_uint32;
+                       fr_dbuff_current(&hdr)[1] = (uint8_t)vp->vp_uint32;
                        fr_cursor_next(cursor);
                        continue;
                }
 
                if (vp->da == attr_error_code) {
-                       fr_dbuff_marker_current(&hdr)[2] = vp->vp_uint8;
+                       fr_dbuff_current(&hdr)[2] = vp->vp_uint8;
                        fr_cursor_next(cursor);
                        continue;
                }
 
                if (!original && (vp->da == attr_sequence_number)) {
                        sequence = htonl(vp->vp_uint32);
-                       memcpy(&fr_dbuff_marker_current(&hdr)[4], &sequence, sizeof(sequence));
+                       memcpy(&fr_dbuff_current(&hdr)[4], &sequence, sizeof(sequence));
                        fr_cursor_next(cursor);
                        continue;
                }
@@ -365,7 +365,7 @@ ssize_t fr_vmps_encode(fr_dbuff_t *dbuff, uint8_t const *original,
                default:
                        return -1;
                }
-               fr_dbuff_marker_current(&hdr)[3]++;     /* Update the Data Count */
+               fr_dbuff_current(&hdr)[3]++;    /* Update the Data Count */
 
                fr_cursor_next(cursor);
        }