if (fr_debug_lvl > 1) fr_dhcpv4_print_hex(stdout, reply->data, reply->data_len);
- fr_dcursor_init(&cursor, fr_pair_list_order(&reply_vps));
+ fr_pair_dcursor_init(&cursor, &reply_vps);
if (fr_dhcpv4_decode(reply, &reply_vps, reply->data, reply->data_len, &reply->code) < 0) {
ERROR("Failed decoding reply");
return NULL;
last_match = fr_pair_list_head(vps);
- fr_dcursor_init(&list_cursor, fr_pair_list_order(vps));
+ fr_pair_dcursor_init(&list_cursor, vps);
for (i = 0; i < num; i++) {
match = fr_dcursor_filter_next(&list_cursor, fr_pair_matches_da, da[i]);
if (!match) {
if (rs_build_filter(&conf->filter_request_vps, conf->filter_request) < 0) usage(64);
- type = fr_dcursor_iter_by_da_init(&cursor, &conf->filter_request_vps, attr_packet_type);
+ type = fr_pair_dcursor_by_da_init(&cursor, &conf->filter_request_vps, attr_packet_type);
if (type) {
fr_dcursor_remove(&cursor);
conf->filter_request_code = type->vp_uint32;
if (rs_build_filter(&conf->filter_response_vps, conf->filter_response) < 0) usage(64);
- type = fr_dcursor_iter_by_da_init(&cursor, &conf->filter_response_vps, attr_packet_type);
+ type = fr_pair_dcursor_by_da_init(&cursor, &conf->filter_response_vps, attr_packet_type);
if (type) {
fr_dcursor_remove(&cursor);
conf->filter_response_code = type->vp_uint32;
* attribute grouping to coalesce all related index
* attributes under a single request OID.
*/
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(head));
+ for (vp = fr_pair_dcursor_init(&cursor, head);
vp;
vp = fr_dcursor_next(&cursor)) {
fr_dict_attr_t const *common;
return EXIT_FAILURE;
}
fr_pair_list_init(&request_vps);
- fr_dcursor_init(&cursor, fr_pair_list_order(&request_vps));
+ fr_pair_dcursor_init(&cursor, &request_vps);
NEXT_LINE(line, buffer);
#endif
}
- for (vp = fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(&head),
- tp->next_encodable ? tp->next_encodable : fr_proto_next_encodable,
- cc->tmpl_rules.dict_def ? cc->tmpl_rules.dict_def : cc->config->dict, fr_pair_t);
+ for (vp = fr_pair_dcursor_iter_init(&cursor, &head,
+ tp->next_encodable ? tp->next_encodable : fr_proto_next_encodable,
+ cc->tmpl_rules.dict_def ? cc->tmpl_rules.dict_def : cc->config->dict);
vp;
vp = fr_dcursor_current(&cursor)) {
slen = tp->func(&FR_DBUFF_TMP(enc_p, enc_end), &cursor, encode_ctx);
}
};
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ for (vp = fr_pair_dcursor_init(&cursor, &request->request_pairs);
vp;
vp = fr_dcursor_next(&cursor)) {
/*
} /* loop over the VP's we read in */
if (fr_debug_lvl) {
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ for (vp = fr_pair_dcursor_init(&cursor, &request->request_pairs);
vp;
vp = fr_dcursor_next(&cursor)) {
/*
dv = fr_dict_enum_by_value(attr_packet_type, fr_box_uint32(packet->code));
if (dv) fprintf(fp, "%s\n", dv->name);
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(list));
+ for (vp = fr_pair_dcursor_init(&cursor, list);
vp;
vp = fr_dcursor_next(&cursor)) {
/*
/*
* Get only EAP-Message attribute list
*/
- vp = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_message);
+ vp = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_message);
if (!vp) {
fr_strerror_const("EAP-Message not found");
return NULL;
ptr += 4;
end = ptr + total;
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->reply_pairs));
+ fr_pair_dcursor_init(&cursor, &request->reply_pairs);
while ((vp = fr_dcursor_current(&cursor)) && (ptr < end)) {
/*
* Skip things which shouldn't be in channel bindings.
chbind_packet_t *packet;
fr_dcursor_t cursor;
- if (!fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_channel_binding_message)) return NULL;
+ if (!fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_channel_binding_message)) return NULL;
/*
* Compute the total length of the channel binding data.
* Group attributes with similar lineages together
*/
fr_pair_list_sort(to_encode, fr_pair_cmp_by_parent_num);
- if (fr_dcursor_init(&cursor, fr_pair_list_order(to_encode)) == vp) {
+ if (fr_pair_dcursor_init(&cursor, to_encode) == vp) {
fr_dcursor_next(&cursor); /* Skip subtype if it came out first */
}
case FR_EAP_METHOD_SIM:
case FR_EAP_METHOD_AKA:
case FR_EAP_METHOD_AKA_PRIME:
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&cursor, &request->request_pairs);
decode_ctx = mod_session->ctx;
decode_ctx.hmac_extra = mod_session->response_hmac_extra;
fr_dcursor_t cursor;
int i;
- for (i = 0, (kc = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_kc));
+ for (i = 0, (kc = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_kc));
(i < idx) && (kc = fr_dcursor_next(&cursor));
i++);
if (!kc) {
return -1;
}
- for (i = 0, (rand = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
+ for (i = 0, (rand = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
(i < idx) && (rand = fr_dcursor_next(&cursor));
i++);
if (!rand) {
return -1;
}
- for (i = 0, (sres = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_sres));
+ for (i = 0, (sres = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_sres));
(i < idx) && (sres = fr_dcursor_next(&cursor));
i++);
if (!sres) {
/*
* Fetch CK
*/
- for (i = 0, (ck = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_ck));
+ for (i = 0, (ck = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_ck));
(i < idx) && (ck = fr_dcursor_next(&cursor));
i++);
if (!ck) {
/*
* Fetch IK
*/
- for (i = 0, (ik = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_ik));
+ for (i = 0, (ik = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_ik));
(i < idx) && (ik = fr_dcursor_next(&cursor));
i++);
if (!ik) {
/*
* Fetch RAND
*/
- for (i = 0, (rand = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
+ for (i = 0, (rand = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_rand));
(i < idx) && (rand = fr_dcursor_next(&cursor));
i++);
if (!rand) {
/*
* Fetch XRES
*/
- for (i = 0, (xres = fr_dcursor_iter_by_da_init(&cursor, vps, attr_eap_aka_sim_xres));
+ for (i = 0, (xres = fr_pair_dcursor_by_da_init(&cursor, vps, attr_eap_aka_sim_xres));
(i < idx) && (xres = fr_dcursor_next(&cursor));
i++);
if (!xres) {
if (request) {
da = fr_dict_attr_child_by_num(fr_dict_root(fr_dict_internal()), FR_EXEC_EXPORT);
if (da) {
- for (vp = fr_dcursor_iter_by_da_init(&cursor, &request->control_pairs, da);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, &request->control_pairs, da);
vp && (i < (env_len - 1));
vp = fr_dcursor_next(&cursor)) {
env_p[i++] = UNCONST(char *, vp->vp_strvalue);
if (request) {
da = fr_dict_attr_child_by_num(fr_dict_root(fr_dict_internal()), FR_EXEC_EXPORT);
if (da) {
- for (vp = fr_dcursor_iter_by_da_init(&cursor, &request->control_pairs, da);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, &request->control_pairs, da);
vp && (i < (envlen - 1));
vp = fr_dcursor_next(&cursor)) {
DEBUG3("export %pV", &vp->data);
}
fr_pair_list_copy(NULL, &args, &ef->trigger_args);
- fr_dcursor_init(&cursor, fr_pair_list_order(&args));
+ fr_pair_dcursor_init(&cursor, &args);
MEM(vp = fr_pair_afrom_da(NULL, da));
fr_pair_value_strdup(vp, entry->filename, false);
*/
if (tmpl_copy_pairs(ctx, &found, request, map->rhs) < 0) return 0;
- vp = fr_dcursor_init(&from, fr_pair_list_order(&found));
+ vp = fr_pair_dcursor_init(&from, &found);
/*
* Src/Dst attributes don't match, convert src attributes
return 0; /* No pairs returned */
}
- (void)fr_dcursor_init(&from, fr_pair_list_order(&vp_head));
+ (void)fr_pair_dcursor_init(&from, &vp_head);
while ((vp = fr_dcursor_remove(&from))) {
map_t *mod;
tmpl_rules_t rules;
map_list_mod_to_vps(parent, &vp_from, vlm);
if (fr_pair_list_empty(&vp_from)) goto finish;
- fr_dcursor_init(&from, fr_pair_list_order(&vp_from));
+ fr_pair_dcursor_init(&from, &vp_from);
fr_dcursor_merge(&list, &from); /* Merge first (insert after current attribute) */
fr_dcursor_free_item(&list); /* Then free the current attribute */
int replaced = 0;
fr_pair_t *known_good, *new;
- for (known_good = fr_dcursor_iter_by_ancestor_init(&cursor, &request->control_pairs, attr_root);
+ for (known_good = fr_pair_dcursor_by_ancestor_init(&cursor, &request->control_pairs, attr_root);
known_good;
known_good = fr_dcursor_next(&cursor)) {
if (!fr_cond_assert(known_good->da->attr < NUM_ELEMENTS(password_info))) return -1;
fr_dcursor_t cursor;
fr_pair_t *known_good;
- for (known_good = fr_dcursor_iter_by_ancestor_init(&cursor, &request->control_pairs, attr_root);
+ for (known_good = fr_pair_dcursor_by_ancestor_init(&cursor, &request->control_pairs, attr_root);
known_good;
known_good = fr_dcursor_next(&cursor)) {
password_info_t *info;
fr_pair_t *op;
fr_pair_list_init(&head);
- fr_dcursor_init(&request_cursor, fr_pair_list_order(&request->request_pairs));
- fr_dcursor_iter_by_da_init(&op_cursor, &request->request_pairs, attr_snmp_operation);
- fr_dcursor_init(&reply_cursor, fr_pair_list_order(&request->reply_pairs));
- fr_dcursor_init(&out_cursor, fr_pair_list_order(&head));
+ fr_pair_dcursor_init(&request_cursor, &request->request_pairs);
+ fr_pair_dcursor_by_da_init(&op_cursor, &request->request_pairs, attr_snmp_operation);
+ fr_pair_dcursor_init(&reply_cursor, &request->reply_pairs);
+ fr_pair_dcursor_init(&out_cursor, &head);
RDEBUG2("Processing SNMP stats request");
}
}
- for (vp = fr_dcursor_iter_by_ancestor_init(&request_cursor, &request->request_pairs, attr_snmp_root);
+ for (vp = fr_pair_dcursor_by_ancestor_init(&request_cursor, &request->request_pairs, attr_snmp_root);
vp;
vp = fr_dcursor_next(&request_cursor)) {
fr_proto_da_stack_build(&da_stack, vp->da);
* by the state context.
*/
if (entry->ctx) {
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&entry->ctx->children));
+ for (vp = fr_pair_dcursor_init(&cursor, &entry->ctx->children);
vp;
vp = fr_dcursor_next(&cursor)) {
fr_assert(entry->ctx == talloc_parent(vp));
.func = _tmpl_cursor_child_eval,
.list_ctx = list_ctx
};
- fr_dcursor_init(&ns->group.cursor, fr_pair_list_order(list));
+ fr_pair_dcursor_init(&ns->group.cursor, list);
fr_dlist_insert_tail(&cc->nested, ns);
}
/*
* Get the first entry from the tmpl
*/
- vp = fr_dcursor_talloc_iter_init(cursor, fr_pair_list_order(list_head), _tmpl_cursor_next, cc, fr_pair_t);
+ vp = fr_pair_dcursor_iter_init(cursor, list_head, _tmpl_cursor_next, cc);
if (!vp) {
if (err) {
*err = -1;
* Encode the session-state contents and
* add it to the ticket.
*/
- for (vp = fr_dcursor_init(&dcursor, fr_pair_list_order(&request->session_state_pairs));
+ for (vp = fr_pair_dcursor_init(&dcursor, &request->session_state_pairs);
vp;
vp = fr_dcursor_current(&dcursor)) {
slen = fr_internal_encode_pair(&dbuff, &dcursor, NULL);
foreach->request = request;
foreach->depth = foreach_depth;
fr_pair_list_append(&foreach->vps, &vps);
- fr_dcursor_talloc_init(&foreach->cursor, fr_pair_list_order(&foreach->vps), fr_pair_t);
+ fr_pair_dcursor_init(&foreach->cursor, &foreach->vps);
#ifndef NDEBUG
foreach->indent = request->log.unlang_indent;
#endif
MEM(frame->state = state = talloc_zero(stack, unlang_frame_state_xlat_t));
state->exp = talloc_get_type_abort_const(exp, xlat_exp_t); /* Ensure the node is valid */
- fr_dcursor_talloc_init(&state->values, out, fr_value_box_t);
+ fr_dcursor_init(&state->values, out);
fr_value_box_list_init(&state->rhead);
state->ctx = ctx;
fr_dcursor_t cursor;
fr_value_box_list_init(&head);
- fr_dcursor_talloc_init(&cursor, &head, fr_value_box_t);
+ fr_dcursor_init(&cursor, &head);
XLAT_DEBUG("%.*sxlat aprint %d %s", lvl, xlat_spaces, node->type, node->fmt);
* Both have iterators...
*/
b_iter = b->iter;
- b_uctx = b->uctx;
+ b_uctx = b->iter_uctx;
/*
* Deal with the case where the two iterators
*/
fr_dcursor_copy(b, a);
b->iter = b_iter;
- b->uctx = b_uctx;
+ b->iter_uctx = b_uctx;
} while ((a->current = dcursor_next(a, a->current)));
return NULL;
void *current; //!< The current item in the dlist.
void *prev; //!< The previous item in the dlist.
fr_dcursor_iter_t iter; //!< Iterator function.
+ void *iter_uctx; //!< to pass to iterator function.
fr_dcursor_insert_t insert; //!< Callback function on insert.
fr_dcursor_remove_t remove; //!< Callback function on delete.
+ void *mod_uctx; //!< to pass to modification functions.
bool is_const; //!< The list we're iterating over is immutable.
- void *uctx; //!< to pass to iterator function.
} fr_dcursor_t;
typedef struct {
if (!cursor->iter) return (fr_dlist_head(cursor->dlist)); /* Fast path without custom iter */
current = fr_dlist_head(cursor->dlist);
- return cursor->iter(cursor->dlist, current, cursor->uctx);
+ return cursor->iter(cursor->dlist, current, cursor->iter_uctx);
}
#ifndef TALLOC_GET_TYPE_ABORT_NOOP
* The iterator can just return what it was passed for curr
* if it just wants to advance by one.
*/
- return cursor->iter(cursor->dlist, next, cursor->uctx);
+ return cursor->iter(cursor->dlist, next, cursor->iter_uctx);
}
/** Copy cursor parameters and state.
if (cursor->dlist->type) _talloc_get_type_abort(v, cursor->dlist->type, __location__);
#endif
- if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->uctx)) < 0) return ret;
+ if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->mod_uctx)) < 0) return ret;
/*
* Insert at the head of the list
if (cursor->dlist->type) _talloc_get_type_abort(v, cursor->dlist->type, __location__);
#endif
- if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->uctx)) < 0) return ret;
+ if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->mod_uctx)) < 0) return ret;
fr_dlist_insert_tail(cursor->dlist, v);
return 0;
}
- if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->uctx)) < 0) return ret;
+ if (cursor->insert) if ((ret = cursor->insert(cursor->dlist, v, cursor->mod_uctx)) < 0) return ret;
fr_dlist_insert_after(cursor->dlist, cursor->current, v);
v = cursor->current;
- if (cursor->remove) if ((ret = cursor->remove(cursor->dlist, v, cursor->uctx)) < 0) return ret;
+ if (cursor->remove) if ((ret = cursor->remove(cursor->dlist, v, cursor->mod_uctx)) < 0) return ret;
p = fr_dcursor_list_prev_peek(cursor);
fr_dlist_remove(cursor->dlist, v);
}
p = fr_dcursor_list_prev_peek(cursor);
- if (cursor->remove) if ((ret = cursor->remove(cursor->dlist, v, cursor->uctx)) < 0) return ret;
+ if (cursor->remove) if ((ret = cursor->remove(cursor->dlist, v, cursor->mod_uctx)) < 0) return ret;
fr_dlist_replace(cursor->dlist, cursor->current, r);
} while (v);
}
-/** Initialise a cursor with runtime talloc type safety checks and a custom iterator
+/** Initialise a cursor with a custom iterator
*
* @param[in] _cursor to initialise.
* @param[in] _head of item list.
* @param[in] _iter function.
* @param[in] _uctx _iter function _uctx.
- * @param[in] _type Talloc type i.e. fr_pair_t or fr_value_box_t.
* @return
* - NULL if _head does not point to any items, or the iterator matches no items
* in the current list.
* - The first item returned by the iterator.
*/
-#define fr_dcursor_talloc_iter_init(_cursor, _head, _iter, _uctx, _type) \
+#define fr_dcursor_iter_mod_init(_cursor, _head, _iter, _iter_uctx, _insert, _remove, _mod_uctx) \
_fr_dcursor_init(_cursor, \
_head, \
_iter, \
- NULL, \
- NULL, \
+ _iter_uctx, \
+ _insert, \
+ _remove, \
+ _mod_uctx, \
_Generic((_head), \
fr_dlist_head_t * : false, \
fr_dlist_head_t const * : true \
- ), \
- _uctx)
+ ))
/** Initialise a cursor with a custom iterator
*
_fr_dcursor_init(_cursor, \
_head, \
_iter, \
- NULL, \
- NULL, \
- _Generic((_head), \
- fr_dlist_head_t * : false, \
- fr_dlist_head_t const * : true \
- ), \
- _uctx)
-
-/** Initialise a cursor with runtime talloc type safety checks
- *
- * @param[in] _cursor to initialise.
- * @param[in] _head of item list.
- * @param[in] _type Talloc type i.e. fr_pair_t or fr_value_box_t.
- * @return
- * - NULL if _head does not point to any items.
- * - The first item in the list.
- */
-#define fr_dcursor_talloc_init(_cursor, _head, _type) \
- _fr_dcursor_init(_cursor, \
- _head, \
+ _uctx, \
NULL, \
NULL, \
NULL, \
_Generic((_head), \
fr_dlist_head_t * : false, \
fr_dlist_head_t const * : true \
- ), \
- NULL)
+ ))
/** Initialise a cursor
*
NULL, \
NULL, \
NULL, \
+ NULL, \
+ NULL, \
_Generic((_head), \
fr_dlist_head_t * : false, \
fr_dlist_head_t const * : true \
- ), \
- NULL)
+ ))
/** Setup a cursor to iterate over attribute items in dlists
*
* @param[in] cursor Where to initialise the cursor (uses existing structure).
* @param[in] head of dlist.
* @param[in] iter Iterator callback.
+ * @param[in] iter_uctx to pass to iterator function.
* @param[in] insert Callback for inserts.
* @param[in] remove Callback for removals.
+ * @param[in] mod_uctx to pass to modification functions.
* @param[in] is_const Don't allow modification of the underlying list.
- * @param[in] uctx to pass to iterator function.
* @return the attribute pointed to by v.
*
* @hidecallergraph
*/
static inline CC_HINT(nonnull(1,2))
void *_fr_dcursor_init(fr_dcursor_t *cursor, fr_dlist_head_t const *head,
- fr_dcursor_iter_t iter, fr_dcursor_insert_t insert,
- fr_dcursor_remove_t remove, bool is_const, void const *uctx)
+ fr_dcursor_iter_t iter, void const *iter_uctx,
+ fr_dcursor_insert_t insert, fr_dcursor_remove_t remove, void const *mod_uctx, bool is_const)
{
*cursor = (fr_dcursor_t){
.dlist = UNCONST(fr_dlist_head_t *, head),
.iter = iter,
+ .iter_uctx = UNCONST(void *, iter_uctx),
.insert = insert,
.remove = remove,
- .uctx = UNCONST(void *, uctx),
+ .mod_uctx = UNCONST(void *, mod_uctx),
.is_const = is_const
};
if (!fr_dlist_empty(cursor->dlist)) return fr_dcursor_next(cursor); /* Initialise current */
TEST_CHECK(!fr_dcursor_current(&cursor));
TEST_CHECK(!fr_dcursor_list_prev_peek(&cursor));
TEST_CHECK(!fr_dcursor_list_next_peek(&cursor));
- TEST_CHECK(cursor.uctx == &cursor);
+ TEST_CHECK(cursor.iter_uctx == &cursor);
}
static void test_init_1i_start(void)
test_list_init(&list);
- _fr_dcursor_init(&cursor, (fr_dlist_head_t *)&list, test_iter, NULL, NULL, false, NULL);
+ _fr_dcursor_init(&cursor, (fr_dlist_head_t *)&list, test_iter, NULL, NULL, NULL, NULL, false);
TEST_CHECK(!fr_dcursor_remove(&cursor));
}
return pair_children(vp);
}
+/** Keep attr tree and sublists synced on cursor insert
+ *
+ * @param[in] list Underlying order list from the fr_pair_list_t.
+ * @param[in] to_insert fr_pair_t being inserted.
+ * @param[in] uctx fr_pair_list_t containing the order list.
+ * @return
+ * - 0 on success.
+ */
+static int _pair_list_dcursor_insert(UNUSED fr_dlist_head_t *list, UNUSED void *to_insert, UNUSED void *uctx)
+{
+ return 0;
+}
+
+/** Keep attr tree and sublists synced on cursor insert
+ *
+ * @param[in] list Underlying order list from the fr_pair_list_t.
+ * @param[in] to_remove fr_pair_t being removed.
+ * @param[in] uctx fr_pair_list_t containing the order list.
+ * @return
+ * - 0 on success.
+ */
+static int _pair_list_dcursor_remove(UNUSED fr_dlist_head_t *list, UNUSED void *to_remove, UNUSED void *uctx)
+{
+ return 0;
+}
+
+/** Initialises a special dcursor with callbacks that will maintain the attr sublists correctly
+ *
+ * Filters can be applied later with fr_dcursor_filter_set.
+ *
+ * @note This is the only way to use a dcursor in non-const mode with fr_pair_list_t.
+ *
+ * @param[out] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] iter Iterator to use when filtering pairs.
+ * @param[in] uctx To pass to iterator.
+ * @param[in] is_const whether the fr_pair_list_t is const.
+ * @return
+ * - NULL if src does not point to any items.
+ * - The first pair in the list.
+ */
+fr_pair_t *_fr_pair_dcursor_iter_init(fr_dcursor_t *cursor, fr_pair_list_t const *list,
+ fr_dcursor_iter_t iter, void const *uctx,
+ bool is_const)
+{
+ return _fr_dcursor_init(cursor, &list->order,
+ iter, uctx,
+ _pair_list_dcursor_insert, _pair_list_dcursor_remove, list, is_const);
+}
+
+/** Initialises a special dcursor with callbacks that will maintain the attr sublists correctly
+ *
+ * Filters can be applied later with fr_dcursor_filter_set.
+ *
+ * @note This is the only way to use a dcursor in non-const mode with fr_pair_list_t.
+ *
+ * @param[out] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] is_const whether the fr_pair_list_t is const.
+ * @return
+ * - NULL if src does not point to any items.
+ * - The first pair in the list.
+ */
+fr_pair_t *_fr_pair_dcursor_init(fr_dcursor_t *cursor, fr_pair_list_t const *list,
+ bool is_const)
+{
+ return _fr_dcursor_init(cursor, &list->order,
+ NULL, NULL,
+ _pair_list_dcursor_insert, _pair_list_dcursor_remove, list, is_const);
+}
+
+
+/** Initialise a cursor that will return only attributes matching the specified #fr_dict_attr_t
+ *
+ * @param[in] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] da to search for.
+ * @param[in] is_const whether the fr_pair_list_t is const.
+ * @return
+ * - The first matching pair.
+ * - NULL if no pairs match.
+ */
+fr_pair_t *_fr_pair_dcursor_by_da_init(fr_dcursor_t *cursor,
+ fr_pair_list_t const *list, fr_dict_attr_t const *da,
+ bool is_const)
+{
+ return _fr_dcursor_init(cursor, &list->order,
+ fr_pair_iter_next_by_da, da,
+ _pair_list_dcursor_insert, _pair_list_dcursor_remove, list, is_const);
+}
+
+/** Initialise a cursor that will return only attributes descended from the specified #fr_dict_attr_t
+ *
+ * @param[in] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] da who's decentness to search for.
+ * @param[in] is_const whether the fr_pair_list_t is const.
+ * @return
+ * - The first matching pair.
+ * - NULL if no pairs match.
+ */
+fr_pair_t *_fr_pair_dcursor_by_ancestor_init(fr_dcursor_t *cursor,
+ fr_pair_list_t const *list, fr_dict_attr_t const *da,
+ bool is_const)
+{
+ return _fr_dcursor_init(cursor, &list->order,
+ fr_pair_iter_next_by_ancestor, da,
+ _pair_list_dcursor_insert, _pair_list_dcursor_remove, list, is_const);
+}
+
/** Get the head of a valuepair list
*
* @param[in] list to return the head of
bool fr_pair_matches_da(void const *item, void const *uctx) CC_HINT(nonnull);
-/** Initialise a cursor that will return only attributes matching the specified #fr_dict_attr_t
- *
- * @param[in] cursor to initialise.
- * @param[in] list to iterate over.
- * @param[in] da to search for.
- * @return
- * - The first matching pair.
- * - NULL if no pairs match.
- */
-static inline CC_HINT(nonnull)
-fr_pair_t *fr_dcursor_iter_by_da_init(fr_dcursor_t *cursor,
- fr_pair_list_t *list, fr_dict_attr_t const *da)
-{
- return fr_dcursor_talloc_iter_init(cursor, &list->order, fr_pair_iter_next_by_da, da, fr_pair_t);
-}
-
-/** Initialise a cursor that will return only attributes descended from the specified #fr_dict_attr_t
- *
- * @param[in] cursor to initialise.
- * @param[in] list to iterate over.
- * @param[in] da who's decentness to search for.
- * @return
- * - The first matching pair.
- * - NULL if no pairs match.
- */
-static inline CC_HINT(nonnull)
-fr_pair_t *fr_dcursor_iter_by_ancestor_init(fr_dcursor_t *cursor,
- fr_pair_list_t *list, fr_dict_attr_t const *da)
-{
- return fr_dcursor_talloc_iter_init(cursor, &list->order, fr_pair_iter_next_by_ancestor, da, fr_pair_t);
-}
-
/** @hidecallergraph */
unsigned int fr_pair_count_by_da(fr_pair_list_t const *list, fr_dict_attr_t const *da)
CC_HINT(nonnull);
/* functions for FR_TYPE_STRUCTURAL */
fr_pair_list_t *fr_pair_children(fr_pair_t *head) CC_HINT(nonnull);
+/** Initialises a special dcursor with callbacks that will maintain the attr sublists correctly
+ *
+ * Filters can be applied later with fr_dcursor_filter_set.
+ *
+ * @note This is the only way to use a dcursor in non-const mode with fr_pair_list_t.
+ *
+ * @param[out] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] iter Iterator to use when filtering pairs.
+ * @param[in] uctx To pass to iterator.
+ * @return
+ * - NULL if src does not point to any items.
+ * - The first pair in the list.
+ */
+#define fr_pair_dcursor_iter_init(_cursor, _list, _iter, _uctx) \
+ _fr_pair_dcursor_iter_init(_cursor, \
+ _list, \
+ _iter, \
+ _uctx, \
+ _Generic((_list), \
+ fr_pair_list_t * : false, \
+ fr_pair_list_t const * : true \
+ ))
+fr_pair_t *_fr_pair_dcursor_iter_init(fr_dcursor_t *cursor, fr_pair_list_t const *list,
+ fr_dcursor_iter_t iter, void const *uctx,
+ bool is_const) CC_HINT(nonnull);
+
+/** Initialises a special dcursor with callbacks that will maintain the attr sublists correctly
+ *
+ * Filters can be applied later with fr_dcursor_filter_set.
+ *
+ * @note This is the only way to use a dcursor in non-const mode with fr_pair_list_t.
+ *
+ * @param[out] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @return
+ * - NULL if src does not point to any items.
+ * - The first pair in the list.
+ */
+#define fr_pair_dcursor_init(_cursor, _list) \
+ _fr_pair_dcursor_init(_cursor, \
+ _list, \
+ _Generic((_list), \
+ fr_pair_list_t * : false, \
+ fr_pair_list_t const * : true \
+ ))
+fr_pair_t *_fr_pair_dcursor_init(fr_dcursor_t *cursor, fr_pair_list_t const *list,
+ bool is_const) CC_HINT(nonnull);
+
+/** Initialise a cursor that will return only attributes matching the specified #fr_dict_attr_t
+ *
+ * @param[in] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] da to search for.
+ * @return
+ * - The first matching pair.
+ * - NULL if no pairs match.
+ */
+#define fr_pair_dcursor_by_da_init(_cursor, _list, _da) \
+ _fr_pair_dcursor_by_da_init(_cursor, \
+ _list, \
+ _da, \
+ _Generic((_list), \
+ fr_pair_list_t * : false, \
+ fr_pair_list_t const * : true \
+ ))
+fr_pair_t *_fr_pair_dcursor_by_da_init(fr_dcursor_t *cursor,
+ fr_pair_list_t const *list, fr_dict_attr_t const *da,
+ bool is_const) CC_HINT(nonnull);
+
+/** Initialise a cursor that will return only attributes descended from the specified #fr_dict_attr_t
+ *
+ * @param[in] cursor to initialise.
+ * @param[in] list to iterate over.
+ * @param[in] da who's decentness to search for.
+ * @return
+ * - The first matching pair.
+ * - NULL if no pairs match.
+ */
+#define fr_pair_dcursor_by_ancestor_init(_cursor, _list, _da) \
+ _fr_pair_dcursor_by_ancestor_init(_cursor, \
+ _list, \
+ _da, \
+ _Generic((_list), \
+ fr_pair_list_t * : false, \
+ fr_pair_list_t const * : true \
+ ))
+fr_pair_t *_fr_pair_dcursor_by_ancestor_init(fr_dcursor_t *cursor,
+ fr_pair_list_t const *list, fr_dict_attr_t const *da,
+ bool is_const) CC_HINT(nonnull);
+
/** Compare two attributes using and operator.
*
* @return
*/
our_out = FR_SBUFF_NO_ADVANCE(out);
FR_SBUFF_IN_CHAR_RETURN(&our_out, '{', ' ');
- for (child = fr_dcursor_init(&cursor, fr_pair_list_order(&vp->vp_group));
+ for (child = fr_pair_dcursor_init(&cursor, &vp->vp_group);
child != NULL;
child = fr_dcursor_next(&cursor)) {
FR_SBUFF_RETURN(fr_pair_print, &our_out, vp, child);
TEST_CHECK(vp && vp->da->flags.is_unknown == true);
}
-static void test_fr_dcursor_iter_by_da_init(void)
+static void test_fr_pair_dcursor_by_da_init(void)
{
fr_pair_t *vp, *needle;
fr_dcursor_t cursor;
- TEST_CASE("Searching for fr_dict_attr_test_uint32 using fr_dcursor_iter_by_da_init()");
+ TEST_CASE("Searching for fr_dict_attr_test_uint32 using fr_pair_dcursor_by_da_init()");
needle = NULL;
- for (vp = fr_dcursor_iter_by_da_init(&cursor, &test_pairs, fr_dict_attr_test_uint32);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, &test_pairs, fr_dict_attr_test_uint32);
vp;
vp = fr_dcursor_next(&cursor)) {
if (!needle) {
TEST_CHECK(needle && needle->da == fr_dict_attr_test_uint32);
}
-static void test_fr_dcursor_iter_by_ancestor_init(void)
+static void test_fr_pair_dcursor_by_ancestor_init(void)
{
fr_pair_t *vp, *needle;
fr_dcursor_t cursor;
- TEST_CASE("Searching for fr_dict_attr_test_tlv_string as ascend of fr_dict_attr_test_tlv using fr_dcursor_iter_by_ancestor_init()");
+ TEST_CASE("Searching for fr_dict_attr_test_tlv_string as ascend of fr_dict_attr_test_tlv using fr_pair_dcursor_by_ancestor_init()");
needle = NULL;
- for (vp = fr_dcursor_iter_by_ancestor_init(&cursor, &test_pairs, fr_dict_attr_test_tlv);
+ for (vp = fr_pair_dcursor_by_ancestor_init(&cursor, &test_pairs, fr_dict_attr_test_tlv);
vp;
vp = fr_dcursor_next(&cursor)) {
TEST_CHECK(vp != NULL);
fr_pair_append(&local_pairs, fr_pair_afrom_da(autofree, fr_dict_attr_test_tlv));
/* lets' count */
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&local_pairs));
- vp;
- vp = fr_dcursor_next(&cursor)) count++;
+ for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
+ vp;
+ vp = fr_dcursor_next(&cursor)) count++;
TEST_CASE("Expected (count == 3)");
TEST_CHECK(count == 3);
TEST_CHECK(fr_pair_prepend_by_da(ctx, NULL, &local_pairs, fr_dict_attr_test_string) == 0);
/* lets' count */
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&local_pairs));
- vp;
- vp = fr_dcursor_next(&cursor)) {
+ for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
+ vp;
+ vp = fr_dcursor_next(&cursor)) {
TEST_CASE("Expected (vp->da == fr_dict_attr_test_string)");
TEST_CHECK(vp->da == fr_dict_attr_test_string);
}
TEST_CHECK(fr_pair_list_copy_by_da(autofree, &local_pairs, &test_pairs, fr_dict_attr_test_string, 0) > 0);
TEST_CASE("The 'local_pairs' should have only fr_dict_attr_test_string");
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&local_pairs));
- vp;
- vp = fr_dcursor_next(&cursor)) {
+ for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
+ vp;
+ vp = fr_dcursor_next(&cursor)) {
TEST_CASE("Validating PAIR_VERIFY()");
PAIR_VERIFY(vp);
TEST_CHECK(fr_pair_list_copy_by_ancestor(autofree, &local_pairs, &test_pairs, fr_dict_attr_test_tlv, 0) > 0);
TEST_CASE("The 'local_pairs' should have only fr_dict_attr_test_tlv_string (ancestor of 'Test-TLV-Root'");
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&local_pairs));
- vp;
- vp = fr_dcursor_next(&cursor)) {
+ for (vp = fr_pair_dcursor_init(&cursor, &local_pairs);
+ vp;
+ vp = fr_dcursor_next(&cursor)) {
TEST_CASE("Validating PAIR_VERIFY()");
PAIR_VERIFY(vp);
fr_pair_list_sort(&local_pairs, fr_pair_cmp_by_da);
TEST_CASE("1st (da == fr_dict_attr_test_string)");
- TEST_CHECK((vp = fr_dcursor_init(&cursor, fr_pair_list_order(&local_pairs))) != NULL);
+ TEST_CHECK((vp = fr_pair_dcursor_init(&cursor, &local_pairs)) != NULL);
TEST_CHECK(vp && vp->da == fr_dict_attr_test_string);
TEST_CASE("2nd (da == fr_dict_attr_test_octets)");
{ "fr_pair_steal", test_fr_pair_steal },
/* Searching and list modification */
- { "fr_dcursor_iter_by_da_init", test_fr_dcursor_iter_by_da_init },
- { "fr_dcursor_iter_by_ancestor_init", test_fr_dcursor_iter_by_ancestor_init },
+ { "fr_dcursor_iter_by_da_init", test_fr_pair_dcursor_by_da_init },
+ { "fr_pair_dcursor_by_ancestor_init", test_fr_pair_dcursor_by_ancestor_init },
{ "fr_pair_to_unknown", test_fr_pair_to_unknown },
{ "fr_pair_find_by_da", test_fr_pair_find_by_da },
{ "fr_pair_find_by_child_num", test_fr_pair_find_by_child_num },
fr_pair_t *sorted = fr_dcursor_current(parent_cursor); /* NOT const */
fr_pair_list_sort(&sorted->vp_group, pair_sort_increasing);
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&sorted->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &sorted->vp_group);
/*
* Build the da_stack for the new structure.
}
lineno = 1;
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&cursor, &request->request_pairs);
fr_dcursor_tail(&cursor); /* Ensure we only free what we add on error */
fr_pair_list_init(&tmp_list);
request->reply->socket.inet.src_ipaddr = client->src_ipaddr;
}
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(&request->reply_pairs), fr_proto_next_encodable, dict_vmps, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, &request->reply_pairs, fr_proto_next_encodable, dict_vmps);
data_len = fr_vmps_encode(&FR_DBUFF_TMP(buffer, buffer_len), request->packet->data,
request->reply->code, request->reply->id, &cursor);
/*
* Clear control attributes
*/
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(&request->control_pairs));
+ for (vp = fr_pair_dcursor_init(&cursor, &request->control_pairs);
vp;
vp = fr_dcursor_next(&cursor)) {
again:
* Copy the EAP-Message back to the tunnel.
*/
- for (vp = fr_dcursor_iter_by_da_init(&cursor, reply_list, attr_eap_message);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, reply_list, attr_eap_message);
vp;
vp = fr_dcursor_next(&cursor)) {
eap_fast_tlv_append(tls_session, attr_eap_fast_eap_payload, true, vp->vp_length, vp->vp_octets);
/*
* Add the tunneled attributes to the request request.
*/
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&cursor, &request->request_pairs);
if (eap_ttls_decode_pair(request, request->request_ctx, &cursor, fr_dict_root(fr_dict_internal()),
data, data_len, tls_session->ssl) < 0) {
RPEDEBUG("Decoding TTLS TLVs failed");
* We return RLM_MODULE_INVALID here as an indication
* the caller should try a dynamic group lookup instead.
*/
- vp = fr_dcursor_iter_by_da_init(&cursor, &request->control_pairs, inst->cache_da);
+ vp = fr_pair_dcursor_by_da_init(&cursor, &request->control_pairs, inst->cache_da);
if (!vp) RETURN_MODULE_INVALID;
for (vp = fr_dcursor_current(&cursor);
t->type->vp_uint32 = (uint32_t) type;
t->lvl->vp_uint32 = (uint32_t) lvl;
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&cursor, &request->request_pairs);
fr_dcursor_prepend(&cursor, t->msg);
fr_dcursor_prepend(&cursor, t->type);
fr_dcursor_prepend(&cursor, t->lvl);
/*
* @fixme Packet list should be light user data too at some point
*/
- fr_dcursor_iter_by_da_init(&cursor, &request->request_pairs, da);
+ fr_pair_dcursor_by_da_init(&cursor, &request->request_pairs, da);
for (index = (int) lua_tointeger(L, -1); index >= 0; index--) {
vp = fr_dcursor_next(&cursor);
/*
* @fixme Packet list should be light user data too at some point
*/
- fr_dcursor_iter_by_da_init(&cursor, &request->request_pairs, da);
+ fr_pair_dcursor_by_da_init(&cursor, &request->request_pairs, da);
for (index = lua_tointeger(L, -2); index >= 0; index--) {
vp = fr_dcursor_next(&cursor);
REDEBUG("Failed allocating user data to hold cursor");
return -1;
}
- fr_dcursor_iter_by_da_init(cursor, &request->request_pairs, da); /* @FIXME: Shouldn't use list head */
+ fr_pair_dcursor_by_da_init(cursor, &request->request_pairs, da); /* @FIXME: Shouldn't use list head */
lua_pushcclosure(L, _lua_pair_iterator, 1);
REDEBUG("Failed allocating user data to hold cursor");
return -1;
}
- fr_dcursor_init(cursor, fr_pair_list_order(&request->request_pairs)); /* @FIXME: Shouldn't use list head */
+ fr_pair_dcursor_init(cursor, &request->request_pairs); /* @FIXME: Shouldn't use list head */
lua_pushlightuserdata(L, cursor);
lua_pushcclosure(L, _lua_list_iterator, 1);
/* Attribute list table */
fr_pair_list_sort(&request->request_pairs, fr_pair_cmp_by_da);
- fr_dcursor_init(&cursor, fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&cursor, &request->request_pairs);
/*
* Setup the environment
key = fr_pair_find_by_da(&request->request_pairs, inst->keyattr, 0);
if (!key) RETURN_MODULE_NOTFOUND;
- for (i = fr_dcursor_iter_by_da_init(&cursor, &request->request_pairs, inst->keyattr);
+ for (i = fr_pair_dcursor_by_da_init(&cursor, &request->request_pairs, inst->keyattr);
i;
i = fr_dcursor_next(&cursor)) {
/*
RINDENT();
fr_pair_list_sort(vps, fr_pair_cmp_by_da);
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(vps));
+ for (vp = fr_pair_dcursor_init(&cursor, vps);
vp;
vp = fr_dcursor_next(&cursor)) {
fr_pair_t *next;
if (RDEBUG_ENABLED) {
fr_dcursor_t cursor;
- for (vp = fr_dcursor_iter_by_da_init(&cursor, &request->request_pairs, attr_proxy_state);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, &request->request_pairs, attr_proxy_state);
vp;
vp = fr_dcursor_next(&cursor)) {
if (vp->vp_length != 4) continue;
* sure that it's a loop.
*/
if (DEBUG_ENABLED) {
- for (vp = fr_dcursor_iter_by_da_init(&cursor, &request->request_pairs, attr_proxy_state);
+ for (vp = fr_pair_dcursor_by_da_init(&cursor, &request->request_pairs, attr_proxy_state);
vp;
vp = fr_dcursor_next(&cursor)) {
if ((vp->vp_length == 5) && (memcmp(vp->vp_octets, &inst->parent->proxy_state, 4) == 0)) {
ctx->headers = curl_slist_append(ctx->headers, buffer);
if (!ctx->headers) goto error_header;
- for (header = fr_dcursor_iter_by_da_init(&headers, &request->control_pairs, attr_rest_http_header);
+ for (header = fr_pair_dcursor_by_da_init(&headers, &request->control_pairs, attr_rest_http_header);
header;
header = fr_dcursor_next(&headers)) {
header = fr_dcursor_remove(&headers);
case REST_HTTP_BODY_POST:
rest_request_init(section, request, &ctx->request);
- fr_dcursor_init(&(ctx->request.cursor), fr_pair_list_order(&request->request_pairs));
+ fr_pair_dcursor_init(&(ctx->request.cursor), &request->request_pairs);
if (rest_request_config_body(inst, section, request, randle, rest_encode_post) < 0) return -1;
int elems_added = 0;
/* Iterate over the VP and add the string value to the curl_slist */
- vp = fr_dcursor_iter_by_da_init(&uctx->cursor, &uctx->request->request_pairs, dict_attr);
+ vp = fr_pair_dcursor_by_da_init(&uctx->cursor, &uctx->request->request_pairs, dict_attr);
while (vp) {
*out = curl_slist_append(*out, vp->vp_strvalue);
elems_added++;
mime_body = curl_mime_init(uctx->randle->candle);
/* initialize the cursor used by the body_source function*/
- vp = fr_dcursor_iter_by_da_init(&uctx->body_cursor, &uctx->request->request_pairs, attr_smtp_body);
+ vp = fr_pair_dcursor_by_da_init(&uctx->body_cursor, &uctx->request->request_pairs, attr_smtp_body);
fr_dbuff_init(&uctx->vp_in, (uint8_t const *)vp->vp_strvalue, vp->vp_length);
/* Add a mime part to mime_body for every body element */
RDEBUG2("initialized %d body element part(s)", body_elements);
/* Re-initialize the cursor for use when uploading the data to curl */
- fr_dcursor_iter_by_da_init(&uctx->body_cursor, &uctx->request->request_pairs, attr_smtp_body);
+ fr_pair_dcursor_by_da_init(&uctx->body_cursor, &uctx->request->request_pairs, attr_smtp_body);
/* Add body_mime as a subpart of the mime request with a local content-disposition*/
part = curl_mime_addpart(mime);
/*
* Find the first attribute which is parented by ARP-Packet.
*/
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(vps));
+ for (vp = fr_pair_dcursor_init(&cursor, vps);
vp;
vp = fr_dcursor_next(&cursor)) {
if (vp->da->parent == attr_arp_packet) break;
* operates correctly. This changes the order of the list, but never mind...
*/
fr_pair_list_sort(vps, fr_dhcpv4_attr_cmp);
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(vps), fr_proto_next_encodable, dict_dhcpv4, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, vps, fr_proto_next_encodable, dict_dhcpv4);
/*
* Each call to fr_dhcpv4_encode_option will encode one complete DHCP option,
}
do_child:
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
work_dbuff = FR_DBUFF(dbuff);
while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
packet_ctx.original = original;
packet_ctx.original_length = length;
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(vps), fr_dhcpv6_next_encodable, dict_dhcpv6, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, vps, fr_dhcpv6_next_encodable, dict_dhcpv6);
while ((fr_dbuff_extend(&frame_dbuff) > 0) && (fr_dcursor_current(&cursor) != NULL)) {
slen = fr_dhcpv6_encode_option(&frame_dbuff, &cursor, &packet_ctx);
switch (slen) {
* Encode the child options.
*/
if (!fr_pair_list_empty(&vp->vp_group)) {
- (void) fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ (void) fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
while (fr_dcursor_current(&child_cursor) != NULL) {
slen = fr_dhcpv6_encode_option(&work_dbuff, &child_cursor, encode_ctx);
}
do_child:
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
work_dbuff = FR_DBUFF(dbuff);
while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
if (vp->da->type == FR_TYPE_STRUCT) {
fr_dcursor_t child_cursor;
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
slen = fr_struct_to_network(&work_dbuff, da_stack, depth, &child_cursor, encode_ctx, encode_value_trampoline, encode_tlv);
if (slen < 0) return slen;
}
do_child:
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
work_dbuff = FR_DBUFF(dbuff);
while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
if (vp->da->type == FR_TYPE_STRUCT) {
fr_dcursor_t child_cursor;
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
slen = fr_struct_to_network(&work_dbuff, &da_stack, 0, &child_cursor, encode_ctx, encode_value_trampoline, encode_tlv);
if (slen <= 0) return slen;
fr_dbuff_t work_dbuff = FR_DBUFF(dbuff);
fr_dcursor_t cursor;
- vp = fr_dcursor_iter_by_da_init(&cursor, vps, attr);
+ vp = fr_pair_dcursor_by_da_init(&cursor, vps, attr);
if (!vp) {
FR_PROTO_TRACE(" %s not found in list", attr->name);
return 0;
ssize_t slen;
fr_dcursor_t child_cursor;
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
slen = fr_struct_to_network(&work_dbuff, da_stack, 0, &child_cursor, packet_ctx, encode_value_trampoline, encode_tlv);
if (slen <= 0) return slen;
/*
* @todo - find maximum packet length, and limit work_dbuff to that.
*/
- vp = fr_dcursor_iter_by_da_init(&cursor, vps, attr_dns_packet);
+ vp = fr_pair_dcursor_by_da_init(&cursor, vps, attr_dns_packet);
if (!vp) {
fr_pair_list_debug(vps);
/*
* Encode the header.
*/
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
fr_proto_da_stack_build(&da_stack, attr_dns_packet);
slen = fr_struct_to_network(&work_dbuff, &da_stack, 0, &cursor, packet_ctx, encode_value_trampoline, NULL);
* we need to do an intermediary TLV
* VP to retain the nesting structure.
*/
- if (fr_dcursor_init(&cursor, fr_pair_list_order(&children)) && fr_dcursor_next(&cursor)) {
+ if (fr_pair_dcursor_init(&cursor, &children) && fr_dcursor_next(&cursor)) {
fr_pair_t *tlv;
tlv = fr_pair_afrom_da(ctx, parent_da);
fr_dcursor_t children;
fr_pair_t *child;
- for (child = fr_dcursor_talloc_init(&children, fr_pair_list_order(&vp->vp_group), fr_pair_t);
+ for (child = fr_pair_dcursor_init(&children, &vp->vp_group);
child;
child = fr_dcursor_current(&children)) {
{
fr_dcursor_t children;
- for (vp = fr_dcursor_talloc_init(&children, fr_pair_list_order(&vp->vp_group), fr_pair_t);
+ for (vp = fr_pair_dcursor_init(&children, &vp->vp_group);
vp;
vp = fr_dcursor_current(&children)) {
FR_PROTO_TRACE("encode ctx changed %s -> %s", da->name, vp->da->name);
/*
* Loop over the reply attributes for the packet.
*/
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(vps), fr_radius_next_encodable, dict_radius, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, vps, fr_radius_next_encodable, dict_radius);
while ((vp = fr_dcursor_current(&cursor))) {
PAIR_VERIFY(vp);
return PAIR_ENCODE_SKIPPED;
}
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
vp = fr_dcursor_current(&child_cursor);
fr_proto_da_stack_build(da_stack, vp->da);
/*
* Note that we skip tags inside of tags!
*/
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(vps),
- fr_proto_next_encodable, dict_radius, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, vps, fr_proto_next_encodable, dict_radius);
while ((vp = fr_dcursor_current(&cursor))) {
PAIR_VERIFY(vp);
fr_assert(vp->da == da);
work_dbuff = FR_DBUFF(dbuff);
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
fr_proto_da_stack_build(da_stack, vp->da);
* Loop over the children of this Vendor-Specific
* attribute.
*/
- fr_dcursor_init(&child_cursor, fr_pair_list_order(&vp->vp_group));
+ fr_pair_dcursor_init(&child_cursor, &vp->vp_group);
while ((vp = fr_dcursor_current(&child_cursor)) != NULL) {
fr_proto_da_stack_build(da_stack, vp->da);
/*
* Find the first attribute which is parented by TACACS-Packet.
*/
- for (vp = fr_dcursor_init(&cursor, fr_pair_list_order(vps));
+ for (vp = fr_pair_dcursor_init(&cursor, vps);
vp;
vp = fr_dcursor_next(&cursor)) {
if (vp->da->parent == attr_tacacs_packet) break;
{
fr_dcursor_t cursor;
- fr_dcursor_talloc_iter_init(&cursor, fr_pair_list_order(vps), fr_proto_next_encodable, dict_vmps, fr_pair_t);
+ fr_pair_dcursor_iter_init(&cursor, vps, fr_proto_next_encodable, dict_vmps);
return fr_vmps_encode(&FR_DBUFF_TMP(data, data_len), NULL, -1, -1, &cursor);
}
projects / thirdparty / freeradius-server.git / commitdiff
