return 0;
}
-static int mschapv1_encode(fr_radius_packet_t *packet, fr_pair_t **request,
+static int mschapv1_encode(fr_radius_packet_t *packet, fr_pair_list_t *request,
char const *password)
{
unsigned int i;
*
* Should be O(n) if all the attributes exist. List must be pre-sorted.
*/
-static int rs_get_pairs(TALLOC_CTX *ctx, fr_pair_t **out, fr_pair_t *vps, fr_dict_attr_t const *da[], int num)
+static int rs_get_pairs(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_pair_list_t *vps, fr_dict_attr_t const *da[], int num)
{
fr_cursor_t list_cursor, out_cursor;
fr_pair_t *match, *copy;
uint64_t count = 0;
int i;
- last_match = vps;
+ last_match = *vps;
fr_cursor_init(&list_cursor, &last_match);
fr_cursor_init(&out_cursor, out);
return -1;
}
fr_cursor_append(&out_cursor, copy);
- last_match = match;
+ fr_pair_list_set_head(last_match, *match);
count++;
} while ((match = fr_cursor_filter_next(&list_cursor, fr_pair_matches_da, da[i])));
if ((conf->link_da_num > 0) && packet->vps) {
int ret;
- ret = rs_get_pairs(packet, &search.link_vps, packet->vps, conf->link_da,
+ ret = rs_get_pairs(packet, &search.link_vps, &packet->vps, conf->link_da,
conf->link_da_num);
if (ret < 0) {
ERROR("Failed extracting RTX linking pairs from request");
return i;
}
-static int rs_build_filter(fr_pair_t **out, char const *filter)
+static int rs_build_filter(fr_pair_list_t *out, char const *filter)
{
fr_cursor_t cursor;
fr_pair_t *vp;
*/
static int radsnmp_get_response(int fd,
fr_dict_attr_t const *root, fr_dict_attr_t const *type,
- fr_pair_t *head)
+ fr_pair_list_t *head)
{
fr_cursor_t cursor;
fr_pair_t *vp, *type_vp;
* attribute grouping to coalesce all related index
* attributes under a single request OID.
*/
- for (vp = fr_cursor_init(&cursor, &head);
+ for (vp = fr_cursor_init(&cursor, head);
vp;
vp = fr_cursor_next(&cursor)) {
fr_dict_attr_t const *common;
* - 0 on success.
* - -1 on failure.
*/
-static int radsnmp_set_response(int fd, fr_dict_attr_t const *error, fr_pair_t *head)
+static int radsnmp_set_response(int fd, fr_dict_attr_t const *error, fr_pair_list_t *head)
{
fr_pair_t *vp;
char buffer[64];
struct iovec io_vector[2];
char newline[] = "\n";
- vp = fr_pair_find_by_da(&head, error);
+ vp = fr_pair_find_by_da(head, error);
if (!vp) {
if (write(fd, "DONE\n", 5) < 0) {
fr_strerror_printf("Failed writing set response: %s", fr_syserror(errno));
case RADSNMP_GET:
case RADSNMP_GETNEXT:
ret = radsnmp_get_response(STDOUT_FILENO, conf->snmp_oid_root,
- attr_freeradius_snmp_type, reply->vps);
+ attr_freeradius_snmp_type, &reply->vps);
switch (ret) {
case -1:
fr_perror("Failed converting pairs to varbind response");
break;
case RADSNMP_SET:
- if (radsnmp_set_response(STDOUT_FILENO, attr_freeradius_snmp_failure, reply->vps) < 0) {
+ if (radsnmp_set_response(STDOUT_FILENO, attr_freeradius_snmp_failure, &reply->vps) < 0) {
fr_perror("Failed writing SET response");
return EXIT_FAILURE;
}
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, encoder_ctx);
fr_pair_list_free(&head);
cc->last_ret = slen;
if (slen < 0) {
/*
* Print out all the pairs we have so far
*/
- log_request_pair_list(L_DBG_LVL_2, request, NULL, cert_vps, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &cert_vps, NULL);
fr_cursor_merge(&list, &cursor);
fr_pair_list_init(&cert_vps);
}
* NOTE: Sometimes Framed-MTU might contain the length of EAP-Message,
* refer fragmentation in rfc2869.
*/
-eap_packet_raw_t *eap_packet_from_vp(TALLOC_CTX *ctx, fr_pair_t *vps)
+eap_packet_raw_t *eap_packet_from_vp(TALLOC_CTX *ctx, fr_pair_list_t *vps)
{
fr_pair_t *vp;
eap_packet_raw_t *eap_packet;
/*
* Get only EAP-Message attribute list
*/
- vp = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_message);
+ vp = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_message);
if (!vp) {
fr_strerror_printf("EAP-Message not found");
return NULL;
* interfaces in eapcommon.c
*/
fr_pair_t *eap_packet_to_vp(fr_radius_packet_t *packet, eap_packet_raw_t const *reply);
-eap_packet_raw_t *eap_packet_from_vp(TALLOC_CTX *ctx, fr_pair_t *vps);
+eap_packet_raw_t *eap_packet_from_vp(TALLOC_CTX *ctx, fr_pair_list_t *vps);
void eap_add_reply(request_t *request, fr_dict_attr_t const *da, uint8_t const *value, int len);
rlm_rcode_t eap_virtual_server(request_t *request, eap_session_t *eap_session, char const *virtual_server);
ptr[3] = CHBIND_NSID_RADIUS;
RDEBUG2("Sending chbind response: code %i", (int )(ptr[0]));
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
/* Encode the chbind attributes into the response */
ptr += 4;
* Handles multiple EAP-channel-binding Message attrs
* ie concatenates all to get the complete EAP-channel-binding packet.
*/
-chbind_packet_t *eap_chbind_vp2packet(TALLOC_CTX *ctx, fr_pair_t *vps)
+chbind_packet_t *eap_chbind_vp2packet(TALLOC_CTX *ctx, fr_pair_list_t *vps)
{
size_t length;
uint8_t *ptr;
chbind_packet_t *packet;
fr_cursor_t cursor;
- if (!fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_channel_binding_message)) return NULL;
+ if (!fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_channel_binding_message)) return NULL;
/*
* Compute the total length of the channel binding data.
FR_CODE chbind_process(request_t *request, CHBIND_REQ *chbind_req);
fr_pair_t *eap_chbind_packet2vp(fr_radius_packet_t *packet, chbind_packet_t *chbind);
-chbind_packet_t *eap_chbind_vp2packet(TALLOC_CTX *ctx, fr_pair_t *vps);
+chbind_packet_t *eap_chbind_vp2packet(TALLOC_CTX *ctx, fr_pair_list_t *vps);
*/
ssize_t fr_aka_sim_encode_pair(fr_dbuff_t *dbuff, fr_cursor_t *cursor, void *encoder_ctx);
-ssize_t fr_aka_sim_encode(request_t *request, fr_pair_t *to_encode, void *encode_ctx);
+ssize_t fr_aka_sim_encode(request_t *request, fr_pair_list_t *to_encode, void *encode_ctx);
/*
* base.c
/*
* vector.c
*/
-int fr_aka_sim_vector_gsm_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_gsm_from_attrs(request_t *request, fr_pair_list_t *vps,
int idx,
fr_aka_sim_keys_t *keys,
fr_aka_sim_vector_src_t *src);
-int fr_aka_sim_vector_umts_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_umts_from_attrs(request_t *request, fr_pair_list_t *vps,
fr_aka_sim_keys_t *keys,
fr_aka_sim_vector_src_t *src);
-int fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request_t *request, fr_pair_list_t *vps,
fr_aka_sim_keys_t *keys);
-int fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request_t *request, fr_pair_list_t *vps,
fr_aka_sim_keys_t *keys);
void fr_aka_sim_vector_umts_reauth_clear(fr_aka_sim_keys_t *keys);
return fr_dbuff_set(dbuff, &work_dbuff);
}
-ssize_t fr_aka_sim_encode(request_t *request, fr_pair_t *to_encode, void *encode_ctx)
+ssize_t fr_aka_sim_encode(request_t *request, fr_pair_list_t *to_encode, void *encode_ctx)
{
fr_pair_t *vp;
* It might be too big for putting into an
* EAP packet.
*/
- vp = fr_pair_find_by_child_num(&to_encode, packet_ctx->root, FR_SUBTYPE);
+ vp = fr_pair_find_by_child_num(to_encode, packet_ctx->root, FR_SUBTYPE);
if (!vp) {
REDEBUG("Missing subtype attribute");
return PAIR_ENCODE_FATAL_ERROR;
/*
* Group attributes with similar lineages together
*/
- fr_pair_list_sort(&to_encode, fr_pair_cmp_by_parent_num);
- if (fr_cursor_init(&cursor, &to_encode) == vp) fr_cursor_next(&cursor); /* Skip subtype if it came out first */
+ fr_pair_list_sort(to_encode, fr_pair_cmp_by_parent_num);
+ if (fr_cursor_init(&cursor, to_encode) == vp) fr_cursor_next(&cursor); /* Skip subtype if it came out first */
/*
* Will we need to generate a HMAC?
*/
- if (fr_pair_find_by_child_num(&to_encode, packet_ctx->root, FR_MAC)) do_hmac = true;
+ if (fr_pair_find_by_child_num(to_encode, packet_ctx->root, FR_MAC)) do_hmac = true;
/*
* Fast path, we just need to encode a subtype
/** Print out the error the client returned
*
*/
-static inline void client_error_debug(request_t *request, fr_pair_t *from_peer)
+static inline void client_error_debug(request_t *request, fr_pair_list_t *from_peer)
{
fr_pair_t *vp;
- vp = fr_pair_find_by_da(&from_peer, attr_eap_aka_sim_client_error_code);
+ vp = fr_pair_find_by_da(from_peer, attr_eap_aka_sim_client_error_code);
if (!vp) {
REDEBUG("Peer has not supplied a AT_ERROR_CODE");
} else {
RDEBUG2("Encoding attributes");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, head, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &head, NULL);
eap_session->this_round->request->type.num = eap_aka_sim_session->type;
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, &encoder_ctx);
fr_cursor_head(&to_encode);
fr_cursor_free_list(&to_encode);
*/
case FR_EAP_METHOD_SIM:
case FR_EAP_METHOD_AKA:
- if (fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request, request->state,
+ if (fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request, &request->state,
&eap_aka_sim_session->keys) != 0) {
request_new_id:
switch (eap_aka_sim_session->last_id_req) {
case FR_EAP_METHOD_AKA_PRIME:
switch (eap_aka_sim_session->kdf) {
case FR_KDF_VALUE_PRIME_WITH_CK_PRIME_IK_PRIME:
- if (fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request, request->state,
+ if (fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request, &request->state,
&eap_aka_sim_session->keys) != 0) {
goto request_new_id;
}
* Get vectors from attribute or generate
* them using COMP128-* or Milenage.
*/
- if (fr_aka_sim_vector_umts_from_attrs(request, request->control_pairs, &eap_aka_sim_session->keys, &src) != 0) {
+ if (fr_aka_sim_vector_umts_from_attrs(request, &request->control_pairs, &eap_aka_sim_session->keys, &src) != 0) {
REDEBUG("Failed retrieving UMTS vectors");
goto failure;
}
}
RDEBUG2("Acquiring GSM vector(s)");
- if ((fr_aka_sim_vector_gsm_from_attrs(request, request->control_pairs, 0,
+ if ((fr_aka_sim_vector_gsm_from_attrs(request, &request->control_pairs, 0,
&eap_aka_sim_session->keys, &src) != 0) ||
- (fr_aka_sim_vector_gsm_from_attrs(request, request->control_pairs, 1,
+ (fr_aka_sim_vector_gsm_from_attrs(request, &request->control_pairs, 1,
&eap_aka_sim_session->keys, &src) != 0) ||
- (fr_aka_sim_vector_gsm_from_attrs(request, request->control_pairs, 2,
+ (fr_aka_sim_vector_gsm_from_attrs(request, &request->control_pairs, 2,
&eap_aka_sim_session->keys, &src) != 0)) {
REDEBUG("Failed retrieving SIM vectors");
RETURN_MODULE_FAIL;
* Also checks the version matches one of the ones we advertised in our version list,
* which is a bit redundant seeing as there's only one version of EAP-SIM.
*/
-static int sim_start_selected_version_check(request_t *request, fr_pair_t *from_peer,
+static int sim_start_selected_version_check(request_t *request, fr_pair_list_t *from_peer,
eap_aka_sim_session_t *eap_aka_sim_session)
{
fr_pair_t *selected_version_vp;
/*
* Check that we got an AT_SELECTED_VERSION
*/
- selected_version_vp = fr_pair_find_by_da(&from_peer, attr_eap_aka_sim_selected_version);
+ selected_version_vp = fr_pair_find_by_da(from_peer, attr_eap_aka_sim_selected_version);
if (!selected_version_vp) {
REDEBUG("EAP-Response/SIM/Start does not contain AT_SELECTED_VERSION");
return -1;
*
* Does not actually perform cryptographic validation of AT_NONCE_MT, this is done later.
*/
-static int sim_start_nonce_mt_check(request_t *request, fr_pair_t *from_peer,
+static int sim_start_nonce_mt_check(request_t *request, fr_pair_list_t *from_peer,
eap_aka_sim_session_t *eap_aka_sim_session)
{
fr_pair_t *nonce_mt_vp;
/*
* Copy nonce_mt to the keying material
*/
- nonce_mt_vp = fr_pair_find_by_da(&from_peer, attr_eap_aka_sim_nonce_mt);
+ nonce_mt_vp = fr_pair_find_by_da(from_peer, attr_eap_aka_sim_nonce_mt);
if (!nonce_mt_vp) {
REDEBUG("EAP-Response/SIM/Start does not contain AT_NONCE_MT");
return -1;
* if pseudonym resolution went ok.
*/
case FR_IDENTITY_TYPE_VALUE_PSEUDONYM:
- if (sim_start_selected_version_check(request, *from_peer, eap_aka_sim_session) < 0) goto failure;
- if (sim_start_nonce_mt_check(request, *from_peer, eap_aka_sim_session) < 0) goto failure;
+ if (sim_start_selected_version_check(request, from_peer, eap_aka_sim_session) < 0) goto failure;
+ if (sim_start_nonce_mt_check(request, from_peer, eap_aka_sim_session) < 0) goto failure;
return unlang_module_yield_to_section(p_result,
request,
* later.
*/
case FR_IDENTITY_TYPE_VALUE_PERMANENT:
- if (sim_start_selected_version_check(request, *from_peer, eap_aka_sim_session) < 0) goto failure;
- if (sim_start_nonce_mt_check(request, *from_peer, eap_aka_sim_session) < 0) goto failure;
+ if (sim_start_selected_version_check(request, from_peer, eap_aka_sim_session) < 0) goto failure;
+ if (sim_start_nonce_mt_check(request, from_peer, eap_aka_sim_session) < 0) goto failure;
FALL_THROUGH;
default:
*
* This is called by the state_* functions to decode the peer's response.
*/
-static unlang_action_t common_decode(fr_pair_t **subtype_vp, fr_pair_t **vps,
+static unlang_action_t common_decode(fr_pair_t **subtype_vp, fr_pair_list_t *vps,
rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
eap_session_t *eap_session = eap_session_get(request->parent);
aka_vps = fr_cursor_next(&cursor);
if (aka_vps && RDEBUG_ENABLED2) {
RDEBUG2("Decoded attributes");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, aka_vps, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &aka_vps, NULL);
}
*subtype_vp = fr_pair_find_by_da(&aka_vps, attr_eap_aka_sim_subtype);
* Case 1 where we're allowed to send an EAP-Failure
*/
case FR_SUBTYPE_VALUE_AKA_SIM_CLIENT_ERROR:
- client_error_debug(request, from_peer);
+ client_error_debug(request, &from_peer);
eap_aka_sim_session->allow_encrypted = false;
* Case 1 where we're allowed to send an EAP-Failure
*/
case FR_SUBTYPE_VALUE_AKA_SIM_CLIENT_ERROR:
- client_error_debug(request, from_peer);
+ client_error_debug(request, &from_peer);
eap_aka_sim_session->allow_encrypted = false;
* Case 1 where we're allowed to send an EAP-Failure
*/
case FR_SUBTYPE_VALUE_AKA_SIM_CLIENT_ERROR:
- client_error_debug(request, from_peer);
+ client_error_debug(request, &from_peer);
eap_aka_sim_session->allow_encrypted = false;
* identity.
*/
case FR_SUBTYPE_VALUE_AKA_SIM_CLIENT_ERROR:
- client_error_debug(request, from_peer);
+ client_error_debug(request, &from_peer);
return unlang_module_yield_to_section(p_result,
request,
* identity.
*/
case FR_SUBTYPE_VALUE_AKA_SIM_CLIENT_ERROR:
- client_error_debug(request, from_peer);
+ client_error_debug(request, &from_peer);
return unlang_module_yield_to_section(p_result,
request,
#include <freeradius-devel/util/debug.h>
static int vector_opc_from_op(request_t *request, uint8_t const **out, uint8_t opc_buff[MILENAGE_OPC_SIZE],
- fr_pair_t *list, uint8_t const ki[MILENAGE_KI_SIZE])
+ fr_pair_list_t *list, uint8_t const ki[MILENAGE_KI_SIZE])
{
fr_pair_t *opc_vp;
fr_pair_t *op_vp;
- opc_vp = fr_pair_find_by_da(&list, attr_sim_opc);
+ opc_vp = fr_pair_find_by_da(list, attr_sim_opc);
if (opc_vp) {
if (opc_vp->vp_length != MILENAGE_OPC_SIZE) {
REDEBUG("&control.%s has incorrect length, expected %u bytes got %zu bytes",
return 0;
}
- op_vp = fr_pair_find_by_da(&list, attr_sim_op);
+ op_vp = fr_pair_find_by_da(list, attr_sim_op);
if (op_vp) {
if (op_vp->vp_length != MILENAGE_OP_SIZE) {
REDEBUG("&control.%s has incorrect length, expected %u bytes got %zu bytes",
return 1;
}
-static int vector_gsm_from_ki(request_t *request, fr_pair_t *vps, int idx, fr_aka_sim_keys_t *keys)
+static int vector_gsm_from_ki(request_t *request, fr_pair_list_t *vps, int idx, fr_aka_sim_keys_t *keys)
{
fr_pair_t *ki_vp, *version_vp;
uint8_t opc_buff[MILENAGE_OPC_SIZE];
/*
* Generate a new RAND value, and derive Kc and SRES from Ki
*/
- ki_vp = fr_pair_find_by_da(&vps, attr_sim_ki);
+ ki_vp = fr_pair_find_by_da(vps, attr_sim_ki);
if (!ki_vp) {
RDEBUG3("No &control.%sfound, not generating triplets locally", attr_sim_ki->name);
return 1;
* Check to see if we have a Ki for the IMSI, this allows us to generate the rest
* of the triplets.
*/
- version_vp = fr_pair_find_by_da(&vps, attr_sim_algo_version);
+ version_vp = fr_pair_find_by_da(vps, attr_sim_algo_version);
if (!version_vp) {
if (vector_opc_from_op(request, &opc_p, opc_buff, vps, ki_vp->vp_octets) < 0) return -1;
version = opc_p ? FR_SIM_ALGO_VERSION_VALUE_COMP128_4 : FR_SIM_ALGO_VERSION_VALUE_COMP128_3;
return 0;
}
-static int vector_gsm_from_triplets(request_t *request, fr_pair_t *vps,
+static int vector_gsm_from_triplets(request_t *request, fr_pair_list_t *vps,
int idx, fr_aka_sim_keys_t *keys)
{
fr_pair_t *rand = NULL, *sres = NULL, *kc = NULL;
fr_cursor_t cursor;
int i;
- for (i = 0, (kc = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_kc));
+ for (i = 0, (kc = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_kc));
(i < idx) && (kc = fr_cursor_next(&cursor));
i++);
if (!kc) {
return -1;
}
- for (i = 0, (rand = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_rand));
+ for (i = 0, (rand = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
(i < idx) && (rand = fr_cursor_next(&cursor));
i++);
if (!rand) {
return -1;
}
- for (i = 0, (sres = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_sres));
+ for (i = 0, (sres = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_sres));
(i < idx) && (sres = fr_cursor_next(&cursor));
i++);
if (!sres) {
/** Derive triplets from quintuplets
*
*/
-static int vector_gsm_from_quintuplets(request_t *request, fr_pair_t *vps,
+static int vector_gsm_from_quintuplets(request_t *request, fr_pair_list_t *vps,
int idx, fr_aka_sim_keys_t *keys)
{
fr_cursor_t cursor;
/*
* Fetch CK
*/
- for (i = 0, (ck = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_ck));
+ for (i = 0, (ck = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_ck));
(i < idx) && (ck = fr_cursor_next(&cursor));
i++);
if (!ck) {
/*
* Fetch IK
*/
- for (i = 0, (ik = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_ik));
+ for (i = 0, (ik = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_ik));
(i < idx) && (ik = fr_cursor_next(&cursor));
i++);
if (!ik) {
/*
* Fetch RAND
*/
- for (i = 0, (rand = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_rand));
+ for (i = 0, (rand = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
(i < idx) && (rand = fr_cursor_next(&cursor));
i++);
if (!rand) {
/*
* Fetch XRES
*/
- for (i = 0, (xres = fr_cursor_iter_by_da_init(&cursor, &vps, attr_eap_aka_sim_xres));
+ for (i = 0, (xres = fr_cursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_xres));
(i < idx) && (xres = fr_cursor_next(&cursor));
i++);
if (!xres) {
* - 0 Vector was retrieved OK and written to the specified index.
* - -1 Error retrieving vector from the specified src.
*/
-int fr_aka_sim_vector_gsm_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_gsm_from_attrs(request_t *request, fr_pair_list_t *vps,
int idx, fr_aka_sim_keys_t *keys, fr_aka_sim_vector_src_t *src)
{
int ret;
return 0;
}
-static int vector_umts_from_ki(request_t *request, fr_pair_t *vps, fr_aka_sim_keys_t *keys)
+static int vector_umts_from_ki(request_t *request, fr_pair_list_t *vps, fr_aka_sim_keys_t *keys)
{
fr_pair_t *ki_vp, *amf_vp, *sqn_vp, *version_vp;
/*
* Select the algorithm (default to Milenage)
*/
- version_vp = fr_pair_find_by_da(&vps, attr_sim_algo_version);
+ version_vp = fr_pair_find_by_da(vps, attr_sim_algo_version);
if (version_vp) version = version_vp->vp_uint32;
/*
/*
* Find the Ki VP and check its length
*/
- ki_vp = fr_pair_find_by_da(&vps, attr_sim_ki);
+ ki_vp = fr_pair_find_by_da(vps, attr_sim_ki);
if (!ki_vp) {
RDEBUG3("No &control.%s found, not generating quintuplets locally", attr_sim_ki->name);
return 1;
/*
* Find the Sequence Number VP or default to SQN = 2
*/
- sqn_vp = fr_pair_find_by_da(&vps, attr_sim_sqn);
+ sqn_vp = fr_pair_find_by_da(vps, attr_sim_sqn);
keys->sqn = sqn_vp ? sqn_vp->vp_uint64 : 2; /* 2 is the lowest valid SQN on our side */
/*
* Check if we have an AMF value
*/
- amf_vp = fr_pair_find_by_da(&vps, attr_sim_amf);
+ amf_vp = fr_pair_find_by_da(vps, attr_sim_amf);
if (amf_vp) {
if (amf_vp->vp_length != amf_size) {
REDEBUG("&control.%s has incorrect length, expected %zu bytes got %zu bytes",
/** Get one set of quintuplets from the request
*
*/
-static int vector_umts_from_quintuplets(request_t *request, fr_pair_t *vps, fr_aka_sim_keys_t *keys)
+static int vector_umts_from_quintuplets(request_t *request, fr_pair_list_t *vps, fr_aka_sim_keys_t *keys)
{
fr_pair_t *rand_vp = NULL, *xres_vp = NULL, *ck_vp = NULL, *ik_vp = NULL;
fr_pair_t *autn_vp = NULL, *sqn_vp = NULL, *ak_vp = NULL;
/*
* Fetch AUTN
*/
- autn_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_autn);
+ autn_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_autn);
if (!autn_vp) {
RDEBUG3("No &control.%s attribute found, not using UMTS quintuplets", attr_eap_aka_sim_autn->name);
return 1;
/*
* Fetch CK
*/
- ck_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_ck);
+ ck_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_ck);
if (!ck_vp) {
RDEBUG3("No &control.%s attribute found, not using UMTS quintuplets", attr_eap_aka_sim_ck->name);
return 1;
/*
* Fetch IK
*/
- ik_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_ik);
+ ik_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_ik);
if (!ik_vp) {
RDEBUG3("No &control.%s attribute found, not using UMTS quintuplets", attr_eap_aka_sim_ik->name);
return 1;
/*
* Fetch RAND
*/
- rand_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_rand);
+ rand_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_rand);
if (!rand_vp) {
RDEBUG3("No &control.%s attribute found, not using quintuplet derivation", attr_eap_aka_sim_rand->name);
return 1;
/*
* Fetch XRES
*/
- xres_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_xres);
+ xres_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_xres);
if (!xres_vp) {
RDEBUG3("No &control.%s attribute found, not using UMTS quintuplets", attr_eap_aka_sim_xres->name);
return 1;
/*
* Fetch (optional) AK
*/
- ak_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_ak);
+ ak_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_ak);
if (ak_vp && (ak_vp->vp_length != MILENAGE_AK_SIZE)) {
REDEBUG("&control.%s incorrect length. Expected "
STRINGIFY(MILENAGE_AK_SIZE) " bytes, got %zu bytes",
/*
* Fetch (optional) SQN
*/
- sqn_vp = fr_pair_find_by_da(&vps, attr_sim_sqn);
+ sqn_vp = fr_pair_find_by_da(vps, attr_sim_sqn);
if (sqn_vp && (sqn_vp->vp_length != MILENAGE_SQN_SIZE)) {
REDEBUG("&control.%s incorrect length. Expected "
STRINGIFY(MILENAGE_AK_SIZE) " bytes, got %zu bytes",
* - 0 Vector was retrieved OK and written to the specified index.
* - -1 Error retrieving vector from the specified src.
*/
-int fr_aka_sim_vector_umts_from_attrs(request_t *request, fr_pair_t *vps,
+int fr_aka_sim_vector_umts_from_attrs(request_t *request, fr_pair_list_t *vps,
fr_aka_sim_keys_t *keys, fr_aka_sim_vector_src_t *src)
{
int ret;
* - 0 on success.
* - -1 on validation failure.
*/
-int fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request_t *request, fr_pair_t *vps, fr_aka_sim_keys_t *keys)
+int fr_aka_sim_vector_gsm_umts_kdf_0_reauth_from_attrs(request_t *request, fr_pair_list_t *vps, fr_aka_sim_keys_t *keys)
{
fr_pair_t *counter_vp;
fr_pair_t *mk_vp;
* This is the *old* counter value increment
* by 1 to get the *new* counter value
*/
- counter_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_counter);
+ counter_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_counter);
if (!counter_vp) {
RDEBUG2("No &session-state.%s attribute found, can't calculate re-auth keys",
attr_eap_aka_sim_counter->name);
}
counter_vp->vp_uint16++;
- mk_vp = fr_pair_find_by_da(&vps, attr_session_data);
- if (!mk_vp) mk_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_mk);
+ mk_vp = fr_pair_find_by_da(vps, attr_session_data);
+ if (!mk_vp) mk_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_mk);
if (!mk_vp) {
RDEBUG2("Neither &session-state.%s or &session-state.%s attributes found, "
"can't calculate re-auth keys", attr_session_data->name, attr_eap_aka_sim_mk->name);
* - 0 on success.
* - -1 on validation failure.
*/
-int fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request_t *request, fr_pair_t *vps, fr_aka_sim_keys_t *keys)
+int fr_aka_sim_vector_umts_kdf_1_reauth_from_attrs(request_t *request, fr_pair_list_t *vps, fr_aka_sim_keys_t *keys)
{
fr_pair_t *counter_vp;
fr_pair_t *k_re_vp;
* This is the *old* counter value increment
* by 1 to get the *new* counter value
*/
- counter_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_counter);
+ counter_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_counter);
if (!counter_vp) {
RDEBUG2("No &session-state.%s attribute found, can't calculate re-auth keys",
attr_eap_aka_sim_counter->name);
}
counter_vp->vp_uint16++;
- k_re_vp = fr_pair_find_by_da(&vps, attr_session_data);
- if (!k_re_vp) k_re_vp = fr_pair_find_by_da(&vps, attr_eap_aka_sim_k_re);
+ k_re_vp = fr_pair_find_by_da(vps, attr_session_data);
+ if (!k_re_vp) k_re_vp = fr_pair_find_by_da(vps, attr_eap_aka_sim_k_re);
if (!k_re_vp) {
RDEBUG2("Neither &session-state.%s or &session-sate:%s attributes found, "
"can't calculate re-auth keys", attr_session_data->name, attr_eap_aka_sim_k_re->name);
* - <= 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_t *vps,
+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);
/** Entry point for protocol decoders
void fr_json_version_print(void);
-char *fr_json_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+char *fr_json_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format);
bool fr_json_format_verify(fr_json_format_t const *format, bool verbose);
* @param[in] format Formatting control, must be set.
* @return JSON object with the generated representation.
*/
-static json_object *json_object_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+static json_object *json_object_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
fr_cursor_t cursor;
MEM(obj = json_object_new_object());
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
char const *attr_name;
* @param[in] format Formatting control, must be set.
* @return JSON object with the generated representation.
*/
-static json_object *json_smplobj_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+static json_object *json_smplobj_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
fr_cursor_t cursor;
MEM(obj = json_object_new_object());
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
char const *attr_name;
* @param[in] format Formatting control, must be set.
* @return JSON object with the generated representation.
*/
-static struct json_object *json_array_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+static struct json_object *json_array_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
fr_cursor_t cursor;
seen_attributes = json_object_new_object();
}
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
char const *attr_name;
* @param[in] format Formatting control, must be set.
* @return JSON object with the generated representation.
*/
-static struct json_object *json_value_array_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+static struct json_object *json_value_array_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
fr_cursor_t cursor;
* This array format is very simple - just add all the
* attribute values to the array in order.
*/
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
struct json_object *value;
* @param[in] format Formatting control, must be set.
* @return JSON object with the generated representation.
*/
-static struct json_object *json_attr_array_afrom_pair_list(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps,
+static struct json_object *json_attr_array_afrom_pair_list(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
fr_cursor_t cursor;
/*
* Add all the attribute names to the array in order.
*/
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
char const *attr_name;
* @param[in] format Formatting control, can be NULL to use default format.
* @return JSON string representation of the value pairs
*/
-char *fr_json_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_t *vps,
+char *fr_json_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,
fr_json_format_t const *format)
{
struct json_object *obj = NULL;
/*
* map.c - Attribute mapping code.
*/
-int fr_ldap_map_getvalue(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request,
+int fr_ldap_map_getvalue(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request,
map_t const *map, void *uctx);
int fr_ldap_map_verify(map_t *map, void *instance);
*
* @see map_to_vp
*/
-int fr_ldap_map_getvalue(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, map_t const *map, void *uctx)
+int fr_ldap_map_getvalue(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, map_t const *map, void *uctx)
{
fr_ldap_result_t *self = uctx;
fr_pair_list_t head;
fr_pair_list_t args;
fr_redis_cluster_node_t *node = opaque;
+ fr_pair_list_init(&args);
node->addr = node->pending_addr;
if (node->cluster->triggers_enabled) {
if (node->cluster->trigger_args) MEM(fr_pair_list_copy(node->cluster, &args,
&node->cluster->trigger_args) >= 0);
- fr_pool_enable_triggers(pool, node->cluster->trigger_prefix, args);
+ fr_pool_enable_triggers(pool, node->cluster->trigger_prefix, &args);
fr_pair_list_free(&args);
}
fr_pair_list_t args;
CONF_SECTION *pool;
+ fr_pair_list_init(&args);
snprintf(buffer, sizeof(buffer), "%s [%i]", cluster->log_prefix, node->id);
pool = cf_section_find(cluster->module, "pool", NULL);
if (cluster->trigger_args) MEM(fr_pair_list_copy(cluster, &args, &cluster->trigger_args) >= 0);
- fr_pool_enable_triggers(node->pool, node->cluster->trigger_prefix, args);
+ fr_pool_enable_triggers(node->pool, node->cluster->trigger_prefix, &args);
fr_pair_list_free(&args);
}
bool triggers_enabled,
char const *log_prefix,
char const *trigger_prefix,
- fr_pair_t *trigger_args)
+ fr_pair_list_t *trigger_args)
{
uint8_t i;
uint16_t s;
fr_redis_cluster_t *cluster;
fr_assert(triggers_enabled || !trigger_prefix);
- fr_assert(triggers_enabled || !trigger_args);
+ fr_assert(triggers_enabled || !*trigger_args);
cluster = talloc_zero(NULL, fr_redis_cluster_t);
if (!cluster) {
/*
* Duplicate the trigger arguments.
*/
- if (trigger_args) MEM(fr_pair_list_copy(cluster, &cluster->trigger_args, &trigger_args) >= 0);
+ if (trigger_args) MEM(fr_pair_list_copy(cluster, &cluster->trigger_args, trigger_args) >= 0);
}
/*
bool enable_triggers,
char const *log_prefix,
char const *trigger_prefix,
- fr_pair_t *trigger_args);
+ fr_pair_list_t *trigger_args);
#ifdef __cplusplus
}
rlm_rcode_t final;
RDEBUG("Virtual server %s received request", cf_section_name2(request->server_cs));
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
username = fr_pair_find_by_num(&request->request_pairs, 0, FR_STRIPPED_USER_NAME);
if (!username) username = fr_pair_find_by_num(&request->request_pairs, 0, FR_USER_NAME);
packet->data_len);
if (received) {
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
} else {
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
}
*/
if (c->pass2_fixup == PASS2_PAIRCOMPARE) {
fr_pair_t *vp;
+ fr_pair_list_t vps;
+ fr_pair_list_init(&vps);
EVAL_DEBUG("CMP WITH PAIRCOMPARE");
fr_assert(tmpl_is_attr(map->lhs));
fr_value_box_copy(vp, &vp->data, rhs);
- rcode = paircmp(request, request->request_pairs, vp);
+ fr_pair_list_single_value(vps,*vp);
+ rcode = paircmp(request, &request->request_pairs, &vps);
rcode = (rcode == 0) ? 1 : 0;
talloc_free(vp);
goto finish;
#define MAX_ARGV (256)
-static void fr_exec_pair_to_env(request_t *request, fr_pair_t *input_pairs, char **envp, size_t envlen, bool shell_escape)
+static void fr_exec_pair_to_env(request_t *request, fr_pair_list_t *input_pairs, char **envp, size_t envlen, bool shell_escape)
{
char *p;
size_t i;
* hold mutexes. They might be locked when we fork,
* and will remain locked in the child.
*/
- for (vp = fr_cursor_init(&cursor, &input_pairs), i = 0;
+ for (vp = fr_cursor_init(&cursor, input_pairs), i = 0;
vp && (i < envlen - 1);
vp = fr_cursor_next(&cursor)) {
size_t n;
*/
pid_t radius_start_program(char const *cmd, request_t *request, bool exec_wait,
int *input_fd, int *output_fd,
- fr_pair_t *input_pairs, bool shell_escape)
+ fr_pair_list_t *input_pairs, bool shell_escape)
{
int to_child[2] = {-1, -1};
int from_child[2] = {-1, -1};
* - exit code if exec_wait!=0.
* - -1 on failure.
*/
-int radius_exec_program(TALLOC_CTX *ctx, char *out, size_t outlen, fr_pair_t **output_pairs,
- request_t *request, char const *cmd, fr_pair_t *input_pairs,
+int radius_exec_program(TALLOC_CTX *ctx, char *out, size_t outlen, fr_pair_list_t *output_pairs,
+ request_t *request, char const *cmd, fr_pair_list_t *input_pairs,
bool exec_wait, bool shell_escape, fr_time_delta_t timeout)
{
* would allow finer-grained control over the attributes to put into
* the environment.
*/
-int fr_exec_nowait(request_t *request, fr_value_box_t *vb, fr_pair_t *env_pairs)
+int fr_exec_nowait(request_t *request, fr_value_box_t *vb, fr_pair_list_t *env_pairs)
{
int argc;
char **envp;
/*
* Get the environment variables.
*/
- if (env_pairs) {
+ if (*env_pairs) {
MEM(envp = talloc_zero_array(request, char *, MAX_ENVP));
fr_exec_pair_to_env(request, env_pairs, envp, MAX_ENVP, true);
} else {
* would allow finer-grained control over the attributes to put into
* the environment.
*/
-int fr_exec_wait_start(request_t *request, fr_value_box_t *vb, fr_pair_t *env_pairs, pid_t *pid_p, int *input_fd, int *output_fd)
+int fr_exec_wait_start(request_t *request, fr_value_box_t *vb, fr_pair_list_t *env_pairs, pid_t *pid_p, int *input_fd, int *output_fd)
{
int argc;
char **envp;
#endif
pid_t radius_start_program(char const *cmd, request_t *request, bool exec_wait,
int *input_fd, int *output_fd,
- fr_pair_t *input_pairs, bool shell_escape);
+ fr_pair_list_t *input_pairs, bool shell_escape);
int radius_readfrom_program(int fd, pid_t pid, fr_time_delta_t timeout,
char *answer, int left);
-int radius_exec_program(TALLOC_CTX *ctx, char *out, size_t outlen, fr_pair_t **output_pairs,
- request_t *request, char const *cmd, fr_pair_t *input_pairs,
+int radius_exec_program(TALLOC_CTX *ctx, char *out, size_t outlen, fr_pair_list_t *output_pairs,
+ request_t *request, char const *cmd, fr_pair_list_t *input_pairs,
bool exec_wait, bool shell_escape, fr_time_delta_t timeout) CC_HINT(nonnull (5, 6));
-int fr_exec_nowait(request_t *request, fr_value_box_t *vb, fr_pair_t *env_pairs);
+int fr_exec_nowait(request_t *request, fr_value_box_t *vb, fr_pair_list_t *env_pairs);
-int fr_exec_wait_start(request_t *request, fr_value_box_t *vb, fr_pair_t *env_pairs, pid_t *pid_p, int *input_fd, int *output_fd);
+int fr_exec_wait_start(request_t *request, fr_value_box_t *vb, fr_pair_list_t *env_pairs, pid_t *pid_p, int *input_fd, int *output_fd);
void fr_exec_waitpid(pid_t pid);
fr_dict_attr_t const *da;
fr_cursor_t cursor;
+ fr_pair_list_init(&args);
fr_assert(ef != NULL);
fr_assert(name_suffix != NULL);
return;
}
- args = ef->trigger_args;
+ fr_pair_list_copy(request, &args, &ef->trigger_args);
fr_cursor_init(&cursor, &args);
MEM(vp = fr_pair_afrom_da(NULL, da));
fr_cursor_prepend(&cursor, vp);
snprintf(name, sizeof(name), "%s.%s", ef->trigger_prefix, name_suffix);
- trigger_exec(request, ef->conf, name, false, args);
+ trigger_exec(request, ef->conf, name, false, &args);
- talloc_free(vp);
+ fr_pair_list_free(&args);
}
* @param[in] trigger_args to make available in any triggers executed by the exfile api.
* Exfile-File is automatically added to this list.
*/
-void exfile_enable_triggers(exfile_t *ef, CONF_SECTION *conf, char const *trigger_prefix, fr_pair_t *trigger_args)
+void exfile_enable_triggers(exfile_t *ef, CONF_SECTION *conf, char const *trigger_prefix, fr_pair_list_t *trigger_args)
{
talloc_const_free(ef->trigger_prefix);
MEM(ef->trigger_prefix = trigger_prefix ? talloc_typed_strdup(ef, trigger_prefix) : "");
if (!trigger_args) return;
- (void) fr_pair_list_copy(ef, &ef->trigger_args, &trigger_args);
+ (void) fr_pair_list_copy(ef, &ef->trigger_args, trigger_args);
}
exfile_t *exfile_init(TALLOC_CTX *ctx, uint32_t entries, uint32_t idle, bool locking);
void exfile_enable_triggers(exfile_t *ef, CONF_SECTION *cs, char const *trigger_prefix,
- fr_pair_t *trigger_args);
+ fr_pair_list_t *trigger_args);
int exfile_open(exfile_t *lf, request_t *request, char const *filename,
mode_t permissions);
*
* @param[in] lvl Debug lvl (1-4).
* @param[in] request to read logging params from.
- * @param[in] parent of vp to print, may be NULL.
- * @param[in] vp to print.
+ * @param[in] parent of vps to print, may be NULL.
+ * @param[in] vps to print.
* @param[in] prefix (optional).
*/
void log_request_pair_list(fr_log_lvl_t lvl, request_t *request,
- fr_pair_t const *parent, fr_pair_t const *vp, char const *prefix)
+ fr_pair_t const *parent, fr_pair_list_t const *vps, char const *prefix)
{
fr_cursor_t cursor;
- fr_pair_t *m_vp;
+ fr_pair_list_t *m_vp;
+ fr_pair_t *vp;
fr_dict_attr_t const *parent_da = NULL;
- if (!vp || !request->log.dst) return;
+ if (!*vps || !request->log.dst) return;
if (!log_rdebug_enabled(lvl, request)) return;
- memcpy(&m_vp, &vp, sizeof(m_vp));
+ memcpy(&m_vp, &vps, sizeof(m_vp));
RINDENT();
- for (vp = fr_cursor_init(&cursor, &m_vp);
+ for (vp = fr_cursor_init(&cursor, m_vp);
vp;
vp = fr_cursor_next(&cursor)) {
VP_VERIFY(vp);
RDEBUGX(lvl, "%s%pV {", prefix ? prefix : "",
fr_box_strvalue_len(fr_sbuff_start(oid_buff), fr_sbuff_used(oid_buff)));
- log_request_pair_list(lvl, request, vp, (fr_pair_t *) vp->vp_group, prefix);
+ log_request_pair_list(lvl, request, vp, (fr_pair_list_t *) vp->vp_group, prefix);
RDEBUGX(lvl, "%s}", prefix ? prefix : ""); /* don't add extra space between closing brace and prefix */
continue;
}
*
* @param[in] lvl Debug lvl (1-4).
* @param[in] request to read logging params from.
- * @param[in] parent of vp to print, may be NULL.
- * @param[in] vp to print.
+ * @param[in] parent of vps to print, may be NULL.
+ * @param[in] vps to print.
* @param[in] prefix (optional).
*/
void log_request_proto_pair_list(fr_log_lvl_t lvl, request_t *request,
- fr_pair_t const *parent, fr_pair_t const *vp, char const *prefix)
+ fr_pair_t const *parent, fr_pair_list_t const *vps, char const *prefix)
{
fr_cursor_t cursor;
- fr_pair_t *m_vp;
fr_dict_attr_t const *parent_da = NULL;
+ fr_pair_t *vp;
- if (!vp || !request->log.dst) return;
+ if (!*vps || !request->log.dst) return;
if (!log_rdebug_enabled(lvl, request)) return;
- memcpy(&m_vp, &vp, sizeof(m_vp));
-
RINDENT();
- for (vp = fr_cursor_init(&cursor, &m_vp);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
VP_VERIFY(vp);
RDEBUGX(lvl, "%s%pV {", prefix ? prefix : "",
fr_box_strvalue_len(fr_sbuff_start(oid_buff), fr_sbuff_used(oid_buff)));
- log_request_proto_pair_list(lvl, request, vp, (fr_pair_t *) vp->vp_group, prefix);
+ log_request_proto_pair_list(lvl, request, vp, (fr_pair_list_t *) vp->vp_group, prefix);
RDEBUGX(lvl, "%s}", prefix ? prefix : "");
continue;
}
CC_HINT(format (printf, 6, 7)) CC_HINT(nonnull (3));
void log_request_pair_list(fr_log_lvl_t lvl, request_t *request,
- fr_pair_t const *parent, fr_pair_t const *vp, char const *prefix)
+ fr_pair_t const *parent, fr_pair_list_t const *vps, char const *prefix)
CC_HINT(nonnull(2));
void log_request_proto_pair_list(fr_log_lvl_t lvl, request_t *request,
- fr_pair_t const *parent, fr_pair_t const *vp, char const *prefix)
+ fr_pair_t const *parent, fr_pair_list_t const *vp, char const *prefix)
CC_HINT(nonnull(2));
void log_request_marker(fr_log_type_t type, fr_log_lvl_t lvl, request_t *request,
* - 0 on success.
* - -1 on failure.
*/
-static int map_exec_to_vp(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, map_t const *map)
+static int map_exec_to_vp(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, map_t const *map)
{
int result;
char *expanded = NULL;
*/
result = radius_exec_program(ctx, answer, sizeof(answer),
tmpl_is_list(map->lhs) ? &output_pairs : NULL,
- request, map->rhs->name, input_pairs ? *input_pairs : NULL,
+ request, map->rhs->name, input_pairs ? input_pairs : NULL,
true, true, fr_time_delta_from_sec(EXEC_TIMEOUT));
talloc_free(expanded);
if (result != 0) {
case TMPL_TYPE_ATTR:
{
fr_pair_t *vp;
+ fr_pair_list_t vps;
+ fr_pair_list_init(&vps);
MEM(vp = fr_pair_afrom_da(ctx, tmpl_da(map->lhs)));
vp->op = map->op;
if (fr_pair_value_from_str(vp, answer, -1, '"', false) < 0) {
fr_pair_list_free(&vp);
return -2;
}
- *out = vp;
+ fr_pair_add(&vps, vp);
+ *out = vps;
return 0;
}
* - 0 on success.
* - -1 on failure.
*/
-int map_to_vp(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, map_t const *map, UNUSED void *uctx)
+int map_to_vp(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, map_t const *map, UNUSED void *uctx)
{
int rcode = 0;
fr_pair_t *vp = NULL, *n;
fr_pair_list_t found;
+ fr_pair_list_t vps;
request_t *context = request;
fr_cursor_t cursor;
ssize_t slen;
char *str;
fr_pair_list_init(&found);
+ fr_pair_list_init(&vps);
*out = NULL;
MAP_VERIFY(map);
goto error;
}
n->op = map->op;
- *out = n;
+ fr_pair_add(&vps, n);
+ *out = vps;
break;
case TMPL_TYPE_UNRESOLVED:
goto error;
}
n->op = map->op;
- *out = n;
+ fr_pair_add(&vps, n);
+ *out = vps;
break;
case TMPL_TYPE_ATTR:
}
}
n->op = map->op;
- *out = n;
+ fr_pair_add(&vps, n);
+ *out = vps;
MAP_VERIFY(map);
break;
#endif
typedef int (*map_validate_t)(map_t *map, void *ctx);
-typedef int (*radius_map_getvalue_t)(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request,
+typedef int (*radius_map_getvalue_t)(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request,
map_t const *map, void *uctx);
int map_afrom_cp(TALLOC_CTX *ctx, map_t **out, CONF_PAIR *cp,
void map_sort(map_t **maps, fr_cmp_t cmp);
-int map_to_vp(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request,
+int map_to_vp(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request,
map_t const *map, void *uctx) CC_HINT(nonnull (2,3,4));
int map_list_mod_apply(request_t *request, vp_list_mod_t const *vlm);
uint32_t max_idle,
bool locking,
char const *trigger_prefix,
- fr_pair_t *trigger_args)
+ fr_pair_list_t *trigger_args)
{
char trigger_prefix_buff[128];
exfile_t *handle;
fr_pool_connection_alive_t a,
char const *log_prefix,
char const *trigger_prefix,
- fr_pair_t *trigger_args)
+ fr_pair_list_t *trigger_args)
{
CONF_SECTION *cs, *mycs;
char log_prefix_buff[128];
fr_pool_connection_alive_t a,
char const *log_prefix,
char const *trigger_prefix,
- fr_pair_t *trigger_args);
+ fr_pair_list_t *trigger_args);
exfile_t *module_exfile_init(TALLOC_CTX *ctx,
CONF_SECTION *module,
uint32_t max_entries,
uint32_t max_idle,
bool locking,
char const *trigger_prefix,
- fr_pair_t *trigger_args);
+ fr_pair_list_t *trigger_args);
/** @} */
/** @name Helper functions
*/
static int prefix_suffix_cmp(UNUSED void *instance,
request_t *request,
- fr_pair_t *req,
- fr_pair_t *check,
- fr_pair_t *check_list)
+ fr_pair_list_t *request_list,
+ fr_pair_t *check_item,
+ fr_pair_list_t *check_list)
{
fr_pair_t *vp;
char const *name;
if (!username) username = fr_pair_find_by_da(&request->request_pairs, attr_user_name);
if (!username) return -1;
- VP_VERIFY(check);
+ VP_VERIFY(check_item);
name = username->vp_strvalue;
- RDEBUG3("Comparing name \"%s\" and check value \"%pV\"", name, &check->data);
+ RDEBUG3("Comparing name \"%s\" and check value \"%pV\"", name, &check_item->data);
- len = strlen(check->vp_strvalue);
+ len = strlen(check_item->vp_strvalue);
- if (check->da == attr_prefix) {
- ret = strncmp(name, check->vp_strvalue, len);
+ if (check_item->da == attr_prefix) {
+ ret = strncmp(name, check_item->vp_strvalue, len);
if (ret == 0)
strlcpy(rest, name + len, sizeof(rest));
- } else if (check->da == attr_suffix) {
+ } else if (check_item->da == attr_suffix) {
namelen = strlen(name);
if (namelen >= len) {
- ret = strcmp(name + namelen - len, check->vp_strvalue);
+ ret = strcmp(name + namelen - len, check_item->vp_strvalue);
if (ret == 0) strlcpy(rest, name, namelen - len + 1);
}
}
/*
* If Strip-User-Name == No, then don't do any more.
*/
- vp = fr_pair_find_by_da(&check_list, attr_strip_user_name);
+ vp = fr_pair_find_by_da(check_list, attr_strip_user_name);
if (vp && !vp->vp_uint32) return ret;
/*
* See where to put the stripped user name.
*/
- vp = fr_pair_find_by_da(&check_list, attr_stripped_user_name);
+ vp = fr_pair_find_by_da(check_list, attr_stripped_user_name);
if (!vp) {
/*
* If "request" is NULL, then the memory will be
* lost!
*/
MEM(vp = fr_pair_afrom_da(request->packet, attr_stripped_user_name));
- fr_pair_add(&req, vp);
+ fr_pair_add(request_list, vp);
}
fr_pair_value_strdup(vp, rest);
*/
static int packet_cmp(UNUSED void *instance,
request_t *request,
- UNUSED fr_pair_t *req,
- fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+ UNUSED fr_pair_list_t *request_list,
+ fr_pair_t *check_item,
+ UNUSED fr_pair_list_t *check_list)
{
- VP_VERIFY(check);
+ VP_VERIFY(check_item);
- if (request->packet->code == check->vp_uint32) return 0;
+ if (request->packet->code == check_item->vp_uint32) return 0;
return 1;
}
*/
static int generic_cmp(UNUSED void *instance,
request_t *request,
- fr_pair_t *req,
- fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+ UNUSED fr_pair_list_t *request_list,
+ fr_pair_t *check_item,
+ UNUSED fr_pair_list_t *check_list)
{
- VP_VERIFY(check);
+ VP_VERIFY(check_item);
- if ((check->op != T_OP_REG_EQ) && (check->op != T_OP_REG_NE)) {
+ if ((check_item->op != T_OP_REG_EQ) && (check_item->op != T_OP_REG_NE)) {
int rcode;
char name[1024];
char value[1024];
fr_pair_t *vp;
- snprintf(name, sizeof(name), "%%{%s}", check->da->name);
+ snprintf(name, sizeof(name), "%%{%s}", check_item->da->name);
if (xlat_eval(value, sizeof(value), request, name, NULL, NULL) < 0) return 0;
- MEM(vp = fr_pair_afrom_da(req, check->da));
- vp->op = check->op;
+ MEM(vp = fr_pair_afrom_da(request, check_item->da));
+ vp->op = check_item->op;
fr_pair_value_from_str(vp, value, -1, '"', false);
/*
* Paircmp returns 0 for failed comparison, 1 for succeeded -1 for error.
*/
- rcode = fr_pair_cmp(check, vp);
+ rcode = fr_pair_cmp(check_item, vp);
/*
* We're being called from paircmp_func,
* returns 0 for matched, and 1 for didn't match.
*/
rcode = !rcode;
- fr_pair_list_free(&vp);
+ talloc_free(vp);
return rcode;
}
/*
* Will do the xlat for us
*/
- return paircmp_pairs(request, check, NULL);
+ return paircmp_pairs(request, check_item, NULL);
}
/** See what attribute we want to compare with.
return 0;
}
-/** Compare check and vp. May call the attribute comparison function.
+/** Compare check_item and vp. May call the attribute comparison function.
*
* Unlike paircmp_pairs() this function will call any attribute-specific
- * comparison functions registered.
+ * comparison functions registered. vp to be matched is request_item or
+ * found in check_list or looked up from external sources depending on the
+ * comparison function called.
*
* @param[in] request Current request.
+ * @param[in] request_item item to compare.
* @param[in] request_list list pairs.
- * @param[in] check item to compare.
+ * @param[in] check_item item to compare.
* @param[in] check_list list.
* @return
- * - 0 if check and vp are equal.
- * - -1 if vp value is less than check value.
- * - 1 is vp value is more than check value.
+ * - 0 if check_item and vp are equal.
+ * - -1 if vp value is less than check_item value.
+ * - 1 is vp value is more than check_item value.
*/
static int paircmp_func(request_t *request,
- fr_pair_t *request_list,
- fr_pair_t *check,
- fr_pair_t *check_list)
+ fr_pair_t *request_item,
+ fr_pair_list_t *request_list,
+ fr_pair_t *check_item,
+ fr_pair_list_t *check_list)
{
paircmp_t *c;
- VP_VERIFY(check);
+ VP_VERIFY(check_item);
/*
* Check for =* and !* and return appropriately
*/
- if (check->op == T_OP_CMP_TRUE) return 0;
- if (check->op == T_OP_CMP_FALSE) return 1;
+ if (check_item->op == T_OP_CMP_TRUE) return 0;
+ if (check_item->op == T_OP_CMP_FALSE) return 1;
/*
* See if there is a special compare function.
* FIXME: use new RB-Tree code.
*/
for (c = cmp; c; c = c->next) {
- if (c->da == check->da) {
- return (c->compare)(c->instance, request, request_list, check, check_list);
+ if (c->da == check_item->da) {
+ return (c->compare)(c->instance, request, request_list, check_item, check_list);
}
}
if (!request) return -1; /* doesn't exist, don't compare it */
- return paircmp_pairs(request, check, request_list);
+ return paircmp_pairs(request, check_item, request_item);
}
/** Compare two pair lists except for the password information.
*
- * For every element in "check" at least one matching copy must be present
- * in "reply".
+ * For every element in "check_list" at least one matching copy must be present
+ * in "request_list".
*
* @param[in] request Current request.
* @param[in] request_list request valuepairs.
- * @param[in] check Check/control valuepairs.
+ * @param[in] check_list Check/control valuepairs.
* @return 0 on match.
*/
int paircmp(request_t *request,
- fr_pair_t *request_list,
- fr_pair_t *check)
+ fr_pair_list_t *request_list,
+ fr_pair_list_t *check_list)
{
fr_cursor_t cursor;
+ fr_cursor_t request_cursor;
fr_pair_t *check_item;
fr_pair_t *auth_item;
fr_dict_attr_t const *from;
int compare;
bool first_only;
- for (check_item = fr_cursor_init(&cursor, &check);
+ for (check_item = fr_cursor_init(&cursor, check_list);
check_item;
check_item = fr_cursor_next(&cursor)) {
/*
WARN("Are you sure you don't mean Password.Cleartext?");
WARN("See \"man rlm_pap\" for more information");
}
- if (fr_pair_find_by_num(&request_list, 0, FR_USER_PASSWORD) == NULL) continue;
+ if (fr_pair_find_by_num(request_list, 0, FR_USER_PASSWORD) == NULL) continue;
}
/*
*/
first_only = other_attr(check_item->da, &from);
- auth_item = request_list;
+ auth_item = fr_cursor_init(&request_cursor, request_list);
try_again:
if (!first_only) {
while (auth_item != NULL) {
if ((auth_item->da == from) || (!from)) break;
- auth_item = auth_item->next;
+ auth_item = fr_cursor_next(&request_cursor);
}
}
/*
* OK it is present now compare them.
*/
- compare = paircmp_func(request, auth_item, check_item, check);
+ compare = paircmp_func(request, auth_item, request_list, check_item, check_list);
switch (check_item->op) {
case T_OP_EQ:
default:
* another of the same attribute, which DOES match.
*/
if ((result != 0) && (!first_only)) {
- auth_item = auth_item->next;
+ auth_item = fr_cursor_next(&request_cursor);
result = 0;
goto try_again;
}
#include <freeradius-devel/util/pair.h>
/* for paircmp_register */
-typedef int (*RAD_COMPARE_FUNC)(void *instance, request_t *,fr_pair_t *, fr_pair_t *, fr_pair_t *);
+typedef int (*RAD_COMPARE_FUNC)(void *instance, request_t *,fr_pair_list_t *, fr_pair_t *, fr_pair_list_t *);
int paircmp_pairs(request_t *request, fr_pair_t *check, fr_pair_t *vp);
-int paircmp(request_t *request, fr_pair_t *req_list, fr_pair_t *check);
+int paircmp(request_t *request, fr_pair_list_t *request_list, fr_pair_list_t *check_list);
int paircmp_find(fr_dict_attr_t const *da);
* only fr_pair_list_copy() those attributes that we're really going to
* use.
*/
-void radius_pairmove(request_t *request, fr_pair_t **to, fr_pair_t *from, bool do_xlat)
+void radius_pairmove(request_t *request, fr_pair_list_t *to, fr_pair_list_t *from, bool do_xlat)
{
int i, j, count, from_count, to_count, tailto;
fr_cursor_t cursor;
* the matching attributes are deleted.
*/
count = 0;
- for (vp = fr_cursor_init(&cursor, &from); vp; vp = fr_cursor_next(&cursor)) count++;
+ for (vp = fr_cursor_init(&cursor, from); vp; vp = fr_cursor_next(&cursor)) count++;
from_list = talloc_array(request, fr_pair_t *, count);
for (vp = fr_cursor_init(&cursor, to); vp; vp = fr_cursor_next(&cursor)) count++;
* chains.
*/
from_count = 0;
- for (vp = from; vp != NULL; vp = next) {
+ for (vp = *from; vp != NULL; vp = next) {
next = vp->next;
from_list[from_count++] = vp;
vp->next = NULL;
extern "C" {
#endif
-void radius_pairmove(request_t *request, fr_pair_t **to, fr_pair_t *from, bool do_xlat) CC_HINT(nonnull);
+void radius_pairmove(request_t *request, fr_pair_list_t *to, fr_pair_list_t *from, bool do_xlat) CC_HINT(nonnull);
#ifdef __cplusplus
}
if (!pool->triggers_enabled) return;
snprintf(name, sizeof(name), "%s.%s", pool->trigger_prefix, event);
- trigger_exec(request, pool->cs, name, true, pool->trigger_args);
+ trigger_exec(request, pool->cs, name, true, &pool->trigger_args);
}
/** Find a connection handle in the connection list
* Trigger args will be copied, input trigger_args should be freed
* if necessary.
*/
-void fr_pool_enable_triggers(fr_pool_t *pool, char const *trigger_prefix, fr_pair_t *trigger_args)
+void fr_pool_enable_triggers(fr_pool_t *pool, char const *trigger_prefix, fr_pair_list_t *trigger_args)
{
pool->triggers_enabled = true;
if (!trigger_args) return;
- MEM(fr_pair_list_copy(pool, &pool->trigger_args, &trigger_args) >= 0);
+ MEM(fr_pair_list_copy(pool, &pool->trigger_args, trigger_args) >= 0);
}
/** Create a new connection pool
copy = fr_pool_init(ctx, pool->cs, opaque, pool->create, pool->alive, pool->log_prefix);
if (!copy) return NULL;
- if (pool->trigger_prefix) fr_pool_enable_triggers(copy, pool->trigger_prefix, pool->trigger_args);
+ if (pool->trigger_prefix) fr_pool_enable_triggers(copy, pool->trigger_prefix, &pool->trigger_args);
return copy;
}
* Pool get/set
*/
void fr_pool_enable_triggers(fr_pool_t *pool,
- char const *trigger_prefix, fr_pair_t *vp);
+ char const *trigger_prefix, fr_pair_list_t *trigger_args);
fr_time_delta_t fr_pool_timeout(fr_pool_t *pool);
if (request->state) {
RDEBUG2("Restored &session-state");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, request->state, "&session-state.");
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &request->state, "&session-state.");
}
/*
if (request->state) {
RDEBUG2("Saving &session-state");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, request->state, "&session-state.");
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &request->state, "&session-state.");
}
vp = fr_pair_find_by_da(&request->request_pairs, state->da);
*
*/
static inline CC_HINT(always_inline)
-void _tmpl_cursor_tlv_init(TALLOC_CTX *list_ctx, fr_pair_t **list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
+void _tmpl_cursor_tlv_init(TALLOC_CTX *list_ctx, fr_pair_list_t *list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
{
tmpl_attr_t *prev = fr_dlist_prev(&cc->vpt->data.attribute.ar, ar);
*
*/
static inline CC_HINT(always_inline)
-void _tmpl_cursor_group_init(TALLOC_CTX *list_ctx, fr_pair_t **list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
+void _tmpl_cursor_group_init(TALLOC_CTX *list_ctx, fr_pair_list_t *list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
{
tmpl_cursor_nested_t *ns;
*
*/
static inline CC_HINT(always_inline)
-void _tmpl_cursor_leaf_init(TALLOC_CTX *list_ctx, fr_pair_t **list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
+void _tmpl_cursor_leaf_init(TALLOC_CTX *list_ctx, fr_pair_list_t *list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
{
tmpl_cursor_nested_t *ns = &cc->leaf;
}
static inline CC_HINT(always_inline)
-void _tmpl_cursor_init(TALLOC_CTX *list_ctx, fr_pair_t **list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
+void _tmpl_cursor_init(TALLOC_CTX *list_ctx, fr_pair_list_t *list, tmpl_attr_t const *ar, tmpl_cursor_ctx_t *cc)
{
if (fr_dlist_next(&cc->vpt->data.attribute.ar, ar)) switch (ar->ar_da->type) {
case FR_TYPE_TLV:
* - -3 if context could not be found (no parent #request_t available).
* - -4 on memory allocation error.
*/
-int tmpl_copy_pairs(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, tmpl_t const *vpt)
+int tmpl_copy_pairs(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
{
fr_pair_t *vp;
fr_cursor_t from, to;
* - -3 if context could not be found (no parent #request_t available).
* - -4 on memory allocation error.
*/
-int tmpl_copy_pair_children(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, tmpl_t const *vpt)
+int tmpl_copy_pair_children(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, tmpl_t const *vpt)
{
fr_pair_t *vp;
fr_cursor_t from;
* @return - 0 on success.
* - -1 on failure.
*/
-int trigger_exec(request_t *request, CONF_SECTION const *cs, char const *name, bool rate_limit, fr_pair_t *args)
+int trigger_exec(request_t *request, CONF_SECTION const *cs, char const *name, bool rate_limit, fr_pair_list_t *args)
{
CONF_SECTION const *subcs;
int trigger_exec_init(CONF_SECTION const *cs);
int trigger_exec(request_t *request, CONF_SECTION const *cs,
- char const *name, bool quench, fr_pair_t *args)
+ char const *name, bool quench, fr_pair_list_t *args)
CC_HINT(nonnull (3));
void trigger_exec_free(void);
/*
* Print out all the pairs we have so far
*/
- log_request_pair_list(L_DBG_LVL_2, request, NULL, cert_vps, "&session-state.");
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &cert_vps, "&session-state.");
/*
* cert_vps have a different talloc parent, so we
RDEBUG2("Verifying client certificate with cmd");
if (radius_exec_program(request, NULL, 0, NULL, request, conf->verify_client_cert_cmd,
- request->request_pairs, true, true, fr_time_delta_from_sec(EXEC_TIMEOUT)) != 0) {
+ &request->request_pairs, true, true, fr_time_delta_from_sec(EXEC_TIMEOUT)) != 0) {
REDEBUG("Client certificate CN \"%s\" failed external verification", common_name);
my_ok = 0;
} else {
*/
unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, fr_value_box_t **out, int *status,
request_t *request, tmpl_t const *vpt,
- fr_pair_t *vps,
+ fr_pair_list_t *vps,
unlang_module_resume_t resume,
unlang_module_signal_t signal, void *rctx)
{
unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, fr_value_box_t **out, int *status,
request_t *request, tmpl_t const *exp,
- fr_pair_t *vps,
+ fr_pair_list_t *vps,
unlang_module_resume_t resume,
unlang_module_signal_t signal, void *rctx);
state->session.unique_int);
RDEBUG2("Creating subrequest (%s)", child->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, child->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &child->request_pairs, NULL);
frame->process = unlang_subrequest_process;
return unlang_subrequest_process(p_result, request);
* @param[in] vps the input VPs. May be NULL. Used only for #TMPL_TYPE_EXEC
* @param[out] status where the status of exited programs will be stored.
*/
-int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_t **out, request_t *request, tmpl_t const *tmpl, fr_pair_t *vps, int *status)
+int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_t **out, request_t *request, tmpl_t const *tmpl, fr_pair_list_t *vps, int *status)
{
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame;
typedef rlm_rcode_t (*fr_unlang_tmpl_resume_t)(request_t *request, void *rctx);
int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_t **out,
- request_t *request, tmpl_t const *tmpl, fr_pair_t *vps, int *status)
+ request_t *request, tmpl_t const *tmpl, fr_pair_list_t *vps, int *status)
CC_HINT(warn_unused_result);
#ifdef __cplusplus
fr_event_timer_t const *ev; //!< for timing out the child
fr_event_pid_t const *ev_pid; //!< for cleaning up the process
- fr_pair_list_t vps; //!< input VPs
+ fr_pair_list_t *vps; //!< input VPs
char *buffer; //!< for reading the answer
char *ptr; //!< where in the buffer we are writing to
int status; //!< return code of the program
* - The first item returned by the iterator.
*/
#define fr_cursor_talloc_iter_init(_cursor, _head, _iter, _uctx, _type) \
- _fr_cursor_init(_cursor, (void **)_head, offsetof(__typeof__(**(_head)), next), _iter, _uctx, #_type)
+ _fr_cursor_init(_cursor, (void * const *)_head, offsetof(__typeof__(**(_head)), next), _iter, _uctx, #_type)
/** Initialise a cursor with a custom iterator
*
*
* @hidecallergraph
*/
-fr_pair_t *fr_pair_find_by_da(fr_pair_list_t *head, fr_dict_attr_t const *da)
+fr_pair_t *fr_pair_find_by_da(fr_pair_list_t const *head, fr_dict_attr_t const *da)
{
fr_pair_t *vp;
fr_pair_list_t * : NULL, \
default : (fr_pair_list_t *) NULL))
+/*
+ * Temporary macro to point the head of a pair_list to a specific vp
+ */
+#define fr_pair_list_set_head(_list, _vp) (_list = &_vp)
+
+/*
+ * Temporary macro to point a pair_list to a single vp
+ */
+#define fr_pair_list_single_value(_list, _vp) (_list = &_vp)
+
/* Allocation and management */
fr_pair_t *fr_pair_alloc_null(TALLOC_CTX *ctx);
/**
* @hidecallergraph
*/
-fr_pair_t *fr_pair_find_by_da(fr_pair_list_t *head, fr_dict_attr_t const *da);
+fr_pair_t *fr_pair_find_by_da(fr_pair_list_t const *head, fr_dict_attr_t const *da);
fr_pair_t *fr_pair_find_by_num(fr_pair_list_t *head, unsigned int vendor, unsigned int attr);
fr_arp_packet_codes[request->packet->code],
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
return 0;
return 1;
}
- slen = fr_arp_encode(&FR_DBUFF_TMP(buffer, buffer_len), request->packet->data, request->reply_pairs);
+ slen = fr_arp_encode(&FR_DBUFF_TMP(buffer, buffer_len), request->packet->data, &request->reply_pairs);
if (slen <= 0) {
RPEDEBUG("Failed encoding reply");
return -1;
request->reply->code,
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
return slen;
case REQUEST_INIT:
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Received ARP %s", fr_arp_packet_codes[request->packet->code]);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
request->component = "arp";
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Sending %s", fr_arp_packet_codes[request->reply->code]);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
break;
RDEBUG("Received %s ID %i",
fr_dict_enum_name_by_value(inst->attr_packet_type, fr_box_uint32(request->packet->code)),
request->packet->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
request->component = "radius";
request->reply->id);
}
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
break;
default:
}
data_len = fr_dhcpv4_encode(buffer, buffer_len, original, request->reply->code,
- ntohl(original->xid), request->reply_pairs);
+ ntohl(original->xid), &request->reply_pairs);
if (data_len < 0) {
RPEDEBUG("Failed encoding DHCPV4 reply");
return -1;
REXDENT();
if (received || request->parent) {
- log_request_pair_list(L_DBG_LVL_1, request, NULL, packet->vps, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &packet->vps, NULL);
} else {
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, packet->vps, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &packet->vps, NULL);
}
}
data_len = fr_dhcpv6_encode(&FR_DBUFF_TMP(buffer, buffer_len),
request->packet->data, request->packet->data_len,
- request->reply->code, request->reply_pairs);
+ request->reply->code, &request->reply_pairs);
if (data_len < 0) {
RPEDEBUG("Failed encoding DHCPv6 reply");
return -1;
);
if (received || request->parent) {
- log_request_pair_list(L_DBG_LVL_1, request, NULL, packet->vps, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &packet->vps, NULL);
} else {
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, packet->vps, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &packet->vps, NULL);
}
}
request->packet->data_len,
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
if (!inst->io.app_io->decode) return 0;
data_len = fr_radius_encode(buffer, buffer_len, request->packet->data,
client->secret, talloc_array_length(client->secret) - 1,
- request->reply->code, request->reply->id, request->reply_pairs);
+ request->reply->code, request->reply->id, &request->reply_pairs);
if (data_len < 0) {
RPEDEBUG("Failed encoding RADIUS reply");
return -1;
data_len,
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
return data_len;
case REQUEST_INIT:
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Received %s ID %i", fr_packet_codes[request->packet->code], request->packet->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
request->component = "radius";
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Sending %s ID %i", fr_packet_codes[request->reply->code], request->reply->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
break;
case REQUEST_INIT:
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Received %s ID %i", fr_packet_codes[request->packet->code], request->packet->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
request->component = "radius";
}
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Sending %s ID %i", fr_packet_codes[request->reply->code], request->reply->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
break;
case REQUEST_INIT:
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Received %s ID %i", fr_packet_codes[request->packet->code], request->packet->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
request->component = "radius";
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Sending %s ID %i", fr_packet_codes[request->reply->code], request->reply->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
break;
*/
packet_len = fr_radius_encode(inst->packet, inst->max_packet_size, NULL,
client->secret, talloc_array_length(client->secret),
- code, 0, vps);
+ code, 0, &vps);
if (packet_len <= 0) {
cf_log_perr(cs, "Failed encoding packet from %s",
inst->filename);
case REQUEST_INIT:
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Received %s ID %i", fr_packet_codes[request->packet->code], request->packet->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
}
request->component = "radius";
if (request->parent && RDEBUG_ENABLED) {
RDEBUG("Sending %s ID %i", fr_packet_codes[request->reply->code], request->reply->id);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
break;
request->packet->data_len,
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
/*
* Maybe the shared secret is wrong?
data_len = fr_tacacs_encode(&FR_DBUFF_TMP(buffer, buffer_len), request->packet->data,
client->secret, talloc_array_length(client->secret) - 1,
- request->reply_pairs);
+ &request->reply_pairs);
if (data_len < 0) {
RPEDEBUG("Failed encoding TACACS+ reply");
return -1;
data_len,
request->async->listen->name);
- log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
}
RHEXDUMP3(buffer, data_len, "proto_tacacs encode packet");
switch (request->request_state) {
case REQUEST_INIT:
RDEBUG("Received %s ID %i", fr_vmps_codes[request->packet->code], request->packet->id);
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
request->component = "vmps";
} else {
RDEBUG("Denying client");
}
- if (RDEBUG_ENABLED) log_request_pair_list(L_DBG_LVL_1, request, NULL, request->reply_pairs, NULL);
+ if (RDEBUG_ENABLED) log_request_pair_list(L_DBG_LVL_1, request, NULL, &request->reply_pairs, NULL);
break;
default:
switch (request->request_state) {
case REQUEST_INIT:
RDEBUG("Received %s ID %08x", fr_vmps_codes[request->packet->code], request->packet->id);
- log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, request->request_pairs, NULL);
+ log_request_proto_pair_list(L_DBG_LVL_1, request, NULL, &request->request_pairs, NULL);
request->component = "vmps";
char const *field; //!< Field name.
} client_get_vp_ctx_t;
-static int _map_proc_client_get_vp(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request,
+static int _map_proc_client_get_vp(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request,
map_t const *map, void *uctx)
{
client_get_vp_ctx_t *client = uctx;
* - 0 on success.
* - -1 on failure.
*/
-int mod_ensure_start_timestamp(json_object *json, fr_pair_t *vps)
+int mod_ensure_start_timestamp(json_object *json, fr_pair_list_t *vps)
{
json_object *j_value; /* json object value */
struct tm tm; /* struct to hold event time */
}
/* get current event timestamp */
- if ((vp = fr_pair_find_by_da(&vps, attr_event_timestamp)) != NULL) {
+ if ((vp = fr_pair_find_by_da(vps, attr_event_timestamp)) != NULL) {
/* get seconds value from attribute */
ts = fr_time_to_sec(vp->vp_date);
} else {
memset(value, 0, sizeof(value));
/* get elapsed session time */
- if ((vp = fr_pair_find_by_da(&vps, attr_acct_session_time)) != NULL) {
+ if ((vp = fr_pair_find_by_da(vps, attr_acct_session_time)) != NULL) {
/* calculate diff */
ts = (ts - vp->vp_uint32);
/* calculate start time */
json_object *mod_value_pair_to_json_object(request_t *request, fr_pair_t *vp);
-int mod_ensure_start_timestamp(json_object *json, fr_pair_t *vps);
+int mod_ensure_start_timestamp(json_object *json, fr_pair_list_t *vps);
int mod_client_map_section(CONF_SECTION *client, CONF_SECTION const *map, json_object *json, char const *docid);
mod_value_pair_to_json_object(request, vp));
}
/* check start timestamp and adjust if needed */
- mod_ensure_start_timestamp(cookie->jobj, request->request_pairs);
+ mod_ensure_start_timestamp(cookie->jobj, &request->request_pairs);
break;
case FR_STATUS_ALIVE:
/* check start timestamp and adjust if needed */
- mod_ensure_start_timestamp(cookie->jobj, request->request_pairs);
+ mod_ensure_start_timestamp(cookie->jobj, &request->request_pairs);
break;
default:
/*
* Convert field X to a VP.
*/
-static int csv_map_getvalue(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request, map_t const *map, void *uctx)
+static int csv_map_getvalue(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request, map_t const *map, void *uctx)
{
char const *str = uctx;
fr_pair_list_t head;
* attribute. The relevant decoder should have already
* concatenated the fragments into a single buffer.
*/
- eap_packet = eap_packet_from_vp(request, request->request_pairs);
+ eap_packet = eap_packet_from_vp(request, &request->request_pairs);
if (!eap_packet) {
RPERROR("Malformed EAP Message");
RETURN_MODULE_FAIL;
fr_pair_value_memdup(fake->request_pairs, tlv_eap_payload->vp_octets, tlv_eap_payload->vp_length, false);
RDEBUG2("Got tunneled request");
- log_request_pair_list(L_DBG_LVL_1, fake, NULL, fake->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_1, fake, NULL, &fake->request_pairs, NULL);
/*
* Tell the request that it's a fake one.
}
static FR_CODE eap_fast_process_tlvs(request_t *request, eap_session_t *eap_session,
- fr_tls_session_t *tls_session, fr_pair_t *fast_vps)
+ fr_tls_session_t *tls_session, fr_pair_list_t *fast_vps)
{
eap_fast_tunnel_t *t = talloc_get_type_abort(tls_session->opaque, eap_fast_tunnel_t);
fr_pair_t *vp;
memset(&my_binding, 0, sizeof(my_binding));
- for (vp = fr_cursor_init(&cursor, &fast_vps);
+ for (vp = fr_cursor_init(&cursor, fast_vps);
vp;
vp = fr_cursor_next(&cursor)) {
FR_CODE code = FR_CODE_ACCESS_REJECT;
data, data_len, NULL) < 0) return FR_CODE_ACCESS_REJECT;
RDEBUG2("Got Tunneled FAST TLVs");
- log_request_pair_list(L_DBG_LVL_1, request, NULL, fast_vps, NULL);
- code = eap_fast_process_tlvs(request, eap_session, tls_session, fast_vps);
+ log_request_pair_list(L_DBG_LVL_1, request, NULL, &fast_vps, NULL);
+ code = eap_fast_process_tlvs(request, eap_session, tls_session, &fast_vps);
fr_pair_list_free(&fast_vps);
if (code == FR_CODE_ACCESS_REJECT) return FR_CODE_ACCESS_REJECT;
}
RDEBUG2("Built change password packet");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &request->request_pairs, NULL);
/*
* jump to "authentication"
if (data->mppe_keys) {
RDEBUG2("Adding stored attributes to parent");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, data->mppe_keys, "&parent.reply.");
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &data->mppe_keys, "&parent.reply.");
MEM(fr_pair_list_copy(parent->reply, &parent->reply->vps, &data->mppe_keys) >= 0);
} else {
RDEBUG2("No stored attributes to copy to parent");
* Convert a list of fr_pair_t's to an EAP packet, through the
* simple expedient of dumping the EAP message
*/
-static int eap_peap_inner_from_pairs(request_t *request, fr_tls_session_t *tls_session, fr_pair_t *vp)
+static int eap_peap_inner_from_pairs(request_t *request, fr_tls_session_t *tls_session, fr_pair_list_t *vps)
{
- fr_assert(vp != NULL);
+ fr_assert(*vps != NULL);
fr_pair_t *this;
fr_cursor_t cursor;
* Send the EAP data in the first attribute, WITHOUT the
* header.
*/
- (tls_session->record_from_buff)(&tls_session->clean_in, vp->vp_octets + EAP_HEADER_LEN,
- vp->vp_length - EAP_HEADER_LEN);
+ this = fr_cursor_init(&cursor, vps);
+ (tls_session->record_from_buff)(&tls_session->clean_in, this->vp_octets + EAP_HEADER_LEN,
+ this->vp_length - EAP_HEADER_LEN);
/*
* Send the rest of the EAP data, but skipping the first VP.
*/
- fr_cursor_init(&cursor, &vp);
for (this = fr_cursor_next(&cursor);
this;
this = fr_cursor_next(&cursor)) {
} else {
RDEBUG2("Got tunneled reply code %i", reply->code);
}
- log_request_pair_list(L_DBG_LVL_2, request, NULL, reply->vps, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &reply->vps, NULL);
}
switch (reply->code) {
* VP's back to the client.
*/
if (vp) {
- eap_peap_inner_from_pairs(request, tls_session, vp);
+ eap_peap_inner_from_pairs(request, tls_session, &vp);
fr_pair_list_free(&vp);
}
}
RDEBUG2("Got tunneled request");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, fake->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &fake->request_pairs, NULL);
/*
* Update other items in the request_t data structure.
*/
if (tunnel_vps) {
RDEBUG2("Sending tunneled reply attributes");
- log_request_pair_list(L_DBG_LVL_2, request, NULL, tunnel_vps, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &tunnel_vps, NULL);
vp2diameter(request, tls_session, tunnel_vps);
fr_pair_list_free(&tunnel_vps);
/*
* Process channel binding.
*/
- chbind = eap_chbind_vp2packet(request, request->request_pairs);
+ chbind = eap_chbind_vp2packet(request, &request->request_pairs);
if (chbind) {
FR_CODE chbind_code;
CHBIND_REQ *req = talloc_zero(request, CHBIND_REQ);
* This function does it's own xlat of the input program
* to execute.
*/
- result = radius_exec_program(request, *out, outlen, NULL, request, fmt, input_pairs ? *input_pairs : NULL,
+ result = radius_exec_program(request, *out, outlen, NULL, request, fmt, input_pairs ? input_pairs : NULL,
inst->wait, inst->shell_escape, inst->timeout);
if (result != 0) return -1;
env_pairs = *input_pairs;
}
- if (fr_exec_nowait(request, box, env_pairs) < 0) {
+ if (fr_exec_nowait(request, box, &env_pairs) < 0) {
RPEDEBUG("Failed executing program");
RETURN_MODULE_FAIL;
}
m = talloc_zero(ctx, rlm_exec_ctx_t);
- return unlang_module_yield_to_tmpl(m, &m->box, &m->status, request, inst->tmpl, env_pairs, mod_exec_wait_resume, NULL, m);
+ return unlang_module_yield_to_tmpl(m, &m->box, &m->status, request, inst->tmpl, &env_pairs, mod_exec_wait_resume, NULL, m);
}
/*
* Compare the expiration date.
*/
-static int expirecmp(UNUSED void *instance, request_t *req, UNUSED fr_pair_t *request, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int expirecmp(UNUSED void *instance, request_t *req, UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
time_t now = 0;
/*
* See if a fr_pair_t list contains Fall-Through = Yes
*/
-static int fall_through(fr_pair_t *vp)
+static int fall_through(fr_pair_list_t const *vps)
{
fr_pair_t *tmp;
- tmp = fr_pair_find_by_da(&vp, attr_fall_through);
+ tmp = fr_pair_find_by_da(vps, attr_fall_through);
return tmp ? tmp->vp_uint32 : 0;
}
}
}
- if (paircmp(request, packet->vps, check_tmp) == 0) {
+ if (paircmp(request, &packet->vps, &check_tmp) == 0) {
RDEBUG2("Found match \"%s\" one line %d of %s", pl->name, pl->lineno, filename);
found = true;
/* ctx may be reply */
if (pl->reply) {
MEM(fr_pair_list_copy(reply, &reply_tmp, &pl->reply) >= 0);
- radius_pairmove(request, &reply->vps, reply_tmp, true);
+ radius_pairmove(request, &reply->vps, &reply_tmp, true);
}
fr_pair_list_move(&request->control_pairs, &check_tmp);
/*
* Fallthrough?
*/
- if (!fall_through(pl->reply)) break;
+ if (!fall_through(&pl->reply)) break;
}
/* Ensure temporary check list is clear before next match */
*/
MEM(vb = fr_value_box_alloc_null(ctx));
- json_str = fr_json_afrom_pair_list(vb, json_vps, format);
+ json_str = fr_json_afrom_pair_list(vb, &json_vps, format);
if (!json_str) {
REDEBUG("Failed to generate JSON string");
goto error;
* - 0 on success.
* - -1 on failure.
*/
-static int _json_map_proc_get_value(TALLOC_CTX *ctx, fr_pair_t **out, request_t *request,
+static int _json_map_proc_get_value(TALLOC_CTX *ctx, fr_pair_list_t *out, request_t *request,
map_t const *map, void *uctx)
{
fr_pair_t *vp;
fr_value_box_t *head, *value;
int ret;
- *out = NULL;
+ fr_pair_list_init(out);
ret = fr_jpath_evaluate_leaf(request, &head, tmpl_da(map->lhs)->type, tmpl_da(map->lhs),
to_eval->root, to_eval->jpath);
*
* @param instance of the rlm_ldap module.
* @param request Current request.
- * @param thing Unknown.
+ * @param request_list Unknown.
* @param check Which group to check for user membership.
* @param check_list Unknown.
* @return
* - 1 on failure (or if the user is not a member).
* - 0 on success.
*/
-static int rlm_ldap_groupcmp(void *instance, request_t *request, UNUSED fr_pair_t *thing, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int rlm_ldap_groupcmp(void *instance, request_t *request, UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
rlm_ldap_t const *inst = talloc_get_type_abort_const(instance, rlm_ldap_t);
rlm_rcode_t rcode;
/*
* Compare the current time to a range.
*/
-static int timecmp(UNUSED void *instance, request_t *req, UNUSED fr_pair_t *request, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int timecmp(UNUSED void *instance, request_t *req, UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
/*
* If there's a request, use that timestamp.
* Time-Of-Day support
*/
static int time_of_day(UNUSED void *instance, request_t *request,
- UNUSED fr_pair_t *request_list, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+ UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
int scan;
int hhmmss, when;
return 0;
}
-static int mruby_vps_to_array(request_t *request, mrb_value *out, mrb_state *mrb, fr_pair_t **vps)
+static int mruby_vps_to_array(request_t *request, mrb_value *out, mrb_state *mrb, fr_pair_list_t *vps)
{
mrb_value res;
fr_pair_t *vp;
return 0;
}
-static void add_vp_tuple(TALLOC_CTX *ctx, request_t *request, fr_pair_t **vps, mrb_state *mrb, mrb_value value, char const *function_name)
+static void add_vp_tuple(TALLOC_CTX *ctx, request_t *request, fr_pair_list_t *vps, mrb_state *mrb, mrb_value value, char const *function_name)
{
int i;
}
static inline int mruby_set_vps(request_t *request, mrb_state *mrb, mrb_value mruby_request,
- char const *list_name, fr_pair_t **vps)
+ char const *list_name, fr_pair_list_t *vps)
{
mrb_value res;
}
static void result_add(TALLOC_CTX *ctx, rlm_passwd_t const *inst, request_t *request,
- fr_pair_t **vps, struct mypasswd * pw, char when, char const *listname)
+ fr_pair_list_t *vps, struct mypasswd * pw, char when, char const *listname)
{
uint32_t i;
fr_pair_t *vp;
* Example for this is Vendor-Specific.Cisco.AVPair that holds multiple values.
* Which will be available as array_ref in $RAD_REQUEST{'Vendor-Specific.Cisco.AVPair'}
*/
-static void perl_store_vps(UNUSED TALLOC_CTX *ctx, request_t *request, fr_pair_t **vps, HV *rad_hv,
+static void perl_store_vps(UNUSED TALLOC_CTX *ctx, request_t *request, fr_pair_list_t *vps, HV *rad_hv,
const char *hash_name, const char *list_name)
{
fr_pair_t *vp;
* Value Pair Format
*
*/
-static int pairadd_sv(TALLOC_CTX *ctx, request_t *request, fr_pair_t **vps, char *key, SV *sv, fr_token_t op,
+static int pairadd_sv(TALLOC_CTX *ctx, request_t *request, fr_pair_list_t *vps, char *key, SV *sv, fr_token_t op,
const char *hash_name, const char *list_name)
{
char *val;
/*
* Gets the content from hashes
*/
-static int get_hv_content(TALLOC_CTX *ctx, request_t *request, HV *my_hv, fr_pair_t **vps,
+static int get_hv_content(TALLOC_CTX *ctx, request_t *request, HV *my_hv, fr_pair_list_t *vps,
const char *hash_name, const char *list_name)
{
SV *res_sv, **av_sv;
}
static void mod_vptuple(TALLOC_CTX *ctx, rlm_python_t const *inst, request_t *request,
- fr_pair_t **vps, PyObject *p_value, char const *funcname, char const *list_name)
+ fr_pair_list_t *vps, PyObject *p_value, char const *funcname, char const *list_name)
{
int i;
Py_ssize_t tuple_len;
fr_table_str_by_value(fr_tokens_table, op, "="), s2);
}
- radius_pairmove(current, vps, vp, false);
+ radius_pairmove(current, vps, &vp, false);
}
}
static int encode(rlm_radius_udp_t const *inst, request_t *request, udp_request_t *u, uint8_t id);
-static decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_t **reply, uint8_t *response_code,
+static decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_list_t *reply, uint8_t *response_code,
udp_handle_t *h, request_t *request, udp_request_t *u,
uint8_t const request_authenticator[static RADIUS_AUTH_VECTOR_LENGTH],
uint8_t *data, size_t data_len);
request->packet->code = u->code;
DEBUG3("%s - Status check packet type will be %s", h->module_name, fr_packet_codes[u->code]);
- log_request_pair_list(L_DBG_LVL_3, request, NULL, request->request_pairs, NULL);
+ log_request_pair_list(L_DBG_LVL_3, request, NULL, &request->request_pairs, NULL);
MEM(h->status_r = talloc_zero(request, udp_result_t));
h->status_u = u;
* - DECODE_FAIL_NONE on success.
* - DECODE_FAIL_* on failure.
*/
-static decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_t **reply, uint8_t *response_code,
+static decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_list_t *reply, uint8_t *response_code,
udp_handle_t *h, request_t *request, udp_request_t *u,
uint8_t const request_authenticator[static RADIUS_AUTH_VECTOR_LENGTH],
uint8_t *data, size_t data_len)
RDEBUG("Received %s ID %d length %ld reply packet on connection %s",
fr_packet_codes[code], code, packet_len, h->name);
- log_request_pair_list(L_DBG_LVL_2, request, NULL, *reply, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, reply, NULL);
*response_code = code;
*/
packet_len = fr_radius_encode(u->packet, u->packet_len - (proxy_state + message_authenticator), NULL,
inst->secret, talloc_array_length(inst->secret) - 1,
- u->code, id, request->request_pairs);
+ u->code, id, &request->request_pairs);
if (fr_pair_encode_is_error(packet_len)) {
RPERROR("Failed encoding packet");
fr_packet_codes[u->code], u->id, u->packet_len, h->name);
}
- log_request_pair_list(L_DBG_LVL_2, request, NULL, request->request_pairs, NULL);
- if (u->extra) log_request_pair_list(L_DBG_LVL_2, request, NULL, u->extra, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &request->request_pairs, NULL);
+ if (u->extra) log_request_pair_list(L_DBG_LVL_2, request, NULL, &u->extra, NULL);
/*
* Record pointers to the buffer we'll be writing
fr_assert(freespace > 0);
if (ctx->state == READ_STATE_INIT) {
- encoded = fr_json_afrom_pair_list(data, request->request_pairs, NULL);
+ encoded = fr_json_afrom_pair_list(data, &request->request_pairs, NULL);
if (!encoded) return -1;
data->start = data->p = encoded;
RINDENT();
RDEBUG2("&%s:%pP", fr_table_str_by_value(pair_list_table, tmpl_list(dst), ""), vp);
REXDENT();
- radius_pairmove(current, vps, vp, false);
+ radius_pairmove(current, vps, &vp, false);
/*
* If we call json_object_array_get_idx on something that's not an array
* the behaviour appears to be to occasionally segfault.
/*
* Fall-Through checking function from rlm_files.c
*/
-static sql_fall_through_t fall_through(fr_pair_t *vp)
+static sql_fall_through_t fall_through(fr_pair_list_t *vps)
{
fr_pair_t *tmp;
- tmp = fr_pair_find_by_da(&vp, attr_fall_through);
+ tmp = fr_pair_find_by_da(vps, attr_fall_through);
return tmp ? tmp->vp_uint32 : FALL_THROUGH_DEFAULT;
}
* - 0 on success.
* - -1 on failure.
*/
-static int _sql_map_proc_get_value(TALLOC_CTX *ctx, fr_pair_t **out,
+static int _sql_map_proc_get_value(TALLOC_CTX *ctx, fr_pair_list_t *out,
request_t *request, map_t const *map, void *uctx)
{
fr_pair_t *vp;
char const *value = uctx;
+ fr_cursor_t cursor;
+ fr_pair_list_init(out);
+ fr_cursor_init(&cursor, out);
vp = fr_pair_afrom_da(ctx, tmpl_da(map->lhs));
if (!vp) return -1;
}
vp->op = map->op;
- *out = vp;
+ fr_cursor_append(&cursor, vp);
return 0;
}
* The group membership query should only return one element which is the username. The returned
* username will then be checked with the passed check string.
*/
-static int sql_groupcmp(void *instance, request_t *request, UNUSED fr_pair_t *request_vp,
- fr_pair_t *check, UNUSED fr_pair_t *check_list) CC_HINT(nonnull (1, 2, 4));
+static int sql_groupcmp(void *instance, request_t *request, UNUSED fr_pair_list_t *request_list,
+ fr_pair_t *check, UNUSED fr_pair_list_t *check_list) CC_HINT(nonnull (1, 2, 4));
-static int sql_groupcmp(void *instance, request_t *request, UNUSED fr_pair_t *request_vp,
- fr_pair_t *check, UNUSED fr_pair_t *check_list)
+static int sql_groupcmp(void *instance, request_t *request, UNUSED fr_pair_list_t *request_list,
+ fr_pair_t *check, UNUSED fr_pair_list_t *check_list)
{
rlm_sql_handle_t *handle;
rlm_sql_t const *inst = talloc_get_type_abort_const(instance, rlm_sql_t);
* process the reply rows
*/
if ((rows > 0) &&
- (paircmp(request, request->request_pairs, check_tmp) != 0)) {
+ (paircmp(request, &request->request_pairs, &check_tmp) != 0)) {
fr_pair_list_free(&check_tmp);
entry = entry->next;
RDEBUG2("&%pP", vp);
}
REXDENT();
- radius_pairmove(request, &request->control_pairs, check_tmp, true);
+ radius_pairmove(request, &request->control_pairs, &check_tmp, true);
fr_pair_list_init(&check_tmp);
}
}
fr_assert(reply_tmp != NULL); /* coverity, among others */
- *do_fall_through = fall_through(reply_tmp);
+ *do_fall_through = fall_through(&reply_tmp);
RDEBUG2("Group \"%s\": Merging reply items", entry->name);
if (rcode == RLM_MODULE_NOOP) rcode = RLM_MODULE_UPDATED;
- log_request_pair_list(L_DBG_LVL_2, request, NULL, reply_tmp, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &reply_tmp, NULL);
- radius_pairmove(request, &request->reply_pairs, reply_tmp, true);
+ radius_pairmove(request, &request->reply_pairs, &reply_tmp, true);
fr_pair_list_init(&reply_tmp);
/*
* If there's no reply query configured, then we assume
*/
RDEBUG2("User found in radcheck table");
user_found = true;
- if (paircmp(request, request->request_pairs, check_tmp) != 0) {
+ if (paircmp(request, &request->request_pairs, &check_tmp) != 0) {
fr_pair_list_free(&check_tmp);
check_tmp = NULL;
goto skip_reply;
RDEBUG2("&%pP", vp);
}
REXDENT();
- radius_pairmove(request, &request->control_pairs, check_tmp, true);
+ radius_pairmove(request, &request->control_pairs, &check_tmp, true);
rcode = RLM_MODULE_OK;
check_tmp = NULL;
if (rows == 0) goto skip_reply;
- do_fall_through = fall_through(reply_tmp);
+ do_fall_through = fall_through(&reply_tmp);
RDEBUG2("User found in radreply table, merging reply items");
user_found = true;
- log_request_pair_list(L_DBG_LVL_2, request, NULL, reply_tmp, NULL);
+ log_request_pair_list(L_DBG_LVL_2, request, NULL, &reply_tmp, NULL);
- radius_pairmove(request, &request->reply_pairs, reply_tmp, true);
+ radius_pairmove(request, &request->reply_pairs, &reply_tmp, true);
rcode = RLM_MODULE_OK;
reply_tmp = NULL;
/*
* See if the counter matches.
*/
-static int counter_cmp(void *instance, request_t *request, UNUSED fr_pair_t *req , fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int counter_cmp(void *instance, request_t *request, UNUSED fr_pair_list_t *request_list , fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
rlm_sqlcounter_t const *inst = talloc_get_type_abort_const(instance, rlm_sqlcounter_t);
uint64_t counter;
{ NULL }
};
-static int rlm_test_cmp(UNUSED void *instance, request_t *request, UNUSED fr_pair_t *thing, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int rlm_test_cmp(UNUSED void *instance, request_t *request, UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
fr_assert(check->vp_type == FR_TYPE_STRING);
/*
* The Unix-Group = handler.
*/
-static int groupcmp(UNUSED void *instance, request_t *request, UNUSED fr_pair_t *req_vp,
- fr_pair_t *check, UNUSED fr_pair_t *check_list)
+static int groupcmp(UNUSED void *instance, request_t *request, UNUSED fr_pair_list_t *request_list,
+ fr_pair_t *check, UNUSED fr_pair_list_t *check_list)
{
struct passwd *pwd;
struct group *grp;
*
* @param instance Instance of this module
* @param request The current request
- * @param req The request list
+ * @param request_list The request list
* @param check Value pair containing group to be searched
* @param check_list Unknown
*
* - 0 user is in group
* - 1 failure or user is not in group
*/
-static int winbind_group_cmp(void *instance, request_t *request, UNUSED fr_pair_t *req, fr_pair_t *check,
- UNUSED fr_pair_t *check_list)
+static int winbind_group_cmp(void *instance, request_t *request, UNUSED fr_pair_list_t *request_list, fr_pair_t *check,
+ UNUSED fr_pair_list_t *check_list)
{
rlm_winbind_t *inst = instance;
int ret = 1;
int fr_arp_init(void);
void fr_arp_free(void);
-ssize_t fr_arp_encode(fr_dbuff_t *dbuff, uint8_t const *original, fr_pair_t *vps);
+ssize_t fr_arp_encode(fr_dbuff_t *dbuff, uint8_t const *original, fr_pair_list_t *vps);
ssize_t fr_arp_decode(TALLOC_CTX *ctx, uint8_t const *packet, size_t packet_len, fr_pair_list_t *list);
int fr_arp_entry_add(int fd, char const *interface, uint8_t ipaddr[static 4], uint8_t macaddr[static 6]);
/** Encode VPS into a raw ARP packet.
*
*/
-ssize_t fr_arp_encode(fr_dbuff_t *dbuff, uint8_t const *original, fr_pair_t *vps)
+ssize_t fr_arp_encode(fr_dbuff_t *dbuff, uint8_t const *original, fr_pair_list_t *vps)
{
ssize_t slen;
fr_pair_t *vp;
fr_da_stack_t da_stack;
fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
- if (!vps) {
+ if (!*vps) {
fr_strerror_printf("Cannot encode empty packet");
return -1;
}
/*
* Find the first attribute which is parented by ARP-Packet.
*/
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
if (vp->da->parent == attr_arp_packet) break;
* Because ARP has no TLVs, we don't have test points for pair
* encode / decode.
*/
-static ssize_t fr_arp_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
+static ssize_t fr_arp_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
{
return fr_arp_encode(&FR_DBUFF_TMP(data, data_len), NULL, vps);
}
return (vp->da->dict == dict_dhcpv4) && (!vp->da->flags.internal);
}
-ssize_t fr_dhcpv4_encode(uint8_t *buffer, size_t buflen, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_t *vps)
+ssize_t fr_dhcpv4_encode(uint8_t *buffer, size_t buflen, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_list_t *vps)
{
return fr_dhcpv4_encode_dbuff(&FR_DBUFF_TMP(buffer, buflen), original, code, xid, vps);
}
-ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_t *vps)
+ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_list_t *vps)
{
fr_cursor_t cursor;
fr_pair_t *vp;
*/
/* Maximum-Msg-Size */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_dhcp_maximum_msg_size);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_dhcp_maximum_msg_size);
if (vp && (vp->vp_uint32 > mms)) {
mms = vp->vp_uint32;
}
#endif
- vp = fr_pair_find_by_da(&vps, attr_dhcp_opcode);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_opcode);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t) vp->vp_uint8);
} else {
}
/* Hardware-Type */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_hardware_type);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_hardware_type);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint8);
}
/* Hardware-Address-len */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_hardware_address_length);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_hardware_address_length);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint8);
}
/* Hop-Count */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_hop_count);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_hop_count);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint8);
FR_DBUFF_IN_RETURN(&work_dbuff, xid);
/* Number-of-Seconds */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_number_of_seconds);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_number_of_seconds);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint16);
} else {
}
/* Flags */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_flags);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_flags);
if (vp) {
FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint16);
} else {
}
/* Client-IP-Address */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_client_ip_address);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_client_ip_address);
if (vp) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
} else {
}
/* Your-IP-address */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_your_ip_address);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_your_ip_address);
if (vp) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
} else {
}
/* Server-IP-Address */
- vp = fr_pair_find_by_da(&vps, attr_dhcp_server_ip_address);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_server_ip_address);
if (vp) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
} else {
/*
* Gateway-IP-Address
*/
- vp = fr_pair_find_by_da(&vps, attr_dhcp_gateway_ip_address);
+ vp = fr_pair_find_by_da(vps, attr_dhcp_gateway_ip_address);
if (vp) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
}
/* Client-Hardware-Address */
- if ((vp = fr_pair_find_by_da(&vps, attr_dhcp_client_hardware_address))) {
+ if ((vp = fr_pair_find_by_da(vps, attr_dhcp_client_hardware_address))) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)vp->vp_ether, sizeof(vp->vp_ether));
FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, DHCP_CHADDR_LEN - sizeof(vp->vp_ether));
}
/* Server-Host-Name */
- if ((vp = fr_pair_find_by_da(&vps, attr_dhcp_server_host_name))) {
+ if ((vp = fr_pair_find_by_da(vps, attr_dhcp_server_host_name))) {
if (vp->vp_length > DHCP_SNAME_LEN) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, vp->vp_strvalue, DHCP_SNAME_LEN);
} else {
*/
/* Boot-Filename */
- if ((vp = fr_pair_find_by_da(&vps, attr_dhcp_boot_filename))) {
+ if ((vp = fr_pair_find_by_da(vps, attr_dhcp_boot_filename))) {
if (vp->vp_length > DHCP_FILE_LEN) {
FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, vp->vp_strvalue, DHCP_FILE_LEN);
} else {
/* DHCP magic number */
FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) DHCP_OPTION_MAGIC_NUMBER);
- if ((vp = fr_pair_find_by_da(&vps, attr_dhcp_message_type))) {
+ if ((vp = fr_pair_find_by_da(vps, attr_dhcp_message_type))) {
FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_MESSAGE_TYPE, 0x01, vp->vp_uint8);
} else {
FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_MESSAGE_TYPE, 0x01, (uint8_t)code);
* Pre-sort attributes into contiguous blocks so that fr_dhcpv4_encode_option
* operates correctly. This changes the order of the list, but never mind...
*/
- fr_pair_list_sort(&vps, fr_dhcpv4_attr_cmp);
- fr_cursor_talloc_iter_init(&cursor, &vps, fr_proto_next_encodable, dict_dhcpv4, fr_pair_t);
+ fr_pair_list_sort(vps, fr_dhcpv4_attr_cmp);
+ fr_cursor_talloc_iter_init(&cursor, vps, fr_proto_next_encodable, dict_dhcpv4, fr_pair_t);
/*
* Each call to fr_dhcpv4_encode_option will encode one complete DHCP option,
bool fr_dhcpv4_ok(uint8_t const *data, ssize_t data_len, uint8_t *message_type, uint32_t *xid);
fr_radius_packet_t *fr_dhcpv4_packet_alloc(uint8_t const *data, ssize_t data_len);
bool fr_dhcpv4_is_encodable(void const *item, void const *uctx);
-ssize_t fr_dhcpv4_encode(uint8_t *buffer, size_t buflen, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_t *vps);
-ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_t *vps);
+ssize_t fr_dhcpv4_encode(uint8_t *buffer, size_t buflen, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_list_t *vps);
+ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int code, uint32_t xid, fr_pair_list_t *vps);
int fr_dhcpv4_global_init(void);
void fr_dhcpv4_global_free(void);
void fr_dhcpv4_print_hex(FILE *fp, uint8_t const *packet, size_t packet_len);
return fr_dbuff_set(dbuff, &work_dbuff);
}
-static ssize_t fr_dhcpv4_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
+static ssize_t fr_dhcpv4_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
{
return fr_dhcpv4_encode_dbuff(&FR_DBUFF_TMP(data, data_len), NULL, 0, 0, vps);
}
packet->id = fr_rand();
}
- len = fr_dhcpv4_encode(packet->data, packet->data_len, NULL, packet->code, packet->id, packet->vps);
+ len = fr_dhcpv4_encode(packet->data, packet->data_len, NULL, packet->code, packet->id, &packet->vps);
if (len < 0) return -1;
packet->data_len = len;
/** Encode a DHCPv6 packet
*
*/
-ssize_t fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t length, int msg_type, fr_pair_t *vps)
+ssize_t fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t length, int msg_type, fr_pair_list_t *vps)
{
fr_dbuff_t frame_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
fr_pair_t *vp;
root = fr_dict_root(dict_dhcpv6);
if (!msg_type) {
- vp = fr_pair_find_by_da(&vps, attr_packet_type);
+ vp = fr_pair_find_by_da(vps, attr_packet_type);
if (vp) msg_type = vp->vp_uint32;
}
switch (msg_type) {
case FR_DHCPV6_RELAY_REPLY:
case FR_DHCPV6_RELAY_FORWARD:
- vp = fr_pair_find_by_da(&vps, attr_hop_count);
+ vp = fr_pair_find_by_da(vps, attr_hop_count);
if (likely(vp != NULL)) {
FR_VALUE_BOX_TO_NETWORK_RETURN(&frame_dbuff, &vp->data);
} else {
FR_DBUFF_MEMSET_RETURN(&frame_dbuff, 0, DHCPV6_HOP_COUNT_LEN);
}
- vp = fr_pair_find_by_da(&vps, attr_relay_link_address);
+ vp = fr_pair_find_by_da(vps, attr_relay_link_address);
if (likely(vp != NULL)) {
FR_VALUE_BOX_TO_NETWORK_RETURN(&frame_dbuff, &vp->data);
} else {
FR_DBUFF_MEMSET_RETURN(&frame_dbuff, 0, DHCPV6_LINK_ADDRESS_LEN);
}
- vp = fr_pair_find_by_da(&vps, attr_relay_peer_address);
+ vp = fr_pair_find_by_da(vps, attr_relay_peer_address);
if (likely(vp != NULL)) {
FR_VALUE_BOX_TO_NETWORK_RETURN(&frame_dbuff, &vp->data);
} else {
/*
* We can set an XID, or we can pick a random one.
*/
- vp = fr_pair_find_by_da(&vps, attr_transaction_id);
+ vp = fr_pair_find_by_da(vps, attr_transaction_id);
if (vp && (vp->vp_length >= DHCPV6_TRANSACTION_ID_LEN)) {
FR_DBUFF_IN_MEMCPY_RETURN(&frame_dbuff, vp->vp_octets, DHCPV6_TRANSACTION_ID_LEN);
} else {
packet_ctx.original = original;
packet_ctx.original_length = length;
- fr_cursor_talloc_iter_init(&cursor, &vps, fr_dhcpv6_next_encodable, dict_dhcpv6, fr_pair_t);
+ fr_cursor_talloc_iter_init(&cursor, vps, fr_dhcpv6_next_encodable, dict_dhcpv6, fr_pair_t);
while ((fr_dbuff_extend(&frame_dbuff) > 0) && (fr_cursor_current(&cursor) != NULL)) {
slen = fr_dhcpv6_encode_option(&frame_dbuff, &cursor, &packet_ctx);
switch (slen) {
bool from_server);
ssize_t fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t length,
- int msg_type, fr_pair_t *vps);
+ int msg_type, fr_pair_list_t *vps);
ssize_t fr_dhcpv6_decode(TALLOC_CTX *ctx, uint8_t const *packet, size_t packet_len,
fr_cursor_t *cursor);
FR_DBUFF_ADVANCE_RETURN(dbuff, 2); /* Advanced past the length field */
vp = fr_cursor_current(cursor);
- slen = fr_dhcpv6_encode(dbuff, NULL, 0, 0, vp->vp_group);
+ slen = fr_dhcpv6_encode(dbuff, NULL, 0, 0, &vp->vp_group);
if (slen <= 0) {
fr_dbuff_marker_release(&start_m);
return slen;
return 0;
}
-static ssize_t fr_dhcpv6_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
+static ssize_t fr_dhcpv6_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
{
ssize_t slen;
*
*/
ssize_t fr_radius_encode(uint8_t *packet, size_t packet_len, uint8_t const *original,
- char const *secret, size_t secret_len, int code, int id, fr_pair_t *vps)
+ char const *secret, size_t secret_len, int code, int id, fr_pair_list_t *vps)
{
return fr_radius_encode_dbuff(&FR_DBUFF_TMP(packet, packet_len), original, secret, secret_len, code, id, vps);
}
ssize_t fr_radius_encode_dbuff(fr_dbuff_t *dbuff, uint8_t const *original,
- char const *secret, UNUSED size_t secret_len, int code, int id, fr_pair_t *vps)
+ char const *secret, UNUSED size_t secret_len, int code, int id, fr_pair_list_t *vps)
{
ssize_t slen;
fr_pair_t const *vp;
/*
* Loop over the reply attributes for the packet.
*/
- fr_cursor_talloc_iter_init(&cursor, &vps, fr_radius_next_encodable, dict_radius, fr_pair_t);
+ fr_cursor_talloc_iter_init(&cursor, vps, fr_radius_next_encodable, dict_radius, fr_pair_t);
while ((vp = fr_cursor_current(&cursor))) {
VP_VERIFY(vp);
return fr_dbuff_set(dbuff, &work_dbuff);
}
-static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_t *vps, void *encoder_ctx)
+static ssize_t encode_tags(fr_dbuff_t *dbuff, fr_pair_list_t const *vps, void *encoder_ctx)
{
ssize_t slen;
fr_pair_t const *vp;
/*
* Note that we skip tags inside of tags!
*/
- fr_cursor_talloc_iter_init(&cursor, &vps, fr_proto_next_encodable, dict_radius, fr_pair_t);
+ fr_cursor_talloc_iter_init(&cursor, vps, fr_proto_next_encodable, dict_radius, fr_pair_t);
while ((vp = fr_cursor_current(&cursor))) {
VP_VERIFY(vp);
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, encoder_ctx);
packet_ctx->tag = 0;
if (len < 0) return len;
return 0;
}
-static ssize_t fr_radius_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, void *proto_ctx)
+static ssize_t fr_radius_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, void *proto_ctx)
{
fr_radius_ctx_t *test_ctx = talloc_get_type_abort(proto_ctx, fr_radius_ctx_t);
int packet_type = FR_CODE_ACCESS_REQUEST;
fr_pair_t *vp;
ssize_t slen;
- vp = fr_pair_find_by_da(&vps, attr_packet_type);
+ vp = fr_pair_find_by_da(vps, attr_packet_type);
if (vp) packet_type = vp->vp_uint32;
if ((packet_type == FR_CODE_ACCESS_REQUEST) || (packet_type == FR_CODE_STATUS_SERVER)) {
- vp = fr_pair_find_by_da(&vps, attr_packet_authentication_vector);
+ vp = fr_pair_find_by_da(vps, attr_packet_authentication_vector);
if (vp && (vp->vp_length == RADIUS_AUTH_VECTOR_LENGTH)) {
memcpy(data + 4, vp->vp_octets, RADIUS_AUTH_VECTOR_LENGTH);
} else {
memcpy(data + 4, packet->vector, sizeof(packet->vector));
slen = fr_radius_encode(data, sizeof(data), original_data, secret, talloc_array_length(secret) - 1,
- packet->code, packet->id, packet->vps);
+ packet->code, packet->id, &packet->vps);
if (slen < 0) return slen;
/*
ssize_t fr_radius_recv_header(int sockfd, fr_ipaddr_t *src_ipaddr, uint16_t *src_port, unsigned int *code);
ssize_t fr_radius_encode(uint8_t *packet, size_t packet_len, uint8_t const *original,
- char const *secret, size_t secret_len, int code, int id, fr_pair_t *vps);
+ char const *secret, size_t secret_len, int code, int id, fr_pair_list_t *vps);
ssize_t fr_radius_encode_dbuff(fr_dbuff_t *dbuff, uint8_t const *original,
- char const *secret, UNUSED size_t secret_len, int code, int id, fr_pair_t *vps);
+ char const *secret, UNUSED size_t secret_len, int code, int id, fr_pair_list_t *vps);
ssize_t fr_radius_decode(TALLOC_CTX *ctx, uint8_t const *packet, size_t packet_len, uint8_t const *original,
char const *secret, UNUSED size_t secret_len, fr_cursor_t *cursor) CC_HINT(nonnull(1,2,5,7));
/**
* Encode a TACACS+ 'arg_N' fields.
*/
-static uint8_t tacacs_encode_body_arg_n_len(fr_dbuff_t *dbuff, fr_pair_t *vps, fr_dict_attr_t const *da)
+static uint8_t tacacs_encode_body_arg_n_len(fr_dbuff_t *dbuff, fr_pair_list_t *vps, fr_dict_attr_t const *da)
{
uint8_t arg_cnt = 0;
fr_pair_t *vp;
fr_cursor_t cursor;
fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
if (arg_cnt == 255) break;
return arg_cnt;
}
-static ssize_t tacacs_encode_body_arg_n(fr_dbuff_t *dbuff, fr_pair_t *vps, fr_dict_attr_t const *da)
+static ssize_t tacacs_encode_body_arg_n(fr_dbuff_t *dbuff, fr_pair_list_t *vps, fr_dict_attr_t const *da)
{
fr_pair_t *vp;
fr_cursor_t cursor;
uint8_t arg_cnt = 0;
fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor), arg_cnt++) {
if (arg_cnt == 255) break;
/*
* Encode a TACACS+ field.
*/
-static ssize_t tacacs_encode_field(fr_dbuff_t *dbuff, fr_pair_t *vps, fr_dict_attr_t const *da, size_t max_len)
+static ssize_t tacacs_encode_field(fr_dbuff_t *dbuff, fr_pair_list_t *vps, fr_dict_attr_t const *da, size_t max_len)
{
fr_pair_t *vp;
fr_dbuff_t work_dbuff = FR_DBUFF_NO_ADVANCE(dbuff);
- vp = fr_pair_find_by_da(&vps, da);
+ vp = fr_pair_find_by_da(vps, da);
if (!vp || !vp->vp_length || (vp->vp_length > max_len)) return 0;
if (da->type == FR_TYPE_STRING) {
* doesn't specify them, then they don't get encoded.
*/
#define ENCODE_FIELD_UINT8(_field, _da) do { \
- vp = fr_pair_find_by_da(&vps, _da); \
+ vp = fr_pair_find_by_da(vps, _da); \
_field = (vp) ? vp->vp_uint8 : 0; \
} while (0)
/**
* Encode VPS into a raw TACACS packet.
*/
-ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char const *secret, size_t secret_len, fr_pair_t *vps)
+ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original_packet, char const *secret, size_t secret_len, fr_pair_list_t *vps)
{
fr_pair_t *vp;
fr_tacacs_packet_t *packet;
/*
* Find the first attribute which is parented by TACACS-Packet.
*/
- for (vp = fr_cursor_init(&cursor, &vps);
+ for (vp = fr_cursor_init(&cursor, vps);
vp;
vp = fr_cursor_next(&cursor)) {
if (vp->da->parent == attr_tacacs_packet) break;
/*
* If the caller didn't set a session ID, use a random one.
*/
- if (!fr_pair_find_by_da(&vps, attr_tacacs_session_id)) {
+ if (!fr_pair_find_by_da(vps, attr_tacacs_session_id)) {
packet->hdr.session_id = fr_rand();
}
/*
* Test points for protocol encode
*/
-static ssize_t fr_tacacs_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
+static ssize_t fr_tacacs_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
{
fr_tacacs_ctx_t *test_ctx = talloc_get_type_abort(proto_ctx, fr_tacacs_ctx_t);
} fr_tacacs_ctx_t;
/* encode.c */
-ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original, char const *const secret, size_t secret_len, fr_pair_t *vps);
+ssize_t fr_tacacs_encode(fr_dbuff_t *dbuff, uint8_t const *original, char const *const secret, size_t secret_len, fr_pair_list_t *vps);
/* decode.c */
ssize_t fr_tacacs_decode(TALLOC_CTX *ctx, uint8_t const *buffer, size_t buffer_len, UNUSED const uint8_t *original, char const * const secret, size_t secret_len, fr_cursor_t *cursor);
/*
* Test points for protocol encode
*/
-static ssize_t fr_vmps_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
+static ssize_t fr_vmps_encode_proto(UNUSED TALLOC_CTX *ctx, fr_pair_list_t *vps, uint8_t *data, size_t data_len, UNUSED void *proto_ctx)
{
fr_cursor_t cursor;
- fr_cursor_talloc_iter_init(&cursor, &vps, fr_proto_next_encodable, dict_vmps, fr_pair_t);
+ fr_cursor_talloc_iter_init(&cursor, vps, fr_proto_next_encodable, dict_vmps, fr_pair_t);
return fr_vmps_encode(&FR_DBUFF_TMP(data, data_len), NULL, -1, -1, &cursor);
}
projects / thirdparty / freeradius-server.git / commitdiff
