From: Arran Cudbard-Bell Date: Fri, 6 Nov 2020 20:51:03 +0000 (-0600) Subject: Remove dbuff_marker macros X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=248c84cdc8d43ac6aad8a41c21279863ca44fe2b;p=thirdparty%2Ffreeradius-server.git Remove dbuff_marker macros --- diff --git a/src/lib/util/dbuff.c b/src/lib/util/dbuff.c index fb138df3bc5..585a101ba66 100644 --- 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 97b17f936b3..d2990b4dc0e 100644 --- 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 55887a05719..69080a7ecef 100644 --- 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 d0d981a6ab6..048ff63d20e 100644 --- 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 085f68dfcb4..8c53c08fa22 100644 --- 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 0b5bc3f5642..fedbccbeb3b 100644 --- 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 a140a69942f..5e847f3b1d5 100644 --- 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 6bf9f0cd7c7..44450272554 100644 --- 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); }