{
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;
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();
}
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);
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;
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();
}
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);
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;
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();
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",
{
fr_test_point_proto_encode_t *tp = NULL;
- void *encoder_ctx = NULL;
+ void *encode_ctx = NULL;
ssize_t slen;
char *p = in;
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();
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) {
* 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);
/*
* 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);
*/
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
*
* @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);
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;
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;
* @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.
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;
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;
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;
}
* @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;
* 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:
* @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;
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;
* @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
* @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;
* 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:
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
*
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@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);
@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);
*/
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);
/*
* 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);
*/
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;
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;
* 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;
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;
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);
* 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;
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);
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;
* 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);
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;
/*
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);
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);
}
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;
}
/*
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);
}
/*
*/
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;
}
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,
* 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;
}
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);
*
* @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
* 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
*
* @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);
* @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
*
* @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
*
*/
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;
* 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;
}
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 */
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;
}
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);
* 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);
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;
}
* 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);
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,
*/
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;
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 {
*/
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);
*/
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;
* @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;
* 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
* @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);
* @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.
*/
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;
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");
* @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.
*/
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);
* 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 */
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;
* @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;
* @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;
*/
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;
}
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__
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;
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);
};
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;
* 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;
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;
* 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);
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;
}
}
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;
}
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;
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);
}
}
*/
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;
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;
}
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");
/*
* 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);
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;
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;
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
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");
* 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);
}
/*
/*
* 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);
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
*
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);
* 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;
/*
(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;
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;
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;
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);
* 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;
*/
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;
* 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;
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;
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;
/*
*/
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;
* 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;
*/
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;
* @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;
*/
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;
#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;
*
*/
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;
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;
}
*
*/
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;
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;
}
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;
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;
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;
* 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;
}
*
*/
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;
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);
* @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;
*/
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;
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);
/*
* 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;
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);
*
* @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;
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);
}
/*
* @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);
*/
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);
}
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
*
}
-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;
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);
* 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;
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;
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));
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;
/*
* 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;
*/
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;
* 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;
*/
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;
}
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;
*/
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;
*/
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;
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);
*/
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;
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;
* 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;
*/
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);
*/
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;
}
*/
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);
* 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);
}
/*
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);
*
*/
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);
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
*
* @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;
* 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)))) {
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;
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);
}
* 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;
* 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;
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
projects / thirdparty / freeradius-server.git / commitdiff
