From: Arran Cudbard-Bell <a.cudbardb@freeradius.org>
Date: Mon, 29 Mar 2021 14:46:34 +0000 (+0100)
Subject: standardise encode_ctx vs encoder_ctx and decode_ctx vs decoder_ctx
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=e8b6b20fbced44df798fcad049a32f36a8fe6e97;p=thirdparty%2Ffreeradius-server.git

standardise encode_ctx vs encoder_ctx and decode_ctx vs decoder_ctx
---

diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c
index 7db6ec5955a..9b63ca1f8d9 100644
--- a/src/bin/unit_test_attribute.c
+++ b/src/bin/unit_test_attribute.c
@@ -1252,7 +1252,7 @@ static size_t command_decode_pair(command_result_t *result, command_file_ctx_t *
 {
 	fr_test_point_pair_decode_t	*tp = NULL;
 	fr_dcursor_t 	cursor;
-	void		*decoder_ctx = NULL;
+	void		*decode_ctx = NULL;
 	char		*p, *end;
 	uint8_t		*to_dec;
 	uint8_t		*to_dec_end;
@@ -1272,7 +1272,7 @@ static size_t command_decode_pair(command_result_t *result, command_file_ctx_t *
 	p += slen;
 	fr_skip_whitespace(p);
 
-	if (tp->test_ctx && (tp->test_ctx(&decoder_ctx, cc->tmp_ctx) < 0)) {
+	if (tp->test_ctx && (tp->test_ctx(&decode_ctx, cc->tmp_ctx) < 0)) {
 		fr_strerror_const_push("Failed initialising decoder testpoint");
 		RETURN_COMMAND_ERROR();
 	}
@@ -1307,7 +1307,7 @@ static size_t command_decode_pair(command_result_t *result, command_file_ctx_t *
 	fr_dcursor_init(&cursor, &head);
 	while (to_dec < to_dec_end) {
 		slen = tp->func(cc->tmp_ctx, &cursor, cc->tmpl_rules.dict_def ? cc->tmpl_rules.dict_def : cc->config->dict,
-				(uint8_t *)to_dec, (to_dec_end - to_dec), decoder_ctx);
+				(uint8_t *)to_dec, (to_dec_end - to_dec), decode_ctx);
 		cc->last_ret = slen;
 		if (slen <= 0) {
 			fr_pair_list_free(&head);
@@ -1372,7 +1372,7 @@ static size_t command_decode_proto(command_result_t *result, command_file_ctx_t
 				  char *data, size_t data_used, char *in, size_t inlen)
 {
 	fr_test_point_proto_decode_t	*tp = NULL;
-	void		*decoder_ctx = NULL;
+	void		*decode_ctx = NULL;
 	char		*p;
 	uint8_t		*to_dec;
 	uint8_t		*to_dec_end;
@@ -1393,7 +1393,7 @@ static size_t command_decode_proto(command_result_t *result, command_file_ctx_t
 	p += slen;
 	fr_skip_whitespace(p);
 
-	if (tp->test_ctx && (tp->test_ctx(&decoder_ctx, cc->tmp_ctx) < 0)) {
+	if (tp->test_ctx && (tp->test_ctx(&decode_ctx, cc->tmp_ctx) < 0)) {
 		fr_strerror_const_push("Failed initialising decoder testpoint");
 		RETURN_COMMAND_ERROR();
 	}
@@ -1422,7 +1422,7 @@ static size_t command_decode_proto(command_result_t *result, command_file_ctx_t
 	ASAN_POISON_MEMORY_REGION(to_dec_end, COMMAND_OUTPUT_MAX - slen);
 
 	slen = tp->func(cc->tmp_ctx, &head,
-			(uint8_t *)to_dec, (to_dec_end - to_dec), decoder_ctx);
+			(uint8_t *)to_dec, (to_dec_end - to_dec), decode_ctx);
 	cc->last_ret = slen;
 	if (slen <= 0) {
 		ASAN_UNPOISON_MEMORY_REGION(to_dec_end, COMMAND_OUTPUT_MAX - slen);
@@ -1588,7 +1588,7 @@ static size_t command_encode_pair(command_result_t *result, command_file_ctx_t *
 	fr_test_point_pair_encode_t	*tp = NULL;
 
 	fr_dcursor_t	cursor;
-	void		*encoder_ctx = NULL;
+	void		*encode_ctx = NULL;
 	ssize_t		slen;
 	char		*p = in;
 
@@ -1626,7 +1626,7 @@ static size_t command_encode_pair(command_result_t *result, command_file_ctx_t *
 		fr_skip_whitespace(p);
 	}
 
-	if (tp->test_ctx && (tp->test_ctx(&encoder_ctx, cc->tmp_ctx) < 0)) {
+	if (tp->test_ctx && (tp->test_ctx(&encode_ctx, cc->tmp_ctx) < 0)) {
 		fr_strerror_const_push("Failed initialising encoder testpoint");
 		CLEAR_TEST_POINT(cc);
 		RETURN_COMMAND_ERROR();
@@ -1671,7 +1671,7 @@ static size_t command_encode_pair(command_result_t *result, command_file_ctx_t *
 						     cc->tmpl_rules.dict_def ? cc->tmpl_rules.dict_def : cc->config->dict, fr_pair_t);
 		     vp;
 		     vp = fr_dcursor_current(&cursor)) {
-			slen = tp->func(&FR_DBUFF_TMP(enc_p, enc_end), &cursor, encoder_ctx);
+			slen = tp->func(&FR_DBUFF_TMP(enc_p, enc_end), &cursor, encode_ctx);
 			cc->last_ret = slen;
 
 			if (truncate) DEBUG("%s[%d]: Iteration %zu - Result %zd%s%s",
@@ -1765,7 +1765,7 @@ static size_t command_encode_proto(command_result_t *result, command_file_ctx_t
 {
 	fr_test_point_proto_encode_t	*tp = NULL;
 
-	void		*encoder_ctx = NULL;
+	void		*encode_ctx = NULL;
 	ssize_t		slen;
 	char		*p = in;
 
@@ -1781,7 +1781,7 @@ static size_t command_encode_proto(command_result_t *result, command_file_ctx_t
 
 	p += ((size_t)slen);
 	fr_skip_whitespace(p);
-	if (tp->test_ctx && (tp->test_ctx(&encoder_ctx, cc->tmp_ctx) < 0)) {
+	if (tp->test_ctx && (tp->test_ctx(&encode_ctx, cc->tmp_ctx) < 0)) {
 		fr_strerror_const_push("Failed initialising encoder testpoint");
 		CLEAR_TEST_POINT(cc);
 		RETURN_COMMAND_ERROR();
@@ -1793,7 +1793,7 @@ static size_t command_encode_proto(command_result_t *result, command_file_ctx_t
 		RETURN_OK_WITH_ERROR();
 	}
 
-	slen = tp->func(cc->tmp_ctx, &head, cc->buffer_start, cc->buffer_end - cc->buffer_start, encoder_ctx);
+	slen = tp->func(cc->tmp_ctx, &head, cc->buffer_start, cc->buffer_end - cc->buffer_start, encode_ctx);
 	fr_pair_list_free(&head);
 	cc->last_ret = slen;
 	if (slen < 0) {
diff --git a/src/lib/eap_aka_sim/base.h b/src/lib/eap_aka_sim/base.h
index d634cf70e6f..04ae1a1e91b 100644
--- a/src/lib/eap_aka_sim/base.h
+++ b/src/lib/eap_aka_sim/base.h
@@ -246,7 +246,7 @@ extern size_t const fr_aka_sim_attr_sizes[FR_TYPE_MAX + 1][2];
  *	decode.c
  */
 ssize_t		fr_aka_sim_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-					   uint8_t const *data, size_t data_len, void *decoder_ctx);
+					   uint8_t const *data, size_t data_len, void *decode_ctx);
 
 int		fr_aka_sim_decode(request_t *request, fr_dcursor_t *decoded, fr_dict_t const *dict,
 				      uint8_t const *data, size_t data_len, fr_aka_sim_decode_ctx_t *ctx);
@@ -254,7 +254,7 @@ int		fr_aka_sim_decode(request_t *request, fr_dcursor_t *decoded, fr_dict_t cons
 /*
  *	encode.c
  */
-ssize_t		fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx);
+ssize_t		fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx);
 
 ssize_t		fr_aka_sim_encode(request_t *request, fr_pair_list_t *to_encode, void *encode_ctx);
 
diff --git a/src/lib/eap_aka_sim/decode.c b/src/lib/eap_aka_sim/decode.c
index f02d6b5e347..55c8b5dfe67 100644
--- a/src/lib/eap_aka_sim/decode.c
+++ b/src/lib/eap_aka_sim/decode.c
@@ -58,11 +58,11 @@ RCSID("$Id$")
  */
 
 static ssize_t sim_decode_pair_internal(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_attr_t const *parent,
-					   uint8_t const *data, size_t data_len, void *decoder_ctx);
+					   uint8_t const *data, size_t data_len, void *decode_ctx);
 
 static ssize_t sim_decode_pair_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_attr_t const *parent,
 				     uint8_t const *data, size_t const attr_len, size_t const data_len,
-				     void *decoder_ctx);
+				     void *decode_ctx);
 
 /** Extract the IV value from an AT_IV attribute
  *
@@ -107,16 +107,16 @@ static inline int sim_iv_extract(uint8_t out[AKA_SIM_IV_SIZE], uint8_t const *in
  * @param[in] data		to decrypt.
  * @param[in] attr_len		length of encrypted data.
  * @param[in] data_len		length of data remaining in the packet.
- * @param[in] decoder_ctx	containing keys, and the IV (if we already found it).
+ * @param[in] decode_ctx	containing keys, and the IV (if we already found it).
  * @return
  *	- Number of decr bytes decrypted on success.
  *	- < 0 on failure.
  */
 static ssize_t sim_value_decrypt(TALLOC_CTX *ctx, uint8_t **out,
 				 uint8_t const *data, size_t const attr_len, size_t const data_len,
-				 void *decoder_ctx)
+				 void *decode_ctx)
 {
-	fr_aka_sim_decode_ctx_t	*packet_ctx = decoder_ctx;
+	fr_aka_sim_decode_ctx_t	*packet_ctx = decode_ctx;
 	EVP_CIPHER_CTX		*evp_ctx;
 	EVP_CIPHER const	*evp_cipher = EVP_aes_128_cbc();
 	size_t			block_size = EVP_CIPHER_block_size(evp_cipher);
@@ -297,7 +297,7 @@ static int sim_array_members(size_t *out, size_t len, fr_dict_attr_t const *da)
 static ssize_t sim_decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 				fr_dict_attr_t const *parent,
 				uint8_t const *data, size_t const attr_len, UNUSED size_t data_len,
-				void *decoder_ctx)
+				void *decode_ctx)
 {
 	uint8_t const	*p = data, *end = p + attr_len;
 	uint16_t	actual_len;
@@ -341,7 +341,7 @@ static ssize_t sim_decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 	if (elements < 0) return elements;
 
 	for (i = 0; i < elements; i++) {
-		ret = sim_decode_pair_value(ctx, cursor, parent, p, element_len, end - p, decoder_ctx);
+		ret = sim_decode_pair_value(ctx, cursor, parent, p, element_len, end - p, decode_ctx);
 		if (ret < 0) return ret;
 
 		p += ret;
@@ -360,7 +360,7 @@ static ssize_t sim_decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
  * @param[in] data		to parse. Points to the data field of the attribute.
  * @param[in] attr_len		length of the TLV attribute.
  * @param[in] data_len		remaining data in the packet.
- * @param[in] decoder_ctx	IVs, keys etc...
+ * @param[in] decode_ctx	IVs, keys etc...
  * @return
  *	- Length on success.
  *	- < 0 on malformed attribute.
@@ -368,7 +368,7 @@ static ssize_t sim_decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 static ssize_t sim_decode_tlv(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 			      fr_dict_attr_t const *parent,
 			      uint8_t const *data, size_t const attr_len, size_t data_len,
-			      void *decoder_ctx)
+			      void *decode_ctx)
 {
 	uint8_t const		*p = data, *end = p + attr_len;
 	uint8_t			*decr = NULL;
@@ -396,7 +396,7 @@ static ssize_t sim_decode_tlv(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 		FR_PROTO_TRACE("found encrypted attribute '%s'", parent->name);
 
 		decr_len = sim_value_decrypt(ctx, &decr, p + 2,
-					     attr_len - 2, data_len - 2, decoder_ctx);	/* Skip reserved */
+					     attr_len - 2, data_len - 2, decode_ctx);	/* Skip reserved */
 		if (decr_len < 0) return -1;
 
 		p = decr;
@@ -498,7 +498,7 @@ static ssize_t sim_decode_tlv(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 		FR_PROTO_TRACE("decode context changed %s -> %s", parent->name, child->name);
 
 		ret = sim_decode_pair_value(ctx, &tlv_cursor, child, p + 2, sim_at_len - 2, (end - p) - 2,
-					      decoder_ctx);
+					      decode_ctx);
 		if (ret < 0) goto error;
 		p += sim_at_len;
 	}
@@ -518,21 +518,21 @@ static ssize_t sim_decode_tlv(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
  * @param[in] data		to parse. Points to the data field of the attribute.
  * @param[in] attr_len		length of the attribute being parsed.
  * @param[in] data_len		length of the remaining data in the packet.
- * @param[in] decoder_ctx	IVs, keys etc...
+ * @param[in] decode_ctx	IVs, keys etc...
  * @return
  *	- Length on success.
  *	- -1 on failure.
  */
 static ssize_t sim_decode_pair_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_attr_t const *parent,
 				     uint8_t const *data, size_t const attr_len, size_t const data_len,
-				     void *decoder_ctx)
+				     void *decode_ctx)
 {
 	fr_pair_t		*vp;
 	uint8_t const		*p = data;
 	size_t			prefix = 0;
 	fr_dict_attr_t		*unknown;
 
-	fr_aka_sim_decode_ctx_t	*packet_ctx = decoder_ctx;
+	fr_aka_sim_decode_ctx_t	*packet_ctx = decode_ctx;
 
 	if (!fr_cond_assert(attr_len <= data_len)) return -1;
 	if (!fr_cond_assert(parent)) return -1;
@@ -682,7 +682,7 @@ static ssize_t sim_decode_pair_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_d
 		 *	attribute, OR they've already been grouped
 		 *	into a contiguous memory buffer.
 		 */
-		return sim_decode_tlv(ctx, cursor, parent, p, attr_len, data_len, decoder_ctx);
+		return sim_decode_tlv(ctx, cursor, parent, p, attr_len, data_len, decode_ctx);
 
 	default:
 	raw:
@@ -843,13 +843,13 @@ done:
  * @param[in] data_len		length of data.  For top level attributes packet_ctx must be the length
  *				of the packet (so we can hunt for AT_IV), for Sub-TLVs it should
  *				be the length of the container value.
- * @param[in] decoder_ctx	extra context to pass to the decoder.
+ * @param[in] decode_ctx	extra context to pass to the decoder.
  * @return
  *	- The number of bytes parsed.
  *	- -1 on error.
  */
 static ssize_t sim_decode_pair_internal(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_attr_t const *parent,
-					uint8_t const *data, size_t data_len, void *decoder_ctx)
+					uint8_t const *data, size_t data_len, void *decode_ctx)
 {
 	uint8_t			sim_at;
 	size_t			sim_at_len;
@@ -903,9 +903,9 @@ static ssize_t sim_decode_pair_internal(TALLOC_CTX *ctx, fr_dcursor_t *cursor, f
 	FR_PROTO_TRACE("decode context changed %s -> %s", da->parent->name, da->name);
 
 	if (da->flags.array) {
-		ret = sim_decode_array(ctx, cursor, da, data + 2, sim_at_len - 2, data_len - 2, decoder_ctx);
+		ret = sim_decode_array(ctx, cursor, da, data + 2, sim_at_len - 2, data_len - 2, decode_ctx);
 	} else {
-		ret = sim_decode_pair_value(ctx, cursor, da, data + 2, sim_at_len - 2, data_len - 2, decoder_ctx);
+		ret = sim_decode_pair_value(ctx, cursor, da, data + 2, sim_at_len - 2, data_len - 2, decode_ctx);
 	}
 	if (ret < 0) return ret;
 
@@ -921,15 +921,15 @@ static ssize_t sim_decode_pair_internal(TALLOC_CTX *ctx, fr_dcursor_t *cursor, f
  * @param[in] data_len		length of data.  For top level attributes packet_ctx must be the length
  *				of the packet (so we can hunt for AT_IV), for Sub-TLVs it should
  *				be the length of the container value.
- * @param[in] decoder_ctx	extra context to pass to the decoder.
+ * @param[in] decode_ctx	extra context to pass to the decoder.
  * @return
  *	- The number of bytes parsed.
  *	- -1 on error.
  */
 ssize_t fr_aka_sim_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-			   uint8_t const *data, size_t data_len, void *decoder_ctx)
+			   uint8_t const *data, size_t data_len, void *decode_ctx)
 {
-	return sim_decode_pair_internal(ctx, cursor, fr_dict_root(dict), data, data_len, decoder_ctx);
+	return sim_decode_pair_internal(ctx, cursor, fr_dict_root(dict), data, data_len, decode_ctx);
 }
 
 /** Decode SIM/AKA/AKA' specific packet data
@@ -954,13 +954,13 @@ ssize_t fr_aka_sim_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t
  * @param[in] dict		for looking up attributes.
  * @param[in] data		to convert to pairs.
  * @param[in] data_len		length of data to convert.
- * @param[in] decoder_ctx	holds the state of the decoder.
+ * @param[in] decode_ctx	holds the state of the decoder.
  * @return
  *	- 0 on success.
  *	- -1 on failure.
  */
 int fr_aka_sim_decode(request_t *request, fr_dcursor_t *decoded, fr_dict_t const *dict,
-		  uint8_t const *data, size_t data_len, fr_aka_sim_decode_ctx_t *decoder_ctx)
+		  uint8_t const *data, size_t data_len, fr_aka_sim_decode_ctx_t *decode_ctx)
 {
 	ssize_t			ret;
 	uint8_t	const		*p = data;
@@ -994,7 +994,7 @@ int fr_aka_sim_decode(request_t *request, fr_dcursor_t *decoded, fr_dict_t const
 	 *	in the SIM/AKA/AKA' dict.
 	 */
 	while (p < end) {
-		ret = fr_aka_sim_decode_pair(request->request_ctx, decoded, dict, p, end - p, decoder_ctx);
+		ret = fr_aka_sim_decode_pair(request->request_ctx, decoded, dict, p, end - p, decode_ctx);
 		if (ret <= 0) {
 			RPEDEBUG("Failed decoding AT");
 		error:
diff --git a/src/lib/eap_aka_sim/encode.c b/src/lib/eap_aka_sim/encode.c
index ff2850cbc2c..8953cffdb29 100644
--- a/src/lib/eap_aka_sim/encode.c
+++ b/src/lib/eap_aka_sim/encode.c
@@ -58,7 +58,7 @@ RCSID("$Id$")
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx);
+			      fr_dcursor_t *cursor, void *encode_ctx);
 
 /** Evaluation function for EAP-AKA-encodability
  *
@@ -99,9 +99,9 @@ static bool is_eap_aka_encodable(void const *item, void const *uctx)
 	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  @endverbatim
  */
-static ssize_t encode_iv(fr_dbuff_t *dbuff, void *encoder_ctx)
+static ssize_t encode_iv(fr_dbuff_t *dbuff, void *encode_ctx)
 {
-	fr_aka_sim_encode_ctx_t	*packet_ctx = encoder_ctx;
+	fr_aka_sim_encode_ctx_t	*packet_ctx = encode_ctx;
 	uint32_t		iv[4];
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 
@@ -151,12 +151,12 @@ static ssize_t encode_iv(fr_dbuff_t *dbuff, void *encoder_ctx)
  @endverbatim
  */
 static ssize_t encode_encrypted_value(fr_dbuff_t *dbuff,
-			     	      uint8_t const *in, size_t inlen, void *encoder_ctx)
+			     	      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);
 	uint8_t			*encr = NULL;
-	fr_aka_sim_encode_ctx_t	*packet_ctx = encoder_ctx;
+	fr_aka_sim_encode_ctx_t	*packet_ctx = encode_ctx;
 	EVP_CIPHER_CTX		*evp_ctx;
 	EVP_CIPHER const	*evp_cipher = EVP_aes_128_cbc();
 	size_t			block_size = EVP_CIPHER_block_size(evp_cipher);
@@ -268,12 +268,12 @@ static ssize_t encode_encrypted_value(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx)
+			    fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_pair_t const		*vp = fr_dcursor_current(cursor);
 	fr_dict_attr_t const	*da = da_stack->da[depth];
-	fr_aka_sim_encode_ctx_t	*packet_ctx = encoder_ctx;
+	fr_aka_sim_encode_ctx_t	*packet_ctx = encode_ctx;
 
 	VP_VERIFY(vp);
 	FR_PROTO_STACK_PRINT(da_stack, depth);
@@ -486,7 +486,7 @@ done:
 	/*
 	 *	Rebuilds the TLV stack for encoding the next attribute
 	 */
-	vp = fr_dcursor_filter_next(cursor, is_eap_aka_encodable, encoder_ctx);
+	vp = fr_dcursor_filter_next(cursor, is_eap_aka_encodable, encode_ctx);
 	fr_proto_da_stack_build(da_stack, vp ? vp->da : NULL);
 
 	return fr_dbuff_set(dbuff, &work_dbuff);
@@ -512,7 +512,7 @@ done:
  */
 static ssize_t encode_array(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx)
+			    fr_dcursor_t *cursor, void *encode_ctx)
 {
 	size_t			pad_len;
 	size_t			element_len;
@@ -544,7 +544,7 @@ static ssize_t encode_array(fr_dbuff_t *dbuff,
 		fr_pair_t	*vp;
 		ssize_t		slen;
 
-		slen = encode_value(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_value(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 		if (slen == PAIR_ENCODE_FATAL_ERROR) return slen;
 		if (slen < 0) break;
 
@@ -582,7 +582,7 @@ static ssize_t encode_array(fr_dbuff_t *dbuff,
  * Otherwise, attribute may be something else.
  */
 static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	size_t			pad_len;
 	fr_dict_attr_t const	*da;
@@ -623,10 +623,10 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
 
 	if (da->flags.array) {
 		slen = encode_array(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
-				    da_stack, depth, cursor, encoder_ctx);
+				    da_stack, depth, cursor, encode_ctx);
 	} else {
 		slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
-				    da_stack, depth, cursor, encoder_ctx);
+				    da_stack, depth, cursor, encode_ctx);
 	}
 	if (slen <= 0) return slen;
 
@@ -648,7 +648,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
 
 static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 					  fr_da_stack_t *da_stack, unsigned int depth,
-					  fr_dcursor_t *cursor, void *encoder_ctx)
+					  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);
@@ -674,9 +674,9 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 		 *	Determine the nested type and call the appropriate encoder
 		 */
 		if (da_stack->da[depth + 1]->type == FR_TYPE_TLV) {
-			slen = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			slen = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		} else {
-			slen = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			slen = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		}
 
 		if (slen <= 0) return slen;
@@ -703,7 +703,7 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 		ssize_t	value_len = fr_dbuff_used(&work_dbuff) - 2;
 
 		slen = encode_encrypted_value(&value_dbuff, fr_dbuff_current(&value_start),
-					      value_len, encoder_ctx);
+					      value_len, encode_ctx);
 		if (slen < 0) return PAIR_ENCODE_FATAL_ERROR;
 
 		FR_DBUFF_EXTEND_LOWAT_OR_RETURN(&work_dbuff, (size_t)slen - value_len);
@@ -717,7 +717,7 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	unsigned int		total_len;
 	ssize_t			len;
@@ -745,7 +745,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 	 *	this order.
 	 */
 	if (!da_stack->da[depth]->flags.extra && da_stack->da[depth]->flags.subtype) {
-		len = encode_iv(&work_dbuff, encoder_ctx);
+		len = encode_iv(&work_dbuff, encode_ctx);
 		if (len < 0) return len;
 	}
 	tl_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
@@ -755,7 +755,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 
 	da = da_stack->da[depth];
 	len = encode_tlv_internal(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN - 2),
-				  da_stack, depth, cursor, encoder_ctx);
+				  da_stack, depth, cursor, encode_ctx);
 	if (len <= 0) return len;
 
 	/*
@@ -771,7 +771,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 	return fr_dbuff_set(dbuff, &work_dbuff);	/* AT_IV + AT_*(TLV) - Can't use total_len, doesn't include IV */
 }
 
-ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx)
+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);
@@ -780,12 +780,12 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 
 	fr_da_stack_t		da_stack;
 	fr_dict_attr_t const	*da = NULL;
-	fr_aka_sim_encode_ctx_t	*packet_ctx = encoder_ctx;
+	fr_aka_sim_encode_ctx_t	*packet_ctx = encode_ctx;
 
 	fr_dbuff_marker(&m, &work_dbuff);
 	if (!cursor) return PAIR_ENCODE_FATAL_ERROR;
 
-	vp = fr_dcursor_filter_current(cursor, is_eap_aka_encodable, encoder_ctx);
+	vp = fr_dcursor_filter_current(cursor, is_eap_aka_encodable, encode_ctx);
 	if (!vp) return 0;
 
 	VP_VERIFY(vp);
@@ -797,7 +797,7 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 	}
 
 	if (vp->da->attr == FR_MAC) {
-		fr_dcursor_filter_next(cursor, is_eap_aka_encodable, encoder_ctx);
+		fr_dcursor_filter_next(cursor, is_eap_aka_encodable, encode_ctx);
 		return 0;
 	}
 	/*
@@ -815,7 +815,7 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 		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),
-				      &da_stack, 0, cursor, encoder_ctx);
+				      &da_stack, 0, cursor, encode_ctx);
 	}
 
 	/*
@@ -832,13 +832,13 @@ ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *en
 	 */
 	default:
 		slen = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, SIM_MAX_ATTRIBUTE_VALUE_LEN + 2),
-				      &da_stack, 0, cursor, encoder_ctx);
+				      &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),
-				      &da_stack, 0, cursor, encoder_ctx);
+				      &da_stack, 0, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		break;
 	}
diff --git a/src/lib/eap_aka_sim/state_machine.c b/src/lib/eap_aka_sim/state_machine.c
index cb91783a232..9932a2b0387 100644
--- a/src/lib/eap_aka_sim/state_machine.c
+++ b/src/lib/eap_aka_sim/state_machine.c
@@ -812,7 +812,7 @@ static int common_encode(request_t *request, eap_session_t *eap_session, uint16_
 	fr_pair_list_t		head;
 	fr_pair_t		*vp, *subtype_vp;
 	ssize_t			ret;
-	fr_aka_sim_encode_ctx_t	encoder_ctx = {
+	fr_aka_sim_encode_ctx_t	encode_ctx = {
 					.root = fr_dict_root(dict_eap_aka_sim),
 					.keys = &eap_aka_sim_session->keys,
 
@@ -863,7 +863,7 @@ static int common_encode(request_t *request, eap_session_t *eap_session, uint16_
 	 *	result.
 	 */
 	while ((vp = fr_dcursor_current(&cursor))) {
-		if (!fr_dict_attr_common_parent(encoder_ctx.root, vp->da, true)) {
+		if (!fr_dict_attr_common_parent(encode_ctx.root, vp->da, true)) {
 			fr_dcursor_next(&cursor);
 			continue;
 		}
@@ -894,7 +894,7 @@ static int common_encode(request_t *request, eap_session_t *eap_session, uint16_
 	eap_session->this_round->request->id = eap_aka_sim_session->id++ & 0xff;
 	eap_session->this_round->set_request_id = true;
 
-	ret = fr_aka_sim_encode(request, &head, &encoder_ctx);
+	ret = fr_aka_sim_encode(request, &head, &encode_ctx);
 	fr_dcursor_head(&to_encode);
 	fr_dcursor_free_list(&to_encode);
 
diff --git a/src/lib/io/pair.h b/src/lib/io/pair.h
index f8082aade57..7a78f2342c5 100644
--- a/src/lib/io/pair.h
+++ b/src/lib/io/pair.h
@@ -104,7 +104,7 @@ static inline bool fr_pair_encode_is_error(ssize_t slen)
  *
  * @param[out] out		Where to write the encoded data.
  * @param[in] cursor		Cursor containing the list of attributes to process.
- * @param[in] encoder_ctx	Any encoder specific data such as secrets or configurables.
+ * @param[in] encode_ctx	Any encoder specific data such as secrets or configurables.
  * @return
  *	- PAIR_ENCODE_SKIPPED - The current pair is not valid for encoding and should be skipped.
  *	- PAIR_ENCODE_FATAL_ERROR - Encoding failed in a fatal way. Encoding the packet should be
@@ -113,7 +113,7 @@ static inline bool fr_pair_encode_is_error(ssize_t slen)
  *	  integer that would be required to encode the attribute.
  *	- >0 - The number of bytes written to out.
  */
-typedef ssize_t (*fr_pair_encode_t)(fr_dbuff_t *out, fr_dcursor_t *cursor, void *encoder_ctx);
+typedef ssize_t (*fr_pair_encode_t)(fr_dbuff_t *out, fr_dcursor_t *cursor, void *encode_ctx);
 
 /** A generic interface for decoding fr_pair_ts
  *
@@ -125,10 +125,10 @@ typedef ssize_t (*fr_pair_encode_t)(fr_dbuff_t *out, fr_dcursor_t *cursor, void
  * @param[in] dict		to use to lookup attributes.
  * @param[in] data		to decode.
  * @param[in] data_len		The length of the incoming data.
- * @param[in] decoder_ctx	Any decode specific data such as secrets or configurable.
+ * @param[in] decode_ctx	Any decode specific data such as secrets or configurable.
  * @return
  *	- <= 0 on error.  May be the offset (as a negative value) where the error occurred.
  *	- > 0 on success.  How many bytes were decoded.
  */
 typedef ssize_t (*fr_pair_decode_t)(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				    uint8_t const *data, size_t data_len, void *decoder_ctx);
+				    uint8_t const *data, size_t data_len, void *decode_ctx);
diff --git a/src/lib/io/test_point.h b/src/lib/io/test_point.h
index 3c19c599836..e58105972ad 100644
--- a/src/lib/io/test_point.h
+++ b/src/lib/io/test_point.h
@@ -35,13 +35,13 @@ typedef int (*fr_test_point_ctx_alloc_t)(void **out, TALLOC_CTX *ctx);
  * @param[in] list		where new VPs will be added
  * @param[in] data		to decode.
  * @param[in] data_len		The length of the incoming data.
- * @param[in] decoder_ctx	Any decode specific data such as secrets or configurable.
+ * @param[in] decode_ctx	Any decode specific data such as secrets or configurable.
  * @return
  *	- <= 0 on error.  May be the offset (as a negative value) where the error occurred.
  *	- > 0 on success.  How many bytes were decoded.
  */
 typedef ssize_t (*fr_tp_proto_decode_t)(TALLOC_CTX *ctx, fr_pair_list_t *list,
-					uint8_t const *data, size_t data_len, void *decoder_ctx);
+					uint8_t const *data, size_t data_len, void *decode_ctx);
 
 /** A generic interface for encoding fr_pair_ts to packets
  *
@@ -51,13 +51,13 @@ typedef ssize_t (*fr_tp_proto_decode_t)(TALLOC_CTX *ctx, fr_pair_list_t *list,
  * @param[in] vps		vps to encode
  * @param[in] data		buffer where data can be written
  * @param[in] data_len		The length of the buffer, i.e. maximum packet length
- * @param[in] encoder_ctx	Any enccode specific data such as secrets or configurable.
+ * @param[in] encode_ctx	Any enccode specific data such as secrets or configurable.
  * @return
  *	- <= 0 on error.  May be the offset (as a negative value) where the error occurred.
  *	- > 0 on success.  How many bytes were encoded
  */
 typedef ssize_t (*fr_tp_proto_encode_t)(TALLOC_CTX *ctx, fr_pair_list_t *vps,
-					uint8_t *data, size_t data_len, void *encoder_ctx);
+					uint8_t *data, size_t data_len, void *encode_ctx);
 
 /** Entry point for protocol decoders
  *
diff --git a/src/lib/util/struct.c b/src/lib/util/struct.c
index 0fcbc273fa6..292d1a5ce26 100644
--- a/src/lib/util/struct.c
+++ b/src/lib/util/struct.c
@@ -64,7 +64,7 @@ fr_pair_t *fr_raw_from_network(TALLOC_CTX *ctx, fr_dict_attr_t const *parent, ui
  */
 ssize_t fr_struct_from_network(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 			       fr_dict_attr_t const *parent, uint8_t const *data, size_t data_len,
-			       void *decoder_ctx,
+			       void *decode_ctx,
 			       fr_decode_value_t decode_value, fr_decode_value_t decode_tlv)
 {
 	unsigned int		child_num;
@@ -191,7 +191,7 @@ ssize_t fr_struct_from_network(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 			 *	Decode EVERYTHING as a TLV.
 			 */
 			while (p < end) {
-				slen = decode_tlv(ctx, &child_cursor, fr_dict_by_da(child), child, p, end - p, decoder_ctx);
+				slen = decode_tlv(ctx, &child_cursor, fr_dict_by_da(child), child, p, end - p, decode_ctx);
 				if (slen < 0) goto unknown;
 				p += slen;
 			}
@@ -221,7 +221,7 @@ ssize_t fr_struct_from_network(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 		if (decode_value) {
 			ssize_t slen;
 
-			slen = decode_value(ctx, &child_cursor, fr_dict_by_da(child), child, p, child_length, decoder_ctx);
+			slen = decode_value(ctx, &child_cursor, fr_dict_by_da(child), child, p, child_length, decode_ctx);
 			if (slen < 0) return slen - (p - data);
 
 			p += slen;   	/* not always the same as child->flags.length */
@@ -329,7 +329,7 @@ ssize_t fr_struct_from_network(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 			fr_assert(child->type == FR_TYPE_STRUCT);
 
 			slen = fr_struct_from_network(ctx, &child_cursor, child, p, end - p,
-						      decoder_ctx, decode_value, decode_tlv);
+						      decode_ctx, decode_value, decode_tlv);
 			if (slen <= 0) goto unknown_child;
 			p += slen;
 		}
@@ -405,7 +405,7 @@ static int8_t pair_sort_increasing(void const *a, void const *b)
 
 ssize_t fr_struct_to_network(fr_dbuff_t *dbuff,
 			     fr_da_stack_t *da_stack, unsigned int depth,
-			     fr_dcursor_t *parent_cursor, void *encoder_ctx,
+			     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);
@@ -600,7 +600,7 @@ ssize_t fr_struct_to_network(fr_dbuff_t *dbuff,
 			 *	Call the protocol encoder for non-bit fields.
 			 */
 			fr_proto_da_stack_build(da_stack, child);
-			len = encode_value(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_value(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 			if (len < 0) return len;
 			vp = fr_dcursor_current(cursor);
 
@@ -649,7 +649,7 @@ ssize_t fr_struct_to_network(fr_dbuff_t *dbuff,
 			fr_proto_da_stack_build(da_stack, vp->da->parent);
 
 			len = fr_struct_to_network(&work_dbuff, da_stack, depth + 2, /* note + 2 !!! */
-						   cursor, encoder_ctx, encode_value, encode_tlv);
+						   cursor, encode_ctx, encode_value, encode_tlv);
 			if (len < 0) return len;
 			goto done;
 		}
@@ -680,7 +680,7 @@ done:
 		 *	Encode any TLV attributes which are part of this structure.
 		 */
 		while (vp && (da_stack->da[depth] == parent) && (da_stack->depth >= parent->depth)) {
-			slen = encode_tlv(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			slen = encode_tlv(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 			if (slen < 0) return slen;
 
 			vp = fr_dcursor_current(cursor);
diff --git a/src/lib/util/struct.h b/src/lib/util/struct.h
index 157f0a7fb60..9d79afbf5d1 100644
--- a/src/lib/util/struct.h
+++ b/src/lib/util/struct.h
@@ -34,18 +34,18 @@ extern "C" {
 
 typedef ssize_t (*fr_decode_value_t)(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 				     fr_dict_attr_t const *parent,
-				     uint8_t const *data, size_t const data_len, void *decoder_ctx);
+				     uint8_t const *data, size_t const data_len, void *decode_ctx);
 
 ssize_t fr_struct_from_network(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
 			       fr_dict_attr_t const *parent, uint8_t const *data, size_t data_len,
-			       void *decoder_ctx,
+			       void *decode_ctx,
 			       fr_decode_value_t decode_value, fr_decode_value_t decode_tlv) CC_HINT(nonnull(2,3,4));
 
 typedef ssize_t (*fr_encode_dbuff_t)(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned int depth,
-				     fr_dcursor_t *cursor, void *encoder_ctx);
+				     fr_dcursor_t *cursor, void *encode_ctx);
 	
 ssize_t fr_struct_to_network(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned int depth,
-			     fr_dcursor_t *cursor, void *encoder_ctx,
+			     fr_dcursor_t *cursor, void *encode_ctx,
 			     fr_encode_dbuff_t encode_value, fr_encode_dbuff_t encode_tlv) CC_HINT(nonnull(1,2,4));
 
 fr_pair_t *fr_raw_from_network(TALLOC_CTX *ctx, fr_dict_attr_t const *parent,
diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
index b69f42cc3c6..38a87a8fb3e 100644
--- a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
+++ b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
@@ -425,7 +425,7 @@ unexpected:
  */
 ssize_t eap_fast_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_t const *parent,
 			     uint8_t const *data, size_t data_len,
-			     void *decoder_ctx)
+			     void *decode_ctx)
 {
 	fr_dict_attr_t const	*da;
 	uint8_t	const		*p = data, *end = p + data_len;
@@ -449,7 +449,7 @@ ssize_t eap_fast_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_
 			MEM(vp = fr_pair_afrom_child_num(ctx, parent, attr));
 
 		} else if (da->type == FR_TYPE_TLV) {
-			p += (size_t) eap_fast_decode_pair(ctx, out, parent, p, len, decoder_ctx);
+			p += (size_t) eap_fast_decode_pair(ctx, out, parent, p, len, decode_ctx);
 			continue;
 
 		} else {
diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
index d94d1a5883d..cef09c1eb0c 100644
--- a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
+++ b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
@@ -260,4 +260,4 @@ fr_radius_packet_code_t eap_fast_process(request_t *request, eap_session_t *eap_
  */
 ssize_t		eap_fast_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_t const *parent,
 			     	     uint8_t const *data, size_t data_len,
-			     	     UNUSED void *decoder_ctx);
+			     	     UNUSED void *decode_ctx);
diff --git a/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c b/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
index 7fd35bdc3ac..c5696bbe2d1 100644
--- a/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
+++ b/src/modules/rlm_eap/types/rlm_eap_ttls/ttls.c
@@ -141,12 +141,12 @@ static int diameter_verify(request_t *request, uint8_t const *data, unsigned int
  */
 static ssize_t eap_ttls_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_attr_t const *parent,
 				    uint8_t const *data, size_t data_len,
-				    void *decoder_ctx)
+				    void *decode_ctx)
 {
 	uint8_t const		*p = data, *end = p + data_len;
 
 	fr_pair_t		*vp = NULL;
-	SSL			*ssl = decoder_ctx;
+	SSL			*ssl = decode_ctx;
 	fr_dict_t const		*dict_radius;
 	fr_dict_attr_t const   	*attr_radius;
 
diff --git a/src/protocols/dhcpv4/decode.c b/src/protocols/dhcpv4/decode.c
index c84760e37cc..e7c36ee0ccc 100644
--- a/src/protocols/dhcpv4/decode.c
+++ b/src/protocols/dhcpv4/decode.c
@@ -506,10 +506,10 @@ next:
  * @param[in] dict		to lookup attributes in.
  * @param[in] data		to parse.
  * @param[in] data_len		of data to parse.
- * @param[in] decoder_ctx	Unused.
+ * @param[in] decode_ctx	Unused.
  */
 ssize_t fr_dhcpv4_decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor,
-			        fr_dict_t const *dict, uint8_t const *data, size_t data_len, UNUSED void *decoder_ctx)
+			        fr_dict_t const *dict, uint8_t const *data, size_t data_len, UNUSED void *decode_ctx)
 {
 	ssize_t			ret;
 	uint8_t const		*p = data;
diff --git a/src/protocols/dhcpv4/dhcpv4.h b/src/protocols/dhcpv4/dhcpv4.h
index 4de151d7677..1b9f963e14a 100644
--- a/src/protocols/dhcpv4/dhcpv4.h
+++ b/src/protocols/dhcpv4/dhcpv4.h
@@ -162,12 +162,12 @@ void		fr_dhcpv4_print_hex(FILE *fp, uint8_t const *packet, size_t packet_len);
  *	decode.c
  */
 ssize_t		fr_dhcpv4_decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-					uint8_t const *data, size_t len, void *decoder_ctx);
+					uint8_t const *data, size_t len, void *decode_ctx);
 
 /*
  *	encode.c
  */
-ssize_t		fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx);
+ssize_t		fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx);
 
 /*
  *	packet.c
diff --git a/src/protocols/dhcpv4/encode.c b/src/protocols/dhcpv4/encode.c
index cdcdf2cbd5d..fd3059b0eac 100644
--- a/src/protocols/dhcpv4/encode.c
+++ b/src/protocols/dhcpv4/encode.c
@@ -44,14 +44,14 @@
  * @param[in] da_stack		Describing nesting of options.
  * @param[in] depth		in da_stack.
  * @param[in,out] cursor	Current attribute we're encoding.
- * @param[in] encoder_ctx	Containing DHCPv4 dictionary.
+ * @param[in] encode_ctx	Containing DHCPv4 dictionary.
  * @return
  *	- The length of data written.
  *	< 0 if there's not enough space or option type is unsupported
  */
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, unsigned int depth,
-			    fr_dcursor_t *cursor, UNUSED fr_dhcpv4_ctx_t *encoder_ctx)
+			    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);
@@ -197,7 +197,7 @@ static bool extend_option(fr_dbuff_t *dbuff, fr_dbuff_marker_t *hdr, int len)
  * @param[in] da_stack		Describing nesting of options.
  * @param[in] depth		in the da_stack.
  * @param[in,out] cursor	Current attribute we're encoding.
- * @param[in] encoder_ctx	Containing DHCPv4 dictionary.
+ * @param[in] encode_ctx	Containing DHCPv4 dictionary.
  * @return
  *	- >0 length of data encoded.
  *	- 0 if we ran out of space.
@@ -205,7 +205,7 @@ static bool extend_option(fr_dbuff_t *dbuff, fr_dbuff_marker_t *hdr, int len)
  */
 static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, fr_dhcpv4_ctx_t *encoder_ctx)
+			      fr_dcursor_t *cursor, fr_dhcpv4_ctx_t *encode_ctx)
 {
 	ssize_t			len;
 	uint8_t			option_len = 0;
@@ -248,7 +248,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 			break;
 		}
 
-		len = encode_value(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		len = encode_value(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 		if (len < -1) return len;
 		if (len == -1) {
 			FR_PROTO_TRACE("No more space in option");
@@ -291,7 +291,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
  * @param[in] da_stack		Describing nesting of options.
  * @param[in] depth		in the da_stack.
  * @param[in,out] cursor	Current attribute we're encoding.
- * @param[in] encoder_ctx	Containing DHCPv4 dictionary.
+ * @param[in] encode_ctx	Containing DHCPv4 dictionary.
  * @return
  *	- >0 length of data encoded.
  *	- 0 if we ran out of space.
@@ -299,7 +299,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, fr_dhcpv4_ctx_t *encoder_ctx)
+			      fr_dcursor_t *cursor, fr_dhcpv4_ctx_t *encode_ctx)
 {
 	ssize_t			len;
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
@@ -334,9 +334,9 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 		 *	Determine the nested type and call the appropriate encoder
 		 */
 		if (da_stack->da[depth + 1]->type == FR_TYPE_TLV) {
-			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		} else {
-			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		}
 		if (len < 0) return len;
 		if (len == 0) break;		/* Insufficient space */
@@ -409,7 +409,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 
 static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
-			       fr_dcursor_t *cursor, void *encoder_ctx)
+			       fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_MAX_NO_ADVANCE(dbuff, 255 - 4 - 1 - 2);
 	fr_dbuff_marker_t	hdr;
@@ -485,12 +485,12 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 		 *	@todo - encode all options which have the same parent vendor.
 		 */
 		if (da->type == FR_TYPE_TLV) {
-			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		} else {
 			/*
 			 *	Normal vendor option
 			 */
-			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		}
 		if (len < 0) return len;
 
@@ -520,13 +520,13 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
  * @param[out] dbuff		Where to write encoded DHCP attributes.
  * @param[in] cursor		with current VP set to the option to be encoded.
  *				Will be advanced to the next option to encode.
- * @param[in] encoder_ctx	Containing DHCPv4 dictionary.
+ * @param[in] encode_ctx	Containing DHCPv4 dictionary.
  * @return
  *	- > 0 length of data written.
  *	- < 0 error.
  *	- 0 not valid option for DHCP (skipping).
  */
-ssize_t fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx)
+ssize_t fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_pair_t		*vp;
 	unsigned int		depth = 0;
@@ -554,15 +554,15 @@ ssize_t fr_dhcpv4_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *e
 	 */
 	switch (da_stack.da[depth]->type) {
 	case FR_TYPE_VSA:
-		len = encode_vsio_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_vsio_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 
 	case FR_TYPE_TLV:
-		len = encode_tlv_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_tlv_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 
 	default:
-		len = encode_rfc_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_rfc_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 	}
 
diff --git a/src/protocols/dhcpv6/decode.c b/src/protocols/dhcpv6/decode.c
index 05c41e41c07..4f83b730a79 100644
--- a/src/protocols/dhcpv6/decode.c
+++ b/src/protocols/dhcpv6/decode.c
@@ -41,27 +41,27 @@
 
 static ssize_t decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			     fr_dict_attr_t const *parent,
-			     uint8_t const *data, size_t const data_len, void *decoder_ctx);
+			     uint8_t const *data, size_t const data_len, void *decode_ctx);
 static ssize_t decode_tlvs(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			   fr_dict_attr_t const *parent,
-			   uint8_t const *data, size_t const data_len, void *decoder_ctx, bool do_raw);
+			   uint8_t const *data, size_t const data_len, void *decode_ctx, bool do_raw);
 
 static ssize_t decode_tlv_trampoline(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 				     fr_dict_attr_t const *parent,
-				     uint8_t const *data, size_t const data_len, void *decoder_ctx)
+				     uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
-	return decode_tlvs(ctx, cursor, dict, parent, data, data_len, decoder_ctx, true);
+	return decode_tlvs(ctx, cursor, dict, parent, data, data_len, decode_ctx, true);
 }
 
 
 static ssize_t decode_raw(TALLOC_CTX *ctx, fr_dcursor_t *cursor, UNUSED fr_dict_t const *dict,
 			  fr_dict_attr_t const *parent,
-			  uint8_t const *data, size_t const data_len, void *decoder_ctx)
+			  uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	fr_pair_t		*vp;
 	fr_dict_attr_t		*unknown;
 	fr_dict_attr_t const	*da;
-	fr_dhcpv6_decode_ctx_t	*packet_ctx = decoder_ctx;
+	fr_dhcpv6_decode_ctx_t	*packet_ctx = decode_ctx;
 	ssize_t			slen;
 
 #ifdef __clang_analyzer__
@@ -101,37 +101,37 @@ static ssize_t decode_raw(TALLOC_CTX *ctx, fr_dcursor_t *cursor, UNUSED fr_dict_
 
 static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t const data_len, void *decoder_ctx);
+			    uint8_t const *data, size_t const data_len, void *decode_ctx);
 static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t const data_len, void *decoder_ctx);
+			    uint8_t const *data, size_t const data_len, void *decode_ctx);
 static ssize_t decode_dns_labels(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 				 fr_dict_attr_t const *parent,
-				 uint8_t const *data, size_t const data_len, void *decoder_ctx);
+				 uint8_t const *data, size_t const data_len, void *decode_ctx);
 
 /** Handle arrays of DNS lavels for fr_struct_from_network()
  *
  */
 static ssize_t decode_value_trampoline(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 				       fr_dict_attr_t const *parent,
-				       uint8_t const *data, size_t const data_len, void *decoder_ctx)
+				       uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
-	if (parent->flags.array) return decode_array(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+	if (parent->flags.array) return decode_array(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 
 	/*
 	 *	@todo - we might need to limit this to only one DNS label.
 	 */
 	if ((parent->type == FR_TYPE_STRING) && !parent->flags.extra && parent->flags.subtype) {
-		return decode_dns_labels(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+		return decode_dns_labels(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 	}
 
-	return decode_value(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+	return decode_value(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 }
 
 
 static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t const data_len, void *decoder_ctx)
+			    uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	ssize_t			slen;
 	fr_pair_t		*vp;
@@ -146,7 +146,7 @@ static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 	case FR_TYPE_IPV6_PREFIX:
 		if ((data_len == 0) || (data_len > (1 + sizeof(vp->vp_ipv6addr)))) {
 		raw:
-			return decode_raw(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+			return decode_raw(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 
 		};
 
@@ -232,7 +232,7 @@ static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 
 	case FR_TYPE_STRUCT:
 		slen = fr_struct_from_network(ctx, cursor, parent, data, data_len,
-					      decoder_ctx, decode_value_trampoline, decode_tlv_trampoline);
+					      decode_ctx, decode_value_trampoline, decode_tlv_trampoline);
 		if (slen < 0) return slen;
 		return data_len;
 
@@ -254,7 +254,7 @@ static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 		 *	here.
 		 */
 		fr_dcursor_init(&child_cursor, &head);
-		slen = decode_tlvs(vp, &child_cursor, dict, fr_dict_root(dict_dhcpv6), data, data_len, decoder_ctx, false);
+		slen = decode_tlvs(vp, &child_cursor, dict, fr_dict_root(dict_dhcpv6), data, data_len, decode_ctx, false);
 		if (slen < 0) {
 			talloc_free(vp);
 			goto raw;
@@ -283,7 +283,7 @@ static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 
 static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t const data_len, void *decoder_ctx)
+			    uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	uint8_t const  		*p = data, *end = p + data_len;
 	ssize_t			slen;
@@ -306,12 +306,12 @@ static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 			 *	decode the last bit as raw data.
 			 */
 			if ((size_t) (end - p) < element_len) {
-				slen = decode_raw(ctx, cursor, dict, parent, p, end - p , decoder_ctx);
+				slen = decode_raw(ctx, cursor, dict, parent, p, end - p , decode_ctx);
 				if (slen < 0) return slen;
 				break;
 			}
 
-			slen = decode_value(ctx, cursor, dict, parent, p, element_len, decoder_ctx);
+			slen = decode_value(ctx, cursor, dict, parent, p, element_len, decode_ctx);
 			if (slen < 0) return slen;
 			if (!fr_cond_assert((size_t) slen == element_len)) return -(p - data);
 
@@ -336,7 +336,7 @@ static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 	while (p < end) {
 		if ((end - p) < 2) {
 		raw:
-			slen = decode_raw(ctx, cursor, dict, parent, p, end - p , decoder_ctx);
+			slen = decode_raw(ctx, cursor, dict, parent, p, end - p , decode_ctx);
 			if (slen < 0) return slen;
 			break;
 		}
@@ -347,7 +347,7 @@ static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 		}
 
 		p += 2;
-		slen = decode_value(ctx, cursor, dict, parent, p, element_len, decoder_ctx);
+		slen = decode_value(ctx, cursor, dict, parent, p, element_len, decode_ctx);
 		if (slen < 0) return slen;
 		p += slen;
 	}
@@ -357,7 +357,7 @@ static ssize_t decode_array(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 
 static ssize_t decode_dns_labels(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 				 fr_dict_attr_t const *parent,
-				 uint8_t const *data, size_t const data_len, void *decoder_ctx)
+				 uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	ssize_t slen;
 	size_t total;
@@ -389,7 +389,7 @@ static ssize_t decode_dns_labels(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_
 		slen = fr_dns_labels_network_verify(data, data_len);
 		if (slen < 0) {
 		raw:
-			return decode_raw(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+			return decode_raw(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 		}
 	}
 
@@ -425,7 +425,7 @@ static ssize_t decode_dns_labels(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_
  */
 static ssize_t decode_tlvs(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			   fr_dict_attr_t const *parent,
-			   uint8_t const *data, size_t const data_len, void *decoder_ctx, bool do_raw)
+			   uint8_t const *data, size_t const data_len, void *decode_ctx, bool do_raw)
 {
 	uint8_t const *p, *end;
 
@@ -440,11 +440,11 @@ static ssize_t decode_tlvs(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t cons
 	while (p < end) {
 		ssize_t slen;
 
-		slen = decode_option(ctx, cursor, dict, parent, p, (end - p), decoder_ctx);
+		slen = decode_option(ctx, cursor, dict, parent, p, (end - p), decode_ctx);
 		if (slen <= 0) {
 			if (!do_raw) return slen;
 
-			slen = decode_raw(ctx, cursor, dict, parent, p, (end - p), decoder_ctx);
+			slen = decode_raw(ctx, cursor, dict, parent, p, (end - p), decode_ctx);
 			if (slen <= 0) return slen;
 			break;
 		}
@@ -458,11 +458,11 @@ static ssize_t decode_tlvs(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t cons
 
 static ssize_t decode_vsa(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			  fr_dict_attr_t const *parent,
-			  uint8_t const *data, size_t const data_len, void *decoder_ctx)
+			  uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	uint32_t		pen;
 	fr_dict_attr_t const	*da;
-	fr_dhcpv6_decode_ctx_t	*packet_ctx = decoder_ctx;
+	fr_dhcpv6_decode_ctx_t	*packet_ctx = decode_ctx;
 
 	FR_PROTO_HEX_DUMP(data, data_len, "decode_vsa");
 
@@ -473,7 +473,7 @@ static ssize_t decode_vsa(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const
 	/*
 	 *	Enterprise code plus at least one option header
 	 */
-	if (data_len < 8) return decode_raw(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+	if (data_len < 8) return decode_raw(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 
 	memcpy(&pen, data, sizeof(pen));
 	pen = htonl(pen);
@@ -497,18 +497,18 @@ static ssize_t decode_vsa(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const
 
 	FR_PROTO_TRACE("decode context %s -> %s", parent->name, da->name);
 
-	return decode_tlvs(ctx, cursor, dict, da, data + 4, data_len - 4, decoder_ctx, true);
+	return decode_tlvs(ctx, cursor, dict, da, data + 4, data_len - 4, decode_ctx, true);
 }
 
 static ssize_t decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			      fr_dict_attr_t const *parent,
-			      uint8_t const *data, size_t const data_len, void *decoder_ctx)
+			      uint8_t const *data, size_t const data_len, void *decode_ctx)
 {
 	unsigned int   		option;
 	size_t			len;
 	ssize_t			slen;
 	fr_dict_attr_t const	*da;
-	fr_dhcpv6_decode_ctx_t	*packet_ctx = decoder_ctx;
+	fr_dhcpv6_decode_ctx_t	*packet_ctx = decode_ctx;
 
 #ifdef __clang_analyzer__
 	if (!packet_ctx || !packet_ctx->tmp_ctx) return PAIR_DECODE_FATAL_ERROR;
@@ -558,19 +558,19 @@ static ssize_t decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t co
 
 		fr_dcursor_insert(cursor, vp);
 	} else if ((da->type == FR_TYPE_STRING) && !da->flags.extra && da->flags.subtype) {
-		slen = decode_dns_labels(ctx, cursor, dict, da, data + 4, len, decoder_ctx);
+		slen = decode_dns_labels(ctx, cursor, dict, da, data + 4, len, decode_ctx);
 
 	} else if (da->flags.array) {
-		slen = decode_array(ctx, cursor, dict, da, data + 4, len, decoder_ctx);
+		slen = decode_array(ctx, cursor, dict, da, data + 4, len, decode_ctx);
 
 	} else if (da->type == FR_TYPE_VSA) {
-		slen = decode_vsa(ctx, cursor, dict, da, data + 4, len, decoder_ctx);
+		slen = decode_vsa(ctx, cursor, dict, da, data + 4, len, decode_ctx);
 
 	} else if (da->type == FR_TYPE_TLV) {
-		slen = decode_tlvs(ctx, cursor, dict, da, data + 4, len, decoder_ctx, true);
+		slen = decode_tlvs(ctx, cursor, dict, da, data + 4, len, decode_ctx, true);
 
 	} else {
-		slen = decode_value(ctx, cursor, dict, da, data + 4, len, decoder_ctx);
+		slen = decode_value(ctx, cursor, dict, da, data + 4, len, decode_ctx);
 	}
 
 	if (slen < 0) return slen;
@@ -588,7 +588,7 @@ static ssize_t decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t co
  *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  */
 ssize_t fr_dhcpv6_decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				uint8_t const *data, size_t data_len, void *decoder_ctx)
+				uint8_t const *data, size_t data_len, void *decode_ctx)
 {
 	FR_PROTO_HEX_DUMP(data, data_len, "fr_dhcpv6_decode_pair");
 
@@ -599,7 +599,7 @@ ssize_t fr_dhcpv6_decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t
 	 *	All options including VSAs in DHCPv6 MUST follow the
 	 *	standard format.
 	 */
-	return decode_option(ctx, cursor, dict, fr_dict_root(dict), data, data_len, decoder_ctx);
+	return decode_option(ctx, cursor, dict, fr_dict_root(dict), data, data_len, decode_ctx);
 }
 
 /*
diff --git a/src/protocols/dhcpv6/dhcpv6.h b/src/protocols/dhcpv6/dhcpv6.h
index 6b13903e0b6..92ada6524cb 100644
--- a/src/protocols/dhcpv6/dhcpv6.h
+++ b/src/protocols/dhcpv6/dhcpv6.h
@@ -170,10 +170,10 @@ void		fr_dhcpv6_global_free(void);
 /*
  *	encode.c
  */
-ssize_t		fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void * encoder_ctx);
+ssize_t		fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void * encode_ctx);
 
 /*
  *	decode.c
  */
 ssize_t		fr_dhcpv6_decode_option(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-					uint8_t const *data, size_t data_len, void *decoder_ctx);
+					uint8_t const *data, size_t data_len, void *decode_ctx);
diff --git a/src/protocols/dhcpv6/encode.c b/src/protocols/dhcpv6/encode.c
index 8a7639a73db..ce9c0787a1f 100644
--- a/src/protocols/dhcpv6/encode.c
+++ b/src/protocols/dhcpv6/encode.c
@@ -41,19 +41,19 @@
 
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, unsigned int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx);
+			    fr_dcursor_t *cursor, void *encode_ctx);
 
 static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx);
+			      fr_dcursor_t *cursor, void *encode_ctx);
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx);
+			      fr_dcursor_t *cursor, void *encode_ctx);
 
 static ssize_t encode_tlv(fr_dbuff_t *dbuff,
 			  fr_da_stack_t *da_stack, unsigned int depth,
-			  fr_dcursor_t *cursor, void *encoder_ctx);
+			  fr_dcursor_t *cursor, void *encode_ctx);
 
 /** Macro-like function for encoding an option header
  *
@@ -81,7 +81,7 @@ static inline ssize_t encode_option_hdr(fr_dbuff_marker_t *m, uint16_t option, s
 
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, unsigned int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx)
+			    fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
@@ -95,7 +95,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 	 *	Pack multiple attributes into into a single option
 	 */
 	if ((vp->da->type == FR_TYPE_STRUCT) || (da->type == FR_TYPE_STRUCT)) {
-		slen = fr_struct_to_network(&work_dbuff, da_stack, depth, cursor, encoder_ctx, encode_value, encode_tlv);
+		slen = fr_struct_to_network(&work_dbuff, da_stack, depth, cursor, encode_ctx, encode_value, encode_tlv);
 		if (slen <= 0) return slen;
 
 		/*
@@ -299,7 +299,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 			(void) fr_dcursor_init(&child_cursor, &vp->vp_group);
 
 			while (fr_dcursor_current(&child_cursor) != NULL) {
-				slen = fr_dhcpv6_encode_option(&work_dbuff, &child_cursor, encoder_ctx);
+				slen = fr_dhcpv6_encode_option(&work_dbuff, &child_cursor, encode_ctx);
 				if (slen == PAIR_ENCODE_SKIPPED) continue;
 
 				if (slen < 0) return PAIR_ENCODE_FATAL_ERROR;
@@ -375,7 +375,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 
 static inline ssize_t encode_array(fr_dbuff_t *dbuff,
 				   fr_da_stack_t *da_stack, int depth,
-				   fr_dcursor_t *cursor, void *encoder_ctx)
+				   fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	size_t			element_len;
@@ -429,7 +429,7 @@ static inline ssize_t encode_array(fr_dbuff_t *dbuff,
 			FR_DBUFF_ADVANCE_RETURN(&element_dbuff, sizeof(uint16_t));	/* Make room for the length field */
 		}
 
-		slen = encode_value(&element_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_value(&element_dbuff, da_stack, depth, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		if (!fr_cond_assert(slen < UINT16_MAX)) return PAIR_ENCODE_FATAL_ERROR;
 
@@ -463,7 +463,7 @@ static inline ssize_t encode_array(fr_dbuff_t *dbuff,
 
 static ssize_t encode_tlv(fr_dbuff_t *dbuff,
 			  fr_da_stack_t *da_stack, unsigned int depth,
-			  fr_dcursor_t *cursor, void *encoder_ctx)
+			  fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
@@ -478,9 +478,9 @@ static ssize_t encode_tlv(fr_dbuff_t *dbuff,
 		 *	Determine the nested type and call the appropriate encoder
 		 */
 		if (da_stack->da[depth + 1]->type == FR_TYPE_TLV) {
-			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		} else {
-			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		}
 		if (len < 0) return len;
 
@@ -511,7 +511,7 @@ static ssize_t encode_tlv(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_dbuff_marker_t	hdr;
@@ -531,9 +531,9 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 	 *	Write out the option's value
 	 */
 	if (da->flags.array) {
-		len = encode_array(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		len = encode_array(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 	} else {
-		len = encode_value(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		len = encode_value(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 	}
 	if (len < 0) return len;
 
@@ -549,7 +549,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff,
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_dbuff_marker_t	hdr;
@@ -573,7 +573,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 
 	FR_DBUFF_ADVANCE_RETURN(&work_dbuff, DHCPV6_OPT_HDR_LEN);	/* Make room for option header */
 
-	len = encode_tlv(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+	len = encode_tlv(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 	if (len < 0) return len;
 
 	/*
@@ -605,7 +605,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
-			       fr_dcursor_t *cursor, void *encoder_ctx)
+			       fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_dbuff_marker_t	hdr;
@@ -665,12 +665,12 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
 	 *	Encode the different data types
 	 */
 	if (da->type == FR_TYPE_TLV) {
-		len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+		len = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 	} else {
 		/*
 		 *	Normal vendor option
 		 */
-		len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+		len = encode_rfc_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 	}
 	if (len < 0) return len;
 
@@ -687,7 +687,7 @@ static ssize_t encode_vsio_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_relay_message(fr_dbuff_t *dbuff,
 				    fr_da_stack_t *da_stack, unsigned int depth,
-				    fr_dcursor_t *cursor, UNUSED void *encoder_ctx)
+				    fr_dcursor_t *cursor, UNUSED void *encode_ctx)
 {
 	fr_dbuff_marker_t	start_m;
 	fr_dbuff_marker_t	len_m;
@@ -739,12 +739,12 @@ static ssize_t encode_relay_message(fr_dbuff_t *dbuff,
  * @param[out] dbuff		Where to write encoded DHCP attributes.
  * @param[in] cursor		with current VP set to the option to be encoded.
  *				Will be advanced to the next option to encode.
- * @param[in] encoder_ctx	containing parameters for the encoder.
+ * @param[in] encode_ctx	containing parameters for the encoder.
  * @return
  *	- > 0 length of data written.
  *	- < 0 error.
  */
-ssize_t fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void * encoder_ctx)
+ssize_t fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void * encode_ctx)
 {
 	fr_pair_t		*vp;
 	unsigned int		depth = 0;
@@ -772,22 +772,22 @@ ssize_t fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *
 	 */
 	switch (da_stack.da[depth]->type) {
 	case FR_TYPE_TLV:
-		len = encode_tlv_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_tlv_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 
 	case FR_TYPE_VSA:
-		len = encode_vsio_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_vsio_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 
 	case FR_TYPE_GROUP:
 		if (da_stack.da[depth] == attr_relay_message) {
-			len = encode_relay_message(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+			len = encode_relay_message(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 			break;
 		}
 		FALL_THROUGH;
 
 	default:
-		len = encode_rfc_hdr(&work_dbuff, &da_stack, depth, cursor, encoder_ctx);
+		len = encode_rfc_hdr(&work_dbuff, &da_stack, depth, cursor, encode_ctx);
 		break;
 	}
 	if (len < 0) return len;
diff --git a/src/protocols/internal/decode.c b/src/protocols/internal/decode.c
index f3ce4d93272..99ab7884296 100644
--- a/src/protocols/internal/decode.c
+++ b/src/protocols/internal/decode.c
@@ -36,14 +36,14 @@
 #include <freeradius-devel/util/talloc.h>
 
 static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dict_attr_t const *parent_da,
-				    fr_dbuff_t *dbuff, void *decoder_ctx);
+				    fr_dbuff_t *dbuff, void *decode_ctx);
 
 /** Decodes the value of an attribute, potentially producing a pair (added to the cursor)
  *
  */
 static ssize_t internal_decode_pair_value_dbuff(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dict_attr_t const *parent_da,
 						fr_dbuff_t *dbuff,
-						bool tainted, UNUSED void *decoder_ctx)
+						bool tainted, UNUSED void *decode_ctx)
 {
 	fr_pair_t	*vp;
 	ssize_t		slen;
@@ -70,7 +70,7 @@ static ssize_t internal_decode_pair_value_dbuff(TALLOC_CTX *ctx, fr_pair_list_t
  *
  */
 static ssize_t internal_decode_tlv(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dict_attr_t const *parent_da,
-				   fr_dbuff_t *dbuff, void *decoder_ctx)
+				   fr_dbuff_t *dbuff, void *decode_ctx)
 {
 
 	ssize_t		slen;
@@ -89,7 +89,7 @@ static ssize_t internal_decode_tlv(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dic
 		FR_PROTO_HEX_MARKER(fr_dbuff_start(&work_dbuff), fr_dbuff_len(&work_dbuff),
 				    fr_dbuff_remaining(&work_dbuff), "Decoding child");
 
-		slen = internal_decode_pair(ctx, &children, parent_da, &work_dbuff, decoder_ctx);
+		slen = internal_decode_pair(ctx, &children, parent_da, &work_dbuff, decode_ctx);
 		if (slen <= 0) return slen;
 	}
 
@@ -122,7 +122,7 @@ static ssize_t internal_decode_tlv(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dic
  *
  */
 static ssize_t internal_decode_group(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dict_attr_t const *parent_da,
-				     fr_dbuff_t *dbuff, void *decoder_ctx)
+				     fr_dbuff_t *dbuff, void *decode_ctx)
 {
 	fr_pair_t	*vp;
 	ssize_t		slen;
@@ -140,7 +140,7 @@ static ssize_t internal_decode_group(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_d
 		FR_PROTO_HEX_MARKER(fr_dbuff_current(dbuff), fr_dbuff_remaining(dbuff), fr_dbuff_used(&work_dbuff),
 				    "Decoding child");
 
-		slen = internal_decode_pair(vp, &vp->vp_group, parent_da, &work_dbuff, decoder_ctx);
+		slen = internal_decode_pair(vp, &vp->vp_group, parent_da, &work_dbuff, decode_ctx);
 		if (slen <= 0) {
 			talloc_free(vp);
 			return slen;
@@ -152,7 +152,7 @@ static ssize_t internal_decode_group(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_d
 }
 
 static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_dict_attr_t const *parent_da,
-				    fr_dbuff_t *dbuff, void *decoder_ctx)
+				    fr_dbuff_t *dbuff, void *decode_ctx)
 {
 	ssize_t			slen = 0;
 	fr_dict_attr_t const	*da;
@@ -295,7 +295,7 @@ static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_di
 		FR_PROTO_TRACE("Decoding %s - %s", da->name,
 			       fr_table_str_by_value(fr_value_box_type_table, da->type, "?Unknown?"));
 
-		slen = internal_decode_pair(ctx, head, parent_da, &work_dbuff, decoder_ctx);
+		slen = internal_decode_pair(ctx, head, parent_da, &work_dbuff, decode_ctx);
 		if (slen <= 0) goto error;
 		break;
 
@@ -305,12 +305,12 @@ static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_di
 	case FR_TYPE_TLV:
 		if (unlikely(tainted)) goto bad_tainted;
 
-		slen = internal_decode_tlv(ctx, head, da, &work_dbuff, decoder_ctx);
+		slen = internal_decode_tlv(ctx, head, da, &work_dbuff, decode_ctx);
 		if (slen <= 0) goto error;
 		break;
 
 	case FR_TYPE_GROUP:
-		slen = internal_decode_group(ctx, head, da, &work_dbuff, decoder_ctx);
+		slen = internal_decode_group(ctx, head, da, &work_dbuff, decode_ctx);
 		if (slen <= 0) goto error;
 		break;
 
@@ -319,7 +319,7 @@ static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_di
 		 *	It's ok for this function to return 0
 		 *	we can have zero length strings.
 		 */
-		slen = internal_decode_pair_value_dbuff(ctx, head, da, &work_dbuff, tainted, decoder_ctx);
+		slen = internal_decode_pair_value_dbuff(ctx, head, da, &work_dbuff, tainted, decode_ctx);
 		if (slen < 0) goto error;
 	}
 
@@ -330,13 +330,13 @@ static ssize_t internal_decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *head, fr_di
  *
  */
 ssize_t fr_internal_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				uint8_t const *data, size_t data_len, void *decoder_ctx)
+				uint8_t const *data, size_t data_len, void *decode_ctx)
 {
-	return fr_internal_decode_pair_dbuff(ctx, cursor, dict, &FR_DBUFF_TMP(data, data_len), decoder_ctx);
+	return fr_internal_decode_pair_dbuff(ctx, cursor, dict, &FR_DBUFF_TMP(data, data_len), decode_ctx);
 }
 
 ssize_t fr_internal_decode_pair_dbuff(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				fr_dbuff_t *dbuff, void *decoder_ctx)
+				fr_dbuff_t *dbuff, void *decode_ctx)
 {
 	fr_pair_list_t	list;
 	fr_dcursor_t	tmp_cursor;
@@ -345,7 +345,7 @@ ssize_t fr_internal_decode_pair_dbuff(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_
 
 	fr_pair_list_init(&list);
 
-	slen = internal_decode_pair(ctx, &list, fr_dict_root(dict), &work_dbuff, decoder_ctx);
+	slen = internal_decode_pair(ctx, &list, fr_dict_root(dict), &work_dbuff, decode_ctx);
 	if (slen <= 0) return slen;
 
 	fr_dcursor_init(&tmp_cursor, &list);
diff --git a/src/protocols/internal/encode.c b/src/protocols/internal/encode.c
index 9bd32b47709..80ed88ed20a 100644
--- a/src/protocols/internal/encode.c
+++ b/src/protocols/internal/encode.c
@@ -43,14 +43,14 @@
  * @param da_stack	da stack corresponding to the value pair
  * @param depth		in da_stack
  * @param cursor	cursor whose current value is the one to be encoded
- * @param encoder_ctx	encoder context
+ * @param encode_ctx	encoder context
  *
  * @return	either a negative number, indicating an error
  * 		or the number of bytes used to encode the value
  */
 static ssize_t internal_encode(fr_dbuff_t *dbuff,
 			       fr_da_stack_t *da_stack, unsigned int depth,
-			       fr_dcursor_t *cursor, void *encoder_ctx)
+			       fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_dbuff_marker_t	enc_field, len_field, value_field;
@@ -141,7 +141,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 	 */
 	case FR_TYPE_VSA:
 	case FR_TYPE_VENDOR:
-		slen = internal_encode(&value_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+		slen = internal_encode(&value_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		break;
 
@@ -168,7 +168,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 				fr_proto_da_stack_build_partial(da_stack, da_stack->da[depth], child->da);
 				FR_PROTO_STACK_PRINT(da_stack, depth);
 
-				slen = internal_encode(&value_dbuff, da_stack, depth + 1, &children, encoder_ctx);
+				slen = internal_encode(&value_dbuff, da_stack, depth + 1, &children, encode_ctx);
 				if (slen < 0) return slen;
 			}
 			fr_dcursor_next(cursor);
@@ -178,7 +178,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 		/*
 		 *	Still encoding intermediary TLVs...
 		 */
-		slen = internal_encode(&value_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+		slen = internal_encode(&value_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		if (slen < 0) return slen;
 		break;
 
@@ -199,7 +199,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
 		     vp = fr_dcursor_current(&children)) {
 		     	FR_PROTO_TRACE("encode ctx changed %s -> %s", da->name, vp->da->name);
 
-			slen = fr_internal_encode_pair(&value_dbuff, &children, encoder_ctx);
+			slen = fr_internal_encode_pair(&value_dbuff, &children, encode_ctx);
 			if (slen < 0) return slen;
 		}
 		fr_dcursor_next(cursor);
@@ -247,13 +247,13 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
  *
  * @param[in,out] dbuff		Where to write encoded data and how much one can write.
  * @param[in] cursor		Specifying attribute to encode.
- * @param[in] encoder_ctx	Additional data such as the shared secret to use.
+ * @param[in] encode_ctx	Additional data such as the shared secret to use.
  * @return
  *	- >0 The number of bytes written to out.
  *	- 0 Nothing to encode (or attribute skipped).
  *	- <0 an error occurred.
  */
-ssize_t fr_internal_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx)
+ssize_t fr_internal_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_pair_t		*vp;
 	fr_da_stack_t		da_stack;
@@ -263,7 +263,7 @@ ssize_t fr_internal_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *e
 
 	fr_proto_da_stack_build(&da_stack, vp->da);
 
-	return internal_encode(dbuff, &da_stack, 0, cursor, encoder_ctx);
+	return internal_encode(dbuff, &da_stack, 0, cursor, encode_ctx);
 }
 
 /*
diff --git a/src/protocols/internal/internal.h b/src/protocols/internal/internal.h
index 2b9b581cf28..3aa29ae3945 100644
--- a/src/protocols/internal/internal.h
+++ b/src/protocols/internal/internal.h
@@ -40,10 +40,10 @@
  * @copyright 2020 The FreeRADIUS server project
  */
 
-ssize_t fr_internal_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx);
+ssize_t fr_internal_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx);
 
 ssize_t fr_internal_decode_pair(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				uint8_t const *data, size_t data_len, void *decoder_ctx);
+				uint8_t const *data, size_t data_len, void *decode_ctx);
 
 ssize_t fr_internal_decode_pair_dbuff(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
-				fr_dbuff_t *dbuff, void *decoder_ctx);
+				fr_dbuff_t *dbuff, void *decode_ctx);
diff --git a/src/protocols/radius/decode.c b/src/protocols/radius/decode.c
index c2da0b7d074..0cb4189d0f6 100644
--- a/src/protocols/radius/decode.c
+++ b/src/protocols/radius/decode.c
@@ -982,20 +982,20 @@ create_attrs:
  */
 static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t data_len, void *decoder_ctx)
+			    uint8_t const *data, size_t data_len, void *decode_ctx)
 {
-	return fr_radius_decode_pair_value(ctx, cursor, dict, parent, data, data_len, data_len, decoder_ctx);
+	return fr_radius_decode_pair_value(ctx, cursor, dict, parent, data, data_len, data_len, decode_ctx);
 }
 
 /** Wrapper called by fr_struct_from_network()
  */
 static ssize_t decode_tlv(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t const *dict,
 			    fr_dict_attr_t const *parent,
-			    uint8_t const *data, size_t data_len, void *decoder_ctx)
+			    uint8_t const *data, size_t data_len, void *decode_ctx)
 {
 	FR_PROTO_HEX_DUMP(data, data_len, "%s", __FUNCTION__ );
 
-	return fr_radius_decode_tlv(ctx, cursor, dict, parent, data, data_len, decoder_ctx);
+	return fr_radius_decode_tlv(ctx, cursor, dict, parent, data, data_len, decode_ctx);
 }
 
 
diff --git a/src/protocols/radius/encode.c b/src/protocols/radius/encode.c
index 22a37187554..124184ba4ea 100644
--- a/src/protocols/radius/encode.c
+++ b/src/protocols/radius/encode.c
@@ -37,15 +37,15 @@ RCSID("$Id$")
 
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, unsigned int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx);
+			    fr_dcursor_t *cursor, void *encode_ctx);
 
 static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
 				       fr_da_stack_t *da_stack, unsigned int depth,
-				       fr_dcursor_t *cursor, void *encoder_ctx);
+				       fr_dcursor_t *cursor, void *encode_ctx);
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx);
+			      fr_dcursor_t *cursor, void *encode_ctx);
 
 /** Encode a CHAP password
  *
@@ -132,14 +132,14 @@ static ssize_t encode_password(fr_dbuff_t *dbuff, fr_dbuff_marker_t *input, size
 }
 
 
-static ssize_t encode_tunnel_password(fr_dbuff_t *dbuff, fr_dbuff_marker_t *in, size_t inlen, void *encoder_ctx)
+static ssize_t encode_tunnel_password(fr_dbuff_t *dbuff, fr_dbuff_marker_t *in, size_t inlen, void *encode_ctx)
 {
 	fr_md5_ctx_t	*md5_ctx, *md5_ctx_old;
 	uint8_t		digest[RADIUS_AUTH_VECTOR_LENGTH];
 	uint8_t		tpasswd[RADIUS_MAX_STRING_LENGTH];
 	size_t		i, n;
 	size_t		encrypted_len;
-	fr_radius_ctx_t	*packet_ctx = encoder_ctx;
+	fr_radius_ctx_t	*packet_ctx = encode_ctx;
 	uint32_t	r;
 	size_t		len;
 	ssize_t		slen;
@@ -238,7 +238,7 @@ static ssize_t encode_tunnel_password(fr_dbuff_t *dbuff, fr_dbuff_marker_t *in,
 
 static ssize_t encode_tlv_hdr_internal(fr_dbuff_t *dbuff,
 				       fr_da_stack_t *da_stack, unsigned int depth,
-				       fr_dcursor_t *cursor, void *encoder_ctx)
+				       fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t		slen;
 	fr_pair_t const	*vp = fr_dcursor_current(cursor);
@@ -257,9 +257,9 @@ static ssize_t encode_tlv_hdr_internal(fr_dbuff_t *dbuff,
 		 *	Determine the nested type and call the appropriate encoder
 		 */
 		if (da_stack->da[depth + 1]->type == FR_TYPE_TLV) {
-			slen = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			slen = encode_tlv_hdr(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		} else {
-			slen = encode_rfc_hdr_internal(&work_dbuff, da_stack, depth + 1, cursor, encoder_ctx);
+			slen = encode_rfc_hdr_internal(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
 		}
 
 		if (slen <= 0) return slen;
@@ -283,7 +283,7 @@ static ssize_t encode_tlv_hdr_internal(fr_dbuff_t *dbuff,
 
 static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	fr_dbuff_marker_t	len_m;
@@ -310,7 +310,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 	fr_dbuff_marker(&len_m, &work_dbuff);		/* Mark the start of the length field */
 	FR_DBUFF_ADVANCE_RETURN(&work_dbuff, 1);	/* One byte for the length */
 
-	slen = encode_tlv_hdr_internal(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encoder_ctx);
+	slen = encode_tlv_hdr_internal(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encode_ctx);
 	if (slen <= 0) return slen;
 
 	fr_dbuff_in(&len_m, (uint8_t)(slen + 2));
@@ -318,7 +318,7 @@ static ssize_t encode_tlv_hdr(fr_dbuff_t *dbuff,
 	return fr_dbuff_set(dbuff, &work_dbuff);
 }
 
-static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_list_t const *vps, void *encoder_ctx)
+static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_list_t const *vps, void *encode_ctx)
 {
 	ssize_t			slen;
 	fr_pair_t const	*vp;
@@ -334,7 +334,7 @@ static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_list_t const *vps, void *e
 		/*
 		 *	Encode an individual VP
 		 */
-		slen = fr_radius_encode_pair(dbuff, &cursor, encoder_ctx);
+		slen = fr_radius_encode_pair(dbuff, &cursor, encode_ctx);
 		if (slen < 0) {
 			if (slen == PAIR_ENCODE_SKIPPED) continue;
 			return slen;
@@ -357,13 +357,13 @@ static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_list_t const *vps, void *e
  */
 static ssize_t encode_value(fr_dbuff_t *dbuff,
 			    fr_da_stack_t *da_stack, unsigned int depth,
-			    fr_dcursor_t *cursor, void *encoder_ctx)
+			    fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	size_t			len;
 	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 = encoder_ctx;
+	fr_radius_ctx_t		*packet_ctx = encode_ctx;
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
 	fr_dbuff_t		value_dbuff;
 	fr_dbuff_marker_t	value_start, src, dest;
@@ -384,13 +384,13 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
 	 *	It's a little weird to consider a TLV as a value,
 	 *	but it seems to work OK.
 	 */
-	if (da->type == FR_TYPE_TLV) return encode_tlv_hdr(dbuff, da_stack, depth, cursor, encoder_ctx);
+	if (da->type == FR_TYPE_TLV) return encode_tlv_hdr(dbuff, da_stack, depth, cursor, encode_ctx);
 
 	/*
 	 *	This has special requirements.
 	 */
 	if ((vp->da->type == FR_TYPE_STRUCT) || (da->type == FR_TYPE_STRUCT)) {
-		slen = fr_struct_to_network(&work_dbuff, da_stack, depth, cursor, encoder_ctx, encode_value,
+		slen = fr_struct_to_network(&work_dbuff, da_stack, depth, cursor, encode_ctx, encode_value,
 					    encode_tlv_hdr_internal);
 		if (slen <= 0) return slen;
 
@@ -763,7 +763,7 @@ static ssize_t attr_shift(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
 				   fr_da_stack_t *da_stack, unsigned int depth,
-				   fr_dcursor_t *cursor, void *encoder_ctx)
+				   fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	uint8_t			hlen;
@@ -840,9 +840,9 @@ static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
 	}
 
 	if (da_stack->da[depth]->type == FR_TYPE_TLV) {
-		slen = encode_tlv_hdr_internal(&attr_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_tlv_hdr_internal(&attr_dbuff, da_stack, depth, cursor, encode_ctx);
 	} else {
-		slen = encode_value(&attr_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_value(&attr_dbuff, da_stack, depth, cursor, encode_ctx);
 	}
 	if (slen <= 0) return slen;
 
@@ -882,7 +882,7 @@ static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_concat(fr_dbuff_t *dbuff,
 			     fr_da_stack_t *da_stack, unsigned int depth,
-			     fr_dcursor_t *cursor, UNUSED void *encoder_ctx)
+			     fr_dcursor_t *cursor, UNUSED void *encode_ctx)
 {
 	uint8_t const		*p;
 	size_t			left;
@@ -940,7 +940,7 @@ static ssize_t encode_concat(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
 				       fr_da_stack_t *da_stack, unsigned int depth,
-				       fr_dcursor_t *cursor, void *encoder_ctx)
+				       fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t 		slen;
 	uint8_t			hlen;
@@ -970,7 +970,7 @@ static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
 	hlen = 2;
 	FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr, hlen);
 
-	slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encoder_ctx);
+	slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encode_ctx);
 	if (slen <= 0) return slen;
 
 	fr_dbuff_advance(&hdr, 1);
@@ -988,7 +988,7 @@ static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_vendor_attr_hdr(fr_dbuff_t *dbuff,
 				      fr_da_stack_t *da_stack, unsigned int depth,
-				      fr_dcursor_t *cursor, void *encoder_ctx)
+				      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	size_t			hdr_len;
@@ -1011,7 +1011,7 @@ static ssize_t encode_vendor_attr_hdr(fr_dbuff_t *dbuff,
 	da = da_stack->da[depth];
 
 	if ((da->type != FR_TYPE_TLV) && (dv->flags.type_size == 1) && (dv->flags.length == 1)) {
-		return encode_rfc_hdr_internal(dbuff, da_stack, depth, cursor, encoder_ctx);
+		return encode_rfc_hdr_internal(dbuff, da_stack, depth, cursor, encode_ctx);
 	}
 
 	hdr_len = dv->flags.type_size + dv->flags.length;
@@ -1061,9 +1061,9 @@ static ssize_t encode_vendor_attr_hdr(fr_dbuff_t *dbuff,
 	 *	internal tlv function, else we get a double TLV header.
 	 */
 	if (da_stack->da[depth]->type == FR_TYPE_TLV) {
-		slen = encode_tlv_hdr_internal(&FR_DBUFF_MAX(&work_dbuff, 255), da_stack, depth, cursor, encoder_ctx);
+		slen = encode_tlv_hdr_internal(&FR_DBUFF_MAX(&work_dbuff, 255), da_stack, depth, cursor, encode_ctx);
 	} else {
-		slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 255), da_stack, depth, cursor, encoder_ctx);
+		slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 255), da_stack, depth, cursor, encode_ctx);
 	}
 	if (slen <= 0) return slen;
 
@@ -1086,7 +1086,7 @@ static ssize_t encode_vendor_attr_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_wimax_hdr(fr_dbuff_t *dbuff,
 				fr_da_stack_t *da_stack, unsigned int depth,
-				fr_dcursor_t *cursor, void *encoder_ctx)
+				fr_dcursor_t *cursor, void *encode_ctx)
 {
 	ssize_t			slen;
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
@@ -1132,10 +1132,10 @@ static ssize_t encode_wimax_hdr(fr_dbuff_t *dbuff,
 	 */
 
 	if (da_stack->da[depth]->type == FR_TYPE_TLV) {
-		slen = encode_tlv_hdr_internal(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_tlv_hdr_internal(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 		if (slen <= 0) return slen;
 	} else {
-		slen = encode_value(&work_dbuff, da_stack, depth, cursor, encoder_ctx);
+		slen = encode_value(&work_dbuff, da_stack, depth, cursor, encode_ctx);
 		if (slen <= 0) return slen;
 	}
 
@@ -1171,7 +1171,7 @@ static ssize_t encode_wimax_hdr(fr_dbuff_t *dbuff,
  */
 static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
 			      fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_dbuff_marker_t	hdr;
 	fr_dbuff_t		work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
@@ -1192,7 +1192,7 @@ static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
 	 *	Double-check for WiMAX format
 	 */
 	if (fr_dict_vendor_num_by_da(da_stack->da[depth + 1]) == VENDORPEC_WIMAX) {
-		return encode_wimax_hdr(dbuff, da_stack, depth, cursor, encoder_ctx);
+		return encode_wimax_hdr(dbuff, da_stack, depth, cursor, encode_ctx);
 	}
 
 	/*
@@ -1214,7 +1214,7 @@ static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
 
 	FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t)da->attr);	/* Copy in the 32bit vendor ID */
 
-	len = encode_vendor_attr_hdr(&FR_DBUFF_MAX(&work_dbuff, 255 - 6), da_stack, depth, cursor, encoder_ctx);
+	len = encode_vendor_attr_hdr(&FR_DBUFF_MAX(&work_dbuff, 255 - 6), da_stack, depth, cursor, encode_ctx);
 	if (len < 0) return len;
 
 	fr_dbuff_advance(&hdr, 1);
@@ -1229,7 +1229,7 @@ static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
  *
  */
 static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned int depth,
-			      fr_dcursor_t *cursor, void *encoder_ctx)
+			      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);
@@ -1295,7 +1295,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
 		return fr_dbuff_set(dbuff, &work_dbuff);
 	}
 
-	return encode_rfc_hdr_internal(dbuff, da_stack, depth, cursor, encoder_ctx);
+	return encode_rfc_hdr_internal(dbuff, da_stack, depth, cursor, encode_ctx);
 }
 
 /** Encode a data structure into a RADIUS attribute
@@ -1306,13 +1306,13 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
  *
  * @param[out] dbuff		Where to write encoded data.
  * @param[in] cursor		Specifying attribute to encode.
- * @param[in] encoder_ctx	Additional data such as the shared secret to use.
+ * @param[in] encode_ctx	Additional data such as the shared secret to use.
  * @return
  *	- >0 The number of bytes written to out.
  *	- 0 Nothing to encode (or attribute skipped).
  *	- <0 an error occurred.
  */
-ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx)
+ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx)
 {
 	fr_pair_t const		*vp;
 	ssize_t			len;
@@ -1338,7 +1338,7 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 	 *	Tags are *top-level*, and are never nested.
 	 */
 	if (vp->da->type == FR_TYPE_GROUP) {
-		fr_radius_ctx_t	*packet_ctx = encoder_ctx;
+		fr_radius_ctx_t	*packet_ctx = encode_ctx;
 
 		if (!vp->da->flags.internal ||
 		    !((vp->da->attr > FR_TAG_BASE) && (vp->da->attr < (FR_TAG_BASE + 0x20)))) {
@@ -1351,7 +1351,7 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 		fr_assert(packet_ctx->tag < 0x20);
 
 		// recurse to encode the children of this attribute
-		len = encode_tags(&work_dbuff, &vp->vp_group, encoder_ctx);
+		len = encode_tags(&work_dbuff, &vp->vp_group, encode_ctx);
 		packet_ctx->tag = 0;
 		if (len < 0) return len;
 
@@ -1404,7 +1404,7 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 		da_stack.da[1] = NULL;
 		da_stack.depth = 1;
 		FR_PROTO_STACK_PRINT(&da_stack, 0);
-		len = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encoder_ctx);
+		len = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encode_ctx);
 		if (len < 0) return len;
 		return fr_dbuff_set(dbuff, &work_dbuff);
 	}
@@ -1425,14 +1425,14 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 			 *	using a different scheme than the "long
 			 *	extended" one.
 			 */
-			len = encode_concat(&work_dbuff, &da_stack, 0, cursor, encoder_ctx);
+			len = encode_concat(&work_dbuff, &da_stack, 0, cursor, encode_ctx);
 			if (len < 0) return len;
 			break;
 		}
 		FALL_THROUGH;
 
 	default:
-		len = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encoder_ctx);
+		len = encode_rfc_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encode_ctx);
 		if (len < 0) return len;
 		break;
 
@@ -1444,19 +1444,19 @@ ssize_t fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *enc
 			 *	attributes by fragmenting them inside
 			 *	of the WiMAX VSA space.
 			 */
-			len = encode_wimax_hdr(&work_dbuff, &da_stack, 0, cursor, encoder_ctx);
+			len = encode_wimax_hdr(&work_dbuff, &da_stack, 0, cursor, encode_ctx);
 			if (len < 0) return len;
 			break;
 		}
-		len = encode_vsa_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encoder_ctx);
+		len = encode_vsa_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encode_ctx);
 		if (len < 0) return len;
 		break;
 
 	case FR_TYPE_TLV:
 		if (!flag_extended(&da->flags)) {
-			len = encode_tlv_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encoder_ctx);
+			len = encode_tlv_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encode_ctx);
 		} else {
-			len = encode_extended_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encoder_ctx);
+			len = encode_extended_hdr(&FR_DBUFF_MAX(&work_dbuff, UINT8_MAX), &da_stack, 0, cursor, encode_ctx);
 		}
 		if (len < 0) return len;
 		break;
diff --git a/src/protocols/radius/radius.h b/src/protocols/radius/radius.h
index d0baf972cd3..025c703f2b5 100644
--- a/src/protocols/radius/radius.h
+++ b/src/protocols/radius/radius.h
@@ -192,7 +192,7 @@ void		fr_radius_encode_chap_password(uint8_t out[static 1 + RADIUS_CHAP_CHALLENG
 					       uint8_t id, uint8_t const vector[static RADIUS_AUTH_VECTOR_LENGTH],
 					       char const *password, size_t password_len) CC_HINT(nonnull(1,3,4));
 
-ssize_t		fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encoder_ctx);
+ssize_t		fr_radius_encode_pair(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void *encode_ctx);
 
 /*
  *	protocols/radius/decode.c