static xlat_action_t xlat_test(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request,
- UNUSED fr_value_box_list_t *in)
+ UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
return XLAT_ACTION_DONE;
}
}
static rlm_rcode_t mod_map_proc(UNUSED void *mod_inst, UNUSED void *proc_inst, UNUSED request_t *request,
- UNUSED fr_value_box_list_t *src, UNUSED map_list_t const *maps)
+ UNUSED FR_DLIST_HEAD(fr_value_box_list) *src, UNUSED map_list_t const *maps)
{
return RLM_MODULE_FAIL;
}
static xlat_action_t aka_sim_xlat_id_method_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *method;
fr_aka_sim_id_type_t type_hint;
fr_aka_sim_method_hint_t method_hint;
- fr_value_box_t *id = fr_dlist_head(in);
+ fr_value_box_t *id = fr_value_box_list_head(in);
fr_value_box_t *vb;
if (fr_aka_sim_id_type(&type_hint, &method_hint, id->vb_strvalue, id->vb_length) < 0) {
*/
static xlat_action_t aka_sim_xlat_id_type_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *type;
fr_aka_sim_id_type_t type_hint;
fr_aka_sim_method_hint_t method_hint;
- fr_value_box_t *id = fr_dlist_head(in);
+ fr_value_box_t *id = fr_value_box_list_head(in);
fr_value_box_t *vb;
if (fr_aka_sim_id_type(&type_hint, &method_hint, id->vb_strvalue, id->vb_length) < 0) {
*/
static xlat_action_t aka_sim_id_3gpp_temporary_id_key_index_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *id = fr_dlist_head(in);
+ fr_value_box_t *id = fr_value_box_list_head(in);
fr_value_box_t *vb;
if (id->vb_length != AKA_SIM_3GPP_PSEUDONYM_LEN) {
*/
static xlat_action_t aka_sim_3gpp_temporary_id_decrypt_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t tag;
char out_tag = '\0', *buff;
char decrypted[AKA_SIM_IMSI_MAX_LEN + 1];
- fr_value_box_t *id_vb = fr_dlist_head(in);
+ fr_value_box_t *id_vb = fr_value_box_list_head(in);
char const *id = id_vb->vb_strvalue;
size_t id_len = id_vb->vb_length;
- fr_value_box_t *key_vb = fr_dlist_next(in, id_vb);
+ fr_value_box_t *key_vb = fr_value_box_list_next(in, id_vb);
/* coverity[dereference] */
uint8_t const *key = key_vb->vb_octets;
size_t key_len = key_vb->vb_length;
- fr_value_box_t *tag_vb = fr_dlist_next(in, key_vb);
+ fr_value_box_t *tag_vb = fr_value_box_list_next(in, key_vb);
bool include_tag = true;
fr_value_box_t *vb;
*/
static xlat_action_t aka_sim_3gpp_temporary_id_encrypt_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char encrypted[AKA_SIM_3GPP_PSEUDONYM_LEN + 1];
uint8_t tag = 0;
fr_aka_sim_id_type_t type_hint;
fr_aka_sim_method_hint_t method_hint;
- fr_value_box_t *id_vb = fr_dlist_head(in);
+ fr_value_box_t *id_vb = fr_value_box_list_head(in);
char const *id = id_vb->vb_strvalue;
size_t id_len = id_vb->vb_length;
- fr_value_box_t *key_vb = fr_dlist_next(in, id_vb);
+ fr_value_box_t *key_vb = fr_value_box_list_next(in, id_vb);
/* coverity[dereference] */
uint8_t const *key = key_vb->vb_octets;
size_t key_len = key_vb->vb_length;
- fr_value_box_t *index_vb = fr_dlist_next(in, key_vb);
+ fr_value_box_t *index_vb = fr_value_box_list_next(in, key_vb);
uint8_t key_index = index_vb->vb_uint8;
- fr_value_box_t *type_vb = fr_dlist_next(in, index_vb);
+ fr_value_box_t *type_vb = fr_value_box_list_next(in, index_vb);
bool fastauth = false;
size_t fr_jpath_escape_func(UNUSED request_t *request, char *out, size_t outlen,
char const *in, UNUSED void *arg);
-int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, fr_value_box_list_t *out,
+int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *root, fr_jpath_node_t const *jpath);
* - 0 on no match.
* - -1 on error.
*/
-static int jpath_evaluate(TALLOC_CTX *ctx, fr_value_box_list_t *tail,
+static int jpath_evaluate(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *tail,
fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *object, fr_jpath_node_t const *jpath)
{
return -1;
}
- fr_dlist_insert_tail(tail, value);
+ fr_value_box_list_insert_tail(tail, value);
return 1;
}
* - 0 on no match.
* - -1 on error.
*/
-int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, fr_value_box_list_t *out,
+int fr_jpath_evaluate_leaf(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
fr_type_t dst_type, fr_dict_attr_t const *dst_enumv,
json_object *root, fr_jpath_node_t const *jpath)
{
return -1;
}
if (fr_value_box_bstrndup(ctx, verb, NULL, reply->str, reply->len, true) < 0) return -1;
- fr_dlist_insert_head(&out->vb_group, verb);
+ fr_value_box_list_insert_head(&out->vb_group, verb);
vtype = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL, true);
if (unlikely(!vtype)) {
return -1;
}
if (fr_value_box_strdup(ctx, vtype, NULL, reply->vtype, true) < 0) return -1;
- fr_dlist_insert_head(&out->vb_group, vtype);
+ fr_value_box_list_insert_head(&out->vb_group, vtype);
}
break;
vb = fr_value_box_alloc_null(ctx);
if (unlikely(!vb)) {
array_error:
- fr_dlist_talloc_free(&out->vb_group);
+ fr_value_box_list_talloc_free(&out->vb_group);
return -1;
}
- fr_dlist_insert_tail(&out->vb_group, vb);
+ fr_value_box_list_insert_tail(&out->vb_group, vb);
if (fr_redis_reply_to_value_box(vb, vb, reply->element[i],
FR_TYPE_VOID, NULL, box_error, shallow) < 0) goto array_error;
cf_file_t *file;
CONF_SECTION *top;
fr_rb_tree_t *tree;
- int fd;
+ int fd = -1;
FILE *fp;
top = cf_root(cs);
* - >= 0 number of array elements in argv
* - <0 on error
*/
-static int exec_value_box_list_to_argv(TALLOC_CTX *ctx, char ***argv_p, fr_value_box_list_t const *in)
+static int exec_value_box_list_to_argv(TALLOC_CTX *ctx, char ***argv_p, FR_DLIST_HEAD(fr_value_box_list) const *in)
{
char **argv;
- fr_value_box_t *vb = NULL;
unsigned int i = 0;
- size_t argc = fr_value_box_list_len(in);
+ size_t argc = fr_value_box_list_num_elements(in);
argv = talloc_zero_array(ctx, char *, argc + 1);
if (!argv) return -1;
- while ((vb = fr_dlist_next(in, vb))) {
+ fr_value_box_list_foreach(in, vb) {
/*
* Print the children of each group into the argv array.
*/
* would allow finer-grained control over the attributes to put into
* the environment.
*/
-int fr_exec_fork_nowait(request_t *request, fr_value_box_list_t *args,
+int fr_exec_fork_nowait(request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit)
{
/*
* Ensure that we don't do anything stupid.
*/
- first = fr_dlist_head(args);
- if (first->type == FR_TYPE_GROUP) first = fr_dlist_head(&first->vb_group);
+ first = fr_value_box_list_head(args);
+ if (first->type == FR_TYPE_GROUP) first = fr_value_box_list_head(&first->vb_group);
if (first->tainted) {
REDEBUG("Program to run comes from tainted source - %pV", first);
return -1;
* the environment.
*/
int fr_exec_fork_wait(pid_t *pid_p, int *stdin_fd, int *stdout_fd, int *stderr_fd,
- request_t *request, fr_value_box_list_t *args,
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit)
{
int argc;
/*
* Ensure that we don't do anything stupid.
*/
- first = fr_dlist_head(args);
- if (first->type == FR_TYPE_GROUP) first = fr_dlist_head(&first->vb_group);
+ first = fr_value_box_list_head(args);
+ if (first->type == FR_TYPE_GROUP) first = fr_value_box_list_head(&first->vb_group);
if (first->tainted) {
fr_strerror_printf("Program to run comes from tainted source - %pV", first);
return -1;
* - -1 on failure
*/
int fr_exec_start(TALLOC_CTX *ctx, fr_exec_state_t *exec, request_t *request,
- fr_value_box_list_t *args,
+ FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit,
bool need_stdin,
bool store_stdout, TALLOC_CTX *stdout_ctx,
void fr_exec_cleanup(fr_exec_state_t *exec, int signal);
-int fr_exec_fork_nowait(request_t *request, fr_value_box_list_t *args,
+int fr_exec_fork_nowait(request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit);
int fr_exec_fork_wait(pid_t *pid_p, int *stdin_fd, int *stdout_fd, int *stderr_fd,
- request_t *request, fr_value_box_list_t *args,
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit);
int fr_exec_start(TALLOC_CTX *ctx, fr_exec_state_t *exec, request_t *request,
- fr_value_box_list_t *args,
+ FR_DLIST_HEAD(fr_value_box_list) *args,
fr_pair_list_t *env_pairs, bool env_escape, bool env_inherit,
bool need_stdin,
bool store_stdout, TALLOC_CTX *stdout_ctx,
*/
static xlat_action_t xlat_config(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *value;
CONF_PAIR *cp;
CONF_ITEM *ci;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_value_box_t *vb;
ci = cf_reference_item(main_config->root_cs, main_config->root_cs, in_head->vb_strvalue);
int map_to_list_mod(TALLOC_CTX *ctx, vp_list_mod_t **out,
request_t *request, map_t const *map,
- fr_value_box_list_t *lhs_result, fr_value_box_list_t *rhs_result);
+ FR_DLIST_HEAD(fr_value_box_list) *lhs_result, FR_DLIST_HEAD(fr_value_box_list) *rhs_result);
int map_to_request(request_t *request, map_t const *map,
radius_map_getvalue_t func, void *ctx);
*/
int map_to_list_mod(TALLOC_CTX *ctx, vp_list_mod_t **out,
request_t *request, map_t const *original,
- fr_value_box_list_t *lhs_result, fr_value_box_list_t *rhs_result)
+ FR_DLIST_HEAD(fr_value_box_list) *lhs_result, FR_DLIST_HEAD(fr_value_box_list) *rhs_result)
{
vp_list_mod_t *n = NULL;
map_t map_tmp;
map_t const *mutated = original;
fr_dcursor_t values;
- fr_value_box_list_t head;
+ FR_DLIST_HEAD(fr_value_box_list) head;
TALLOC_CTX *tmp_ctx = NULL;
MAP_VERIFY(original);
case TMPL_TYPE_XLAT:
{
ssize_t slen;
- fr_value_box_t *lhs_result_head = fr_dlist_head(lhs_result);
+ fr_value_box_t *lhs_result_head = fr_value_box_list_head(lhs_result);
/*
* Get our own mutable copy of the original so we can
tmp_ctx = talloc_new(NULL);
- fr_assert(!fr_dlist_empty(lhs_result));
+ fr_assert(!fr_value_box_list_empty(lhs_result));
/*
* This should always be a noop, but included
FR_VALUE_BOX_LIST_FREE, true,
SIZE_MAX) < 0) {
RPEDEBUG("Left side expansion failed");
- fr_dlist_talloc_free(lhs_result);
+ fr_value_box_list_talloc_free(lhs_result);
goto error;
}
if (slen <= 0) {
RPEDEBUG("Left side expansion result \"%s\" is not an attribute reference",
lhs_result_head->vb_strvalue);
- fr_dlist_talloc_free(lhs_result);
+ fr_value_box_list_talloc_free(lhs_result);
goto error;
}
fr_assert(tmpl_is_attr(mutated->lhs) || tmpl_is_list(mutated->lhs));
n = list_mod_generic_afrom_map(ctx, original, mutated);
if (!n) goto error;
- fr_dcursor_init(&values, &head);
+ fr_dcursor_init(&values, fr_value_box_list_dlist_head(&head));
if (fr_value_box_from_str(map_list_head(&n->mod),
tmpl_value(map_list_head(&n->mod)->rhs), type,
*/
if (!map_check_src_or_dst(request, mutated, mutated->lhs)) goto error;
- (void)fr_dcursor_init(&values, &head);
+ (void)fr_dcursor_init(&values, fr_value_box_list_dlist_head(&head));
switch (mutated->rhs->type) {
case TMPL_TYPE_XLAT:
* happens. This is only for XLATs and in future
* EXECs.
*/
- if (fr_dlist_empty(rhs_result)) {
+ if (fr_value_box_list_empty(rhs_result)) {
n = list_mod_empty_string_afrom_map(ctx, original, mutated);
if (!n) {
RPEDEBUG("Assigning value to \"%s\" failed", tmpl_da(mutated->lhs)->name);
n = list_mod_generic_afrom_map(ctx, original, mutated);
if (!n) goto error;
- (void)fr_dcursor_init(&from, rhs_result);
+ (void)fr_dcursor_init(&from, fr_value_box_list_dlist_head(rhs_result));
while ((vb = fr_dcursor_remove(&from))) {
if (vb->type != tmpl_da(mutated->lhs)->type) {
n_vb = fr_value_box_alloc_null(map_list_head(&n->mod)->rhs);
fr_value_box_t *n_vb;
int err;
- fr_assert(fr_dlist_empty(rhs_result));
+ fr_assert(fr_value_box_list_empty(rhs_result));
fr_assert((tmpl_is_attr(mutated->lhs) && tmpl_da(mutated->lhs)) ||
(tmpl_is_list(mutated->lhs) && !tmpl_da(mutated->lhs)));
{
fr_value_box_t *vb, *n_vb;
- fr_assert(fr_dlist_empty(rhs_result));
+ fr_assert(fr_value_box_list_empty(rhs_result));
fr_assert(tmpl_da(mutated->lhs));
fr_assert(tmpl_is_attr(mutated->lhs));
fr_dcursor_t from;
fr_pair_list_t vp_head;
fr_pair_t *vp;
- fr_value_box_t *rhs_result_head = fr_dlist_head(rhs_result);
+ fr_value_box_t *rhs_result_head = fr_value_box_list_head(rhs_result);
fr_pair_list_init(&vp_head);
/*
* happens. This is only for XLATs and in future
* EXECs.
*/
- if (fr_dlist_empty(rhs_result)) {
+ if (fr_value_box_list_empty(rhs_result)) {
RPEDEBUG("Cannot assign empty value to \"%s\"", mutated->lhs->name);
goto error;
}
FR_VALUE_BOX_LIST_FREE, true,
SIZE_MAX) < 0) {
RPEDEBUG("Right side expansion failed");
- fr_dlist_talloc_free(rhs_result);
+ fr_value_box_list_talloc_free(rhs_result);
goto error;
}
goto error;
}
- fr_assert(!fr_dlist_empty(&head) || !n);
+ fr_assert(!fr_value_box_list_empty(&head) || !n);
/*
* FIXME: This is only required because
* If tmpl_value were a pointer we could
* assign values directly.
*/
- fr_value_box_copy(map_list_head(&n->mod)->rhs, tmpl_value(map_list_head(&n->mod)->rhs), fr_dlist_head(&head));
+ fr_value_box_copy(map_list_head(&n->mod)->rhs, tmpl_value(map_list_head(&n->mod)->rhs), fr_value_box_list_head(&head));
/*
* value boxes in tmpls cannot now be the head of a list
*
*tmpl_value(map_list_head(&n->mod)->rhs)->next = head->next;
*/
- fr_dlist_talloc_free(&head);
+ fr_value_box_list_talloc_free(&head);
finish:
if (n) {
* @param[in,out] result Result of expanding the map input. May be consumed
* by the map processor.
*/
-rlm_rcode_t map_proc(request_t *request, map_proc_inst_t const *inst, fr_value_box_list_t *result)
+rlm_rcode_t map_proc(request_t *request, map_proc_inst_t const *inst, FR_DLIST_HEAD(fr_value_box_list) *result)
{
return inst->proc->evaluate(inst->proc->mod_inst, inst->data, request, result, inst->maps);
}
* - #RLM_MODULE_FAIL - If an error occurred performing the mapping.
*/
typedef rlm_rcode_t (*map_proc_func_t)(void *mod_inst, void *proc_inst, request_t *request,
- fr_value_box_list_t *result, map_list_t const *maps);
+ FR_DLIST_HEAD(fr_value_box_list) *result, map_list_t const *maps);
/** Allocate new instance data for a map processor
*
map_proc_inst_t *map_proc_instantiate(TALLOC_CTX *ctx, map_proc_t const *proc,
CONF_SECTION *cs, tmpl_t const *src, map_list_t const *maps);
-rlm_rcode_t map_proc(request_t *request, map_proc_inst_t const *inst, fr_value_box_list_t *src);
+rlm_rcode_t map_proc(request_t *request, map_proc_inst_t const *inst, FR_DLIST_HEAD(fr_value_box_list) *src);
#ifdef __cplusplus
}
void tmpl_extents_debug(fr_dlist_head_t *head) CC_HINT(nonnull);
-int tmpl_eval_pair(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt);
+int tmpl_eval_pair(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request, tmpl_t const *vpt);
-int tmpl_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt);
+int tmpl_eval(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request, tmpl_t const *vpt);
-int tmpl_eval_cast(TALLOC_CTX *ctx, fr_value_box_list_t *out, tmpl_t const *vpt);
+int tmpl_eval_cast(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, tmpl_t const *vpt);
/** @} */
ssize_t tmpl_preparse(char const **out, size_t *outlen, char const *in, size_t inlen,
fr_pair_t *tmpl_get_list(request_t *request, tmpl_t const *vpt) CC_HINT(nonnull(2)); /* temporary hack */
-int tmpl_value_list_insert_tail(fr_value_box_list_t *list, fr_value_box_t *vb, tmpl_t const *vpt) CC_HINT(nonnull);
+int tmpl_value_list_insert_tail(FR_DLIST_HEAD(fr_value_box_list) *list, fr_value_box_t *vb, tmpl_t const *vpt) CC_HINT(nonnull);
void tmpl_rules_child_init(TALLOC_CTX *ctx, tmpl_rules_t *out, tmpl_rules_t const *parent, tmpl_t *vpt) CC_HINT(nonnull);
* - <0 for "cast failed"
* - 0 for success
*/
-int tmpl_value_list_insert_tail(fr_value_box_list_t *list, fr_value_box_t *box, tmpl_t const *vpt)
+int tmpl_value_list_insert_tail(FR_DLIST_HEAD(fr_value_box_list) *list, fr_value_box_t *box, tmpl_t const *vpt)
{
if (fr_type_is_null(tmpl_rules_cast(vpt)) ||
(box->type == tmpl_rules_cast(vpt))) {
- fr_dlist_insert_tail(list, box);
+ fr_value_box_list_insert_tail(list, box);
return 0;
}
if (fr_value_box_cast_in_place(box, box, tmpl_rules_cast(vpt), tmpl_rules_enumv(vpt)) < 0) return -1;
- fr_dlist_insert_tail(list, box);
+ fr_value_box_list_insert_tail(list, box);
return 0;
}
* - <0 on memory allocation errors.
* - 0 success.
*/
-static int tmpl_eval_pair_virtual(TALLOC_CTX *ctx, fr_value_box_list_t *out,
+static int tmpl_eval_pair_virtual(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, tmpl_t const *vpt)
{
fr_radius_packet_t *packet = NULL;
fr_value_box_t *value;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
/*
* Virtual attributes always have a count of 1
done:
fr_value_box_list_init(&list);
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
if (tmpl_eval_cast(ctx, &list, vpt) < 0) {
- fr_dlist_talloc_free(&list);
+ fr_value_box_list_talloc_free(&list);
return -1;
};
- fr_dlist_move(out, &list);
+ fr_value_box_list_move(out, &list);
return 0;
}
* - <0 we failed getting a value for the attribute.
* - 0 we successfully evaluated the tmpl
*/
-int tmpl_eval_pair(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
+int tmpl_eval_pair(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request, tmpl_t const *vpt)
{
fr_pair_t *vp = NULL;
fr_value_box_t *value;
tmpl_dcursor_ctx_t cc;
int ret = 0;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
fr_assert(tmpl_is_attr(vpt) || tmpl_is_list(vpt));
goto fail;
}
value->datum.int32 = 0;
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
} /* Fall through to being done */
goto done;
value = fr_value_box_alloc(ctx, FR_TYPE_UINT32, NULL, false);
if (!value) goto oom;
value->datum.uint32 = count;
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
break;
}
fr_value_box_copy(value, value, &vp->data);
}
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
vp = fr_dcursor_next(&cursor);
}
break;
fr_assert(fr_type_is_leaf(vp->da->type));
fr_value_box_copy(value, value, &vp->data); /* Also dups taint */
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
break;
}
*/
if (ret == 0) {
if (tmpl_eval_cast(ctx, &list, vpt) < 0) {
- fr_dlist_talloc_free(&list);
+ fr_value_box_list_talloc_free(&list);
ret = -1;
goto fail;
}
- fr_dlist_move(out, &list);
+ fr_value_box_list_move(out, &list);
}
fail:
* - <0 we failed getting a value for the tmpl
* - 0 we successfully evaluated the tmpl
*/
-int tmpl_eval(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, tmpl_t const *vpt)
+int tmpl_eval(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request, tmpl_t const *vpt)
{
char *p;
fr_value_box_t *value;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
if (tmpl_needs_resolving(vpt)) {
fr_strerror_const("Cannot evaluate unresolved tmpl");
*/
done:
fr_value_box_list_init(&list);
- fr_dlist_insert_tail(&list, value);
+ fr_value_box_list_insert_tail(&list, value);
if (tmpl_eval_cast(ctx, &list, vpt) < 0) {
- fr_dlist_talloc_free(&list);
+ fr_value_box_list_talloc_free(&list);
return -1;
};
- fr_dlist_move(out, &list);
+ fr_value_box_list_move(out, &list);
return 0;
}
* - <0 the cast failed
* - 0 we successfully evaluated the tmpl
*/
-int tmpl_eval_cast(TALLOC_CTX *ctx, fr_value_box_list_t *list, tmpl_t const *vpt)
+int tmpl_eval_cast(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *list, tmpl_t const *vpt)
{
fr_type_t cast = tmpl_rules_cast(vpt);
fr_value_box_t *vb;
/*
* Apply a cast to the results if required.
*/
- vb = fr_dlist_head(list);
+ vb = fr_value_box_list_head(list);
if (!vb) return 0;
switch (cast) {
* Many boxes, turn them into strings, and try to parse it as the
* output type.
*/
- if (!fr_dlist_next(list, vb)) {
+ if (!fr_value_box_list_next(list, vb)) {
return fr_value_box_cast_in_place(vb, vb, cast, NULL);
}
FALL_THROUGH;
NULL, tainted);
if ((vlen < 0) || (slen != vlen)) return -1;
- fr_dlist_insert_tail(list, vb);
+ fr_value_box_list_insert_tail(list, vb);
break;
case FR_TYPE_OCTETS:
*/
xlat_action_t trigger_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_list_t *head = NULL;
fr_dict_attr_t const *da;
fr_pair_t *vp;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_value_box_t *vb;
if (!triggers_init) {
typedef struct {
char *command; //!< Name of the trigger.
xlat_exp_head_t *xlat; //!< xlat representation of the trigger args.
- fr_value_box_list_t args; //!< Arguments to pass to the trigger exec.
+ FR_DLIST_HEAD(fr_value_box_list) args; //!< Arguments to pass to the trigger exec.
fr_exec_state_t exec; //!< Used for asynchronous execution.
fr_time_delta_t timeout; //!< How long the trigger has to run.
{
fr_trigger_t *trigger = talloc_get_type_abort(rctx, fr_trigger_t);
- if (fr_dlist_empty(&trigger->args)) {
+ if (fr_value_box_list_empty(&trigger->args)) {
RERROR("Failed trigger \"%s\" - did not expand to anything", trigger->command);
RETURN_MODULE_FAIL;
}
xlat_action_t trigger_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in);
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in);
int trigger_exec_init(CONF_SECTION const *cs);
(void) talloc_get_type_abort(trunk, fr_trunk_t);
for (size_t i = 0; i < NUM_ELEMENTS(trunk->watch); i++) {
- fr_dlist_verify(file, line, &trunk->watch[i]);
+ _fr_dlist_verify(file, line, &trunk->watch[i]);
}
#define IO_FUNC_VERIFY(_func) \
#define TCONN_DLIST_VERIFY(_dlist, _state) \
do { \
- fr_dlist_verify(file, line, &(trunk->_dlist)); \
+ _fr_dlist_verify(file, line, &(trunk->_dlist)); \
fr_dlist_foreach(&(trunk->_dlist), fr_trunk_connection_t, tconn) { \
fr_trunk_connection_verify(file, line, tconn); \
TRUNK_TCONN_CHECKS(tconn, _state); \
}} \
} while (0)
- FR_DLIST_VERIFY(&(trunk->free_requests));
+ fr_dlist_verify(&(trunk->free_requests));
FR_HEAP_VERIFY(trunk->backlog);
TCONN_DLIST_VERIFY(init, FR_TRUNK_CONN_INIT);
#define TREQ_DLIST_VERIFY(_dlist, _state) \
do { \
- fr_dlist_verify(file, line, &(tconn->_dlist)); \
+ _fr_dlist_verify(file, line, &(tconn->_dlist)); \
fr_dlist_foreach(&(tconn->_dlist), fr_trunk_request_t, treq) { \
fr_trunk_request_verify(file, line, treq); \
TCONN_TREQ_CHECKS(treq, _state); \
*/
RCSID("$Id$")
+#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/modpriv.h>
#include <freeradius-devel/server/module_rlm.h>
-#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
+#include <freeradius-devel/util/time.h>
#include "call_priv.h"
#include "caller_priv.h"
unlang_t *c;
unlang_group_t *g;
unlang_timeout_t *gext;
- fr_time_delta_t timeout;
+ fr_time_delta_t timeout = fr_time_delta_from_sec(0);
tmpl_t *vpt = NULL;
fr_token_t token;
char const *name2;
unlang_t *c;
unlang_group_t *g;
- unlang_limit_t *gext;
+ unlang_limit_t *gext;
tmpl_t *vpt = NULL;
- uint32_t limit;
+ uint32_t limit = 0;
fr_token_t token;
ssize_t slen;
tmpl_rules_t t_rules;
#include "group_priv.h"
typedef struct {
- fr_value_box_list_t out; //!< Head of the result of a nested
+ FR_DLIST_HEAD(fr_value_box_list) out; //!< Head of the result of a nested
///< expansion.
bool success; //!< If set, where to record the result
///< of the execution.
static unlang_action_t unlang_if_resume(rlm_rcode_t *p_result, request_t *request, unlang_stack_frame_t *frame)
{
unlang_frame_state_cond_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_cond_t);
- fr_value_box_t *box = fr_dlist_head(&state->out);
+ fr_value_box_t *box = fr_value_box_list_head(&state->out);
bool value;
if (!box) {
value = false;
- } else if (fr_dlist_next(&state->out, box) != NULL) {
+ } else if (fr_value_box_list_next(&state->out, box) != NULL) {
value = true;
} else {
#include "edit_priv.h"
typedef struct {
- fr_value_box_list_t result; //!< result of expansion
+ FR_DLIST_HEAD(fr_value_box_list) result; //!< result of expansion
tmpl_t const *vpt; //!< expanded tmpl
tmpl_t *to_free; //!< tmpl to free.
bool create; //!< whether we need to create the VP
static int tmpl_attr_from_result(TALLOC_CTX *ctx, edit_result_t *out, request_t *request)
{
ssize_t slen;
- fr_value_box_t *box = fr_dlist_head(&out->result);
+ fr_value_box_t *box = fr_value_box_list_head(&out->result);
if (!box) {
RWDEBUG("No value found for assignment");
}
out->vpt = out->to_free;
- fr_dlist_talloc_free(&out->result);
+ fr_value_box_list_talloc_free(&out->result);
return 0;
}
}
} else {
- box = fr_dlist_head(¤t->rhs.result);
+ box = fr_value_box_list_head(¤t->rhs.result);
/*
* Can't concatenate empty results.
* tmpl_push(). If the input xlat/tmpl is quoted, then the output should be a
* single value-box which is the final string.
*/
- box = fr_dlist_head(¤t->rhs.result);
+ box = fr_value_box_list_head(¤t->rhs.result);
if (!box) goto no_rhs;
RWDEBUG("Failed converting result to string");
return -1;
}
- box = fr_dlist_head(¤t->rhs.result);
+ box = fr_value_box_list_head(¤t->rhs.result);
single = true;
} else {
rhs_list:
- if (fr_dlist_num_elements(¤t->rhs.result) == 1) {
- box = fr_dlist_head(¤t->rhs.result);
+ if (fr_value_box_list_num_elements(¤t->rhs.result) == 1) {
+ box = fr_value_box_list_head(¤t->rhs.result);
single = true;
} else {
- box = fr_dcursor_init(&cursor, ¤t->rhs.result);
+ box = fr_dcursor_init(&cursor, fr_value_box_list_dlist_head(¤t->rhs.result));
}
}
} else {
done:
if (pair) tmpl_dcursor_clear(&cc);
- fr_dlist_talloc_free(¤t->rhs.result);
+ fr_value_box_list_talloc_free(¤t->rhs.result);
return 0;
}
MEM(box = fr_value_box_alloc_null(state));
if (fr_value_box_copy(state, box, tmpl_value(vpt)) < 0) return -1;
- fr_dlist_insert_tail(¤t->parent->rhs.result, box);
+ fr_value_box_list_insert_tail(¤t->parent->rhs.result, box);
return next_map(request, state, current);
}
MEM(box = fr_value_box_alloc_null(state));
if (fr_value_box_copy(state, box, &vp->data) < 0) return -1;
- fr_dlist_insert_tail(¤t->parent->rhs.result, box);
+ fr_value_box_list_insert_tail(¤t->parent->rhs.result, box);
vp = fr_dcursor_next(&cursor);
}
{
fr_assert(current->parent);
- fr_dlist_move(¤t->parent->rhs.result, ¤t->lhs.result);
+ fr_value_box_list_move(¤t->parent->rhs.result, ¤t->lhs.result);
return next_map(request, state, current);
}
int rcode;
map_t const *map = current->map;
- fr_assert(fr_dlist_empty(¤t->lhs.result)); /* Should have been consumed */
- fr_assert(fr_dlist_empty(¤t->rhs.result)); /* Should have been consumed */
+ fr_assert(fr_value_box_list_empty(¤t->lhs.result)); /* Should have been consumed */
+ fr_assert(fr_value_box_list_empty(¤t->rhs.result)); /* Should have been consumed */
rcode = tmpl_to_values(state, ¤t->lhs, request, map->lhs);
if (rcode < 0) return -1;
static xlat_action_t unlang_foreach_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in);
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in);
#define FOREACH_REQUEST_DATA (void *)unlang_foreach_xlat
*/
static xlat_action_t unlang_foreach_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
int const *inst = xctx->inst;
*/
static xlat_action_t unlang_interpret_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
unlang_stack_t *stack = request->stack;
int depth = stack->depth;
unlang_stack_frame_t *frame;
unlang_t const *instruction;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
char const *fmt = arg->vb_strvalue;
fr_value_box_t *vb;
/** Interpreter yielded request
*
*/
-static void _request_yield(request_t *request, UNUSED void *uctx)
+static void _request_yield(request_t *request, void *uctx)
{
unlang_interpret_synchronous_t *intps = uctx;
#include "limit_priv.h"
typedef struct {
- uint32_t active_callers;
+ uint32_t active_callers;
} unlang_thread_limit_t;
typedef struct {
- unlang_thread_limit_t *thread;
- uint32_t limit;
- request_t *request;
+ unlang_thread_limit_t *thread;
+ uint32_t limit;
+ request_t *request;
- fr_value_box_list_t result;
+ FR_DLIST_HEAD(fr_value_box_list) result;
} unlang_frame_state_limit_t;
/** Send a signal (usually stop) to a request
return UNLANG_ACTION_PUSHED_CHILD;
}
-static unlang_action_t unlang_limit_xlat_done(UNUSED rlm_rcode_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)
+static unlang_action_t unlang_limit_xlat_done(rlm_rcode_t *p_result, request_t *request, unlang_stack_frame_t *frame)
{
unlang_frame_state_limit_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_limit_t);
- fr_value_box_t *box = fr_dlist_head(&state->result);
+ fr_value_box_t *box = fr_value_box_list_head(&state->result);
/*
* compile_limit() ensures that the tmpl is cast to uint32, so we don't have to do any more work here.
fr_dlist_head_t vlm_head; //!< Head of list of VP List Mod.
- fr_value_box_list_t lhs_result; //!< Result of expanding the LHS
- fr_value_box_list_t rhs_result; //!< Result of expanding the RHS.
+ FR_DLIST_HEAD(fr_value_box_list) lhs_result; //!< Result of expanding the LHS
+ FR_DLIST_HEAD(fr_value_box_list) rhs_result; //!< Result of expanding the RHS.
unlang_update_state_t state; //!< What we're currently doing.
} unlang_frame_state_update_t;
*
*/
typedef struct {
- fr_value_box_list_t src_result; //!< Result of expanding the map source.
+ FR_DLIST_HEAD(fr_value_box_list) src_result; //!< Result of expanding the map source.
} unlang_frame_state_map_proc_t;
/** Apply a list of modifications on one or more fr_pair_t lists.
case UNLANG_UPDATE_MAP_INIT:
update_state->state = UNLANG_UPDATE_MAP_EXPANDED_LHS;
- fr_assert(fr_dlist_empty(&update_state->lhs_result)); /* Should have been consumed */
- fr_assert(fr_dlist_empty(&update_state->rhs_result)); /* Should have been consumed */
+ fr_assert(fr_value_box_list_empty(&update_state->lhs_result)); /* Should have been consumed */
+ fr_assert(fr_value_box_list_empty(&update_state->rhs_result)); /* Should have been consumed */
switch (map->lhs->type) {
default:
/*
* Concat the top level results together
*/
- if (!fr_dlist_empty(&update_state->rhs_result) &&
+ if (!fr_value_box_list_empty(&update_state->rhs_result) &&
(fr_value_box_list_concat_in_place(update_state,
- fr_dlist_head(&update_state->rhs_result), &update_state->rhs_result, FR_TYPE_STRING,
+ fr_value_box_list_head(&update_state->rhs_result), &update_state->rhs_result, FR_TYPE_STRING,
FR_VALUE_BOX_LIST_FREE, true,
SIZE_MAX) < 0)) {
RPEDEBUG("Failed concatenating RHS expansion results");
&update_state->lhs_result, &update_state->rhs_result) < 0) goto error;
if (new_mod) fr_dlist_insert_tail(&update_state->vlm_head, new_mod);
- fr_dlist_talloc_free(&update_state->rhs_result);
+ fr_value_box_list_talloc_free(&update_state->rhs_result);
}
next:
update_state->state = UNLANG_UPDATE_MAP_INIT;
- fr_dlist_talloc_free(&update_state->lhs_result);
+ fr_value_box_list_talloc_free(&update_state->lhs_result);
break;
}
/*
* FIXME - We don't yet support async LHS/RHS expansions for map procs
*/
- FR_DLIST_VERIFY(&map_proc_state->src_result);
+ fr_value_box_list_verify(&map_proc_state->src_result);
*p_result = map_proc(request, gext->proc_inst, &map_proc_state->src_result);
- FR_DLIST_VERIFY(&map_proc_state->src_result);
+ fr_value_box_list_verify(&map_proc_state->src_result);
return UNLANG_ACTION_CALCULATE_RESULT;
}
*p_result = RLM_MODULE_FAIL;
return UNLANG_ACTION_CALCULATE_RESULT;
}
- fr_dlist_insert_head(&map_proc_state->src_result, src_result);
+ fr_value_box_list_insert_head(&map_proc_state->src_result, src_result);
break;
}
case TMPL_TYPE_EXEC:
* @return
* - UNLANG_ACTION_YIELD
*/
-unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_head_t const *exp,
unlang_module_resume_t resume,
unlang_module_signal_t signal, void *rctx)
* @return
* - UNLANG_ACTION_YIELD
*/
-unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, fr_value_box_list_t *out,
+unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, tmpl_t const *vpt,
unlang_tmpl_args_t *args,
unlang_module_resume_t resume,
unlang_module_resume_t resume,
unlang_module_signal_t signal, void *rctx);
-unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+unlang_action_t unlang_module_yield_to_xlat(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_head_t const *xlat,
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_list_t *out,
+unlang_action_t unlang_module_yield_to_tmpl(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, tmpl_t const *vpt,
unlang_tmpl_args_t *args,
unlang_module_resume_t resume,
#include "timeout_priv.h"
typedef struct {
- bool success;
- int depth;
- fr_time_delta_t timeout;
- request_t *request;
- rindent_t indent;
- fr_event_timer_t const *ev;
-
- fr_value_box_list_t result;
+ bool success;
+ int depth;
+ fr_time_delta_t timeout;
+ request_t *request;
+ rindent_t indent;
+ fr_event_timer_t const *ev;
+
+ FR_DLIST_HEAD(fr_value_box_list) result;
} unlang_frame_state_timeout_t;
static void unlang_timeout_handler(UNUSED fr_event_list_t *el, UNUSED fr_time_t now, void *ctx)
state->success = false;
}
-static unlang_action_t unlang_timeout_resume_done(UNUSED rlm_rcode_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)
+static unlang_action_t unlang_timeout_resume_done(UNUSED rlm_rcode_t *p_result, request_t *request, unlang_stack_frame_t *frame)
{
unlang_frame_state_timeout_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_timeout_t);
return UNLANG_ACTION_PUSHED_CHILD;
}
-static unlang_action_t unlang_timeout_xlat_done(UNUSED rlm_rcode_t *p_result, UNUSED request_t *request, unlang_stack_frame_t *frame)
+static unlang_action_t unlang_timeout_xlat_done(rlm_rcode_t *p_result, request_t *request, unlang_stack_frame_t *frame)
{
unlang_frame_state_timeout_t *state = talloc_get_type_abort(frame->state, unlang_frame_state_timeout_t);
- fr_value_box_t *box = fr_dlist_head(&state->result);
+ fr_value_box_t *box = fr_value_box_list_head(&state->result);
/*
* compile_timeout() ensures that the tmpl is cast to time_delta, so we don't have to do any more work here.
return UNLANG_ACTION_CALCULATE_RESULT;
}
- if (state->out) fr_dlist_move(state->out, &state->list);
+ if (state->out) fr_value_box_list_move(state->out, &state->list);
if (state->resume) return state->resume(p_result, request, state->rctx);
* care about output, and we don't care about the programs exit status.
*/
if (state->exec.failed) {
- fr_dlist_talloc_free(&state->list);
+ fr_value_box_list_talloc_free(&state->list);
goto resume;
}
fr_assert(state->exec.pid < 0); /* Assert this has been cleaned up */
if (!state->args.exec.stdout_on_error && (state->exec.status != 0)) {
- fr_assert(fr_dlist_empty(&state->list));
+ fr_assert(fr_value_box_list_empty(&state->list));
goto resume;
}
*p_result = RLM_MODULE_FAIL;
return UNLANG_ACTION_CALCULATE_RESULT;
}
- fr_dlist_insert_head(&state->list, box);
+ fr_value_box_list_insert_head(&state->list, box);
}
resume:
return UNLANG_ACTION_CALCULATE_RESULT;
}
- fr_dlist_talloc_free(&state->list); /* this is the xlat expansion, and not the output string we want */
+ fr_value_box_list_talloc_free(&state->list); /* this is the xlat expansion, and not the output string we want */
frame_repeat(frame, unlang_tmpl_exec_wait_final);
return UNLANG_ACTION_YIELD;
* @param[in] args where the status of exited programs will be stored.
* Used only for #TMPL_TYPE_EXEC.
*/
-int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request,
- tmpl_t const *tmpl, unlang_tmpl_args_t *args)
+unlang_action_t unlang_tmpl_push(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request,
+ tmpl_t const *tmpl, unlang_tmpl_args_t *args)
{
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame;
extern "C" {
#endif
-#include <freeradius-devel/server/tmpl.h>
#include <freeradius-devel/server/rcode.h>
+#include <freeradius-devel/server/tmpl.h>
#include <freeradius-devel/unlang/tmpl.h>
/** Flags that show the type of arguments included
*/
typedef unlang_action_t (*fr_unlang_tmpl_resume_t)(rlm_rcode_t *p_result, request_t *request, void *rctx);
-int unlang_tmpl_push(TALLOC_CTX *ctx, fr_value_box_list_t *out,
+int unlang_tmpl_push(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args)
CC_HINT(warn_unused_result);
*/
typedef struct {
TALLOC_CTX *ctx; //!< for allocating value boxes
- fr_value_box_list_t *out; //!< output list if the exec succeeds
- fr_value_box_list_t list; //!< our intermediate working list
+ FR_DLIST_HEAD(fr_value_box_list) *out; //!< output list if the exec succeeds
+ FR_DLIST_HEAD(fr_value_box_list) list; //!< our intermediate working list
void *rctx; //!< for resume
fr_unlang_tmpl_resume_t resume; //!< resumption handler
/*
* For func and alternate
*/
- fr_value_box_list_t out; //!< Head of the result of a nested
+ FR_DLIST_HEAD(fr_value_box_list) out; //!< Head of the result of a nested
///< expansion.
bool alternate; //!< record which alternate branch we
///< previously took.
* - 0 on success.
* - -1 on failure.
*/
-static int unlang_xlat_push_internal(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+static int unlang_xlat_push_internal(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_head_t const *xlat, xlat_exp_t *node, bool top_frame)
{
/** Static instruction for performing xlat evaluations
/*
* Initialise the input and output lists
*/
- fr_dcursor_init(&state->values, out);
+ fr_dcursor_init(&state->values, fr_value_box_list_dlist_head(out));
fr_value_box_list_init(&state->out);
return 0;
* - 0 on success.
* - -1 on failure.
*/
-int unlang_xlat_push(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+int unlang_xlat_push(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_head_t const *xlat, bool top_frame)
{
(void) talloc_get_type_abort_const(xlat, xlat_exp_head_t);
* - 0 on success.
* - -1 on failure.
*/
-int unlang_xlat_push_node(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+int unlang_xlat_push_node(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_t *node)
{
return unlang_xlat_push_internal(ctx, p_success, out, request, NULL, node, UNLANG_TOP_FRAME);
* at this level. A frame may be used to evaluate
* multiple sibling nodes.
*/
- fr_dlist_talloc_free(&state->out);
+ fr_value_box_list_talloc_free(&state->out);
if (unlang_xlat_push(state->ctx, state->success, &state->out, request, child, false) < 0) {
*p_result = RLM_MODULE_FAIL;
REXDENT();
* at this level. A frame may be used to evaluate
* multiple sibling nodes.
*/
- fr_dlist_talloc_free(&state->out);
+ fr_value_box_list_talloc_free(&state->out);
if (unlang_xlat_push(state->ctx, state->success, &state->out, request, child, false) < 0) {
*p_result = RLM_MODULE_FAIL;
return UNLANG_ACTION_STOP_PROCESSING;
* - XLAT_ACTION_FAIL the xlat function failed.
*/
typedef xlat_action_t (*xlat_func_t)(TALLOC_CTX *ctx, fr_dcursor_t *out,
- xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in);
+ xlat_ctx_t const *xctx, request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in);
/** A callback when the request gets a fr_state_signal_t.
*
int unlang_xlat_timeout_add(request_t *request, fr_unlang_xlat_timeout_t callback,
void const *rctx, fr_time_t when);
-int unlang_xlat_push(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+int unlang_xlat_push(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_head_t const *head, bool top_frame)
CC_HINT(warn_unused_result);
*/
static xlat_action_t xlat_redundant_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_redundant_inst_t const *xri = talloc_get_type_abort_const(xctx->inst, xlat_redundant_inst_t);
xlat_redundant_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_redundant_rctx_t);
/*
* Push the next child...
*/
- if (unlang_xlat_push(ctx, &rctx->last_success, out->dlist,
+ if (unlang_xlat_push(ctx, &rctx->last_success, (FR_DLIST_HEAD(fr_value_box_list) *)out->dlist,
request, *rctx->current, UNLANG_SUB_FRAME) < 0) goto error;
return XLAT_ACTION_PUSH_UNLANG;
*/
static xlat_action_t xlat_load_balance_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
+ UNUSED request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_redundant_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_redundant_rctx_t);
xlat_action_t xa = rctx->last_success ? XLAT_ACTION_DONE : XLAT_ACTION_FAIL;
*/
static xlat_action_t xlat_redundant(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_redundant_inst_t const *xri = talloc_get_type_abort_const(xctx->inst, xlat_redundant_inst_t);
xlat_redundant_rctx_t *rctx;
fr_assert(0);
}
- if (unlang_xlat_push(ctx, &rctx->last_success, out->dlist,
+ if (unlang_xlat_push(ctx, &rctx->last_success, (FR_DLIST_HEAD(fr_value_box_list) *)out->dlist,
request, *rctx->current, UNLANG_SUB_FRAME) < 0) return XLAT_ACTION_FAIL;
return XLAT_ACTION_PUSH_UNLANG;
*/
static xlat_action_t xlat_func_debug(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
int level = 0;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/*
* Expand to previous (or current) level
*/
static xlat_action_t xlat_func_debug_attr(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
fr_dcursor_t cursor;
tmpl_dcursor_ctx_t cc;
tmpl_t *vpt;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
char const *fmt;
if (!RDEBUG_ENABLED2) return XLAT_ACTION_DONE; /* NOOP if debugging isn't enabled */
*/
static xlat_action_t xlat_func_flatten(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
tmpl_t *vpt;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
char const *fmt;
fmt = attr->vb_strvalue;
*/
static xlat_action_t xlat_func_unflatten(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
tmpl_t *vpt;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
char const *fmt;
fmt = attr->vb_strvalue;
static xlat_action_t xlat_func_untaint(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
fr_value_box_list_untaint(in);
- while ((vb = fr_dlist_pop_head(in)) != NULL) {
+ while ((vb = fr_value_box_list_pop_head(in)) != NULL) {
fr_dcursor_append(out, vb);
}
static xlat_action_t xlat_func_taint(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
fr_value_box_list_taint(in);
- while ((vb = fr_dlist_pop_head(in)) != NULL) {
+ while ((vb = fr_value_box_list_pop_head(in)) != NULL) {
fr_dcursor_append(out, vb);
}
*/
static xlat_action_t xlat_func_explode(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *strings = fr_dlist_head(in);
- fr_value_box_list_t *list = &strings->vb_group;
- fr_value_box_t *delim_vb = fr_dlist_next(in, strings);
+ fr_value_box_t *strings = fr_value_box_list_head(in);
+ FR_DLIST_HEAD(fr_value_box_list) *list = &strings->vb_group;
+ fr_value_box_t *delim_vb = fr_value_box_list_next(in, strings);
ssize_t delim_len;
char const *delim;
fr_value_box_t *string, *vb;
delim = delim_vb->vb_strvalue;
delim_len = delim_vb->vb_length;
- while((string = fr_dlist_pop_head(list))) {
+ while((string = fr_value_box_list_pop_head(list))) {
fr_sbuff_t sbuff = FR_SBUFF_IN(string->vb_strvalue, string->vb_length);
fr_sbuff_marker_t m_start;
*/
static xlat_action_t xlat_func_integer(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *in_vb = fr_dlist_head(in);
+ fr_value_box_t *in_vb = fr_value_box_list_head(in);
char const *p;
fr_strerror_clear(); /* Make sure we don't print old errors */
- fr_dlist_remove(in, in_vb);
+ fr_value_box_list_remove(in, in_vb);
switch (in_vb->type) {
default:
*/
static xlat_action_t xlat_func_map(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
map_t *map = NULL;
int ret;
- fr_value_box_t *fmt_vb = fr_dlist_head(in);
+ fr_value_box_t *fmt_vb = fr_value_box_list_head(in);
fr_value_box_t *vb;
tmpl_rules_t attr_rules = {
*/
static xlat_action_t xlat_func_next_time(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
long num;
char *q;
time_t now;
struct tm *local, local_buff;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_value_box_t *vb;
/*
*/
static xlat_action_t xlat_eval_resume(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
+ UNUSED request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_eval_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_eval_rctx_t);
xlat_action_t xa = rctx->last_success ? XLAT_ACTION_DONE : XLAT_ACTION_FAIL;
*/
static xlat_action_t xlat_func_eval(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_eval_rctx_t *rctx;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
/*
* These are escaping rules applied to the
if (unlang_xlat_yield(request, xlat_eval_resume, NULL, rctx) != XLAT_ACTION_YIELD) goto error;
- if (unlang_xlat_push(ctx, &rctx->last_success, out->dlist,
+ if (unlang_xlat_push(ctx, &rctx->last_success, (FR_DLIST_HEAD(fr_value_box_list) *)out->dlist,
request, rctx->ex, UNLANG_SUB_FRAME) < 0) goto error;
return XLAT_ACTION_PUSH_UNLANG;
*/
static xlat_action_t xlat_func_expr(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_eval_rctx_t *rctx;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
/*
* These are escaping rules applied to the
if (unlang_xlat_yield(request, xlat_eval_resume, NULL, rctx) != XLAT_ACTION_YIELD) goto error;
- if (unlang_xlat_push(ctx, &rctx->last_success, out->dlist,
+ if (unlang_xlat_push(ctx, &rctx->last_success, (FR_DLIST_HEAD(fr_value_box_list) *)out->dlist,
request, rctx->ex, UNLANG_SUB_FRAME) < 0) goto error;
return XLAT_ACTION_PUSH_UNLANG;
*/
static xlat_action_t xlat_func_lpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *args)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args)
{
- fr_value_box_t *values = fr_dlist_head(args);
- fr_value_box_list_t *list = &values->vb_group;
- fr_value_box_t *pad = fr_dlist_next(args, values);
+ fr_value_box_t *values = fr_value_box_list_head(args);
+ FR_DLIST_HEAD(fr_value_box_list) *list = &values->vb_group;
+ fr_value_box_t *pad = fr_value_box_list_next(args, values);
/* coverity[dereference] */
size_t pad_len = (size_t)pad->vb_uint64;
/* coverity[dereference] */
- fr_value_box_t *fill = fr_dlist_next(args, pad);
+ fr_value_box_t *fill = fr_value_box_list_next(args, pad);
char const *fill_str = NULL;
size_t fill_len = 0;
fill_len = 1;
}
- while ((in = fr_dlist_pop_head(list))) {
+ while ((in = fr_value_box_list_pop_head(list))) {
size_t len = talloc_array_length(in->vb_strvalue) - 1;
size_t remaining;
char *buff;
*/
static xlat_action_t xlat_func_rpad(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *args)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args)
{
- fr_value_box_t *values = fr_dlist_head(args);
- fr_value_box_list_t *list = &values->vb_group;
- fr_value_box_t *pad = fr_dlist_next(args, values);
+ fr_value_box_t *values = fr_value_box_list_head(args);
+ FR_DLIST_HEAD(fr_value_box_list) *list = &values->vb_group;
+ fr_value_box_t *pad = fr_value_box_list_next(args, values);
/* coverity[dereference] */
size_t pad_len = (size_t)pad->vb_uint64;
- fr_value_box_t *fill = fr_dlist_next(args, pad);
+ fr_value_box_t *fill = fr_value_box_list_next(args, pad);
char const *fill_str = NULL;
size_t fill_len = 0;
fill_len = 1;
}
- while ((in = fr_dlist_pop_head(list))) {
+ while ((in = fr_value_box_list_pop_head(list))) {
size_t len = talloc_array_length(in->vb_strvalue) - 1;
size_t remaining;
char *buff;
*/
static xlat_action_t xlat_func_base64_encode(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *args)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args)
{
size_t alen;
ssize_t elen;
char *buff;
fr_value_box_t *vb;
- fr_value_box_t *in = fr_dlist_head(args);
+ fr_value_box_t *in = fr_value_box_list_head(args);
alen = FR_BASE64_ENC_LENGTH(in->vb_length);
*/
static xlat_action_t xlat_func_base64_decode(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *args)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *args)
{
size_t alen;
ssize_t declen = 0;
uint8_t *decbuf;
fr_value_box_t *vb;
- fr_value_box_t *in = fr_dlist_head(args);
+ fr_value_box_t *in = fr_value_box_list_head(args);
alen = FR_BASE64_DEC_LENGTH(in->vb_length);
MEM(vb = fr_value_box_alloc_null(ctx));
*/
static xlat_action_t xlat_func_bin(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *result;
char const *p, *end;
fr_sbuff_parse_error_t err;
fr_value_box_t *hex;
- hex = fr_dlist_head(in);
+ hex = fr_value_box_list_head(in);
len = hex->vb_length;
if ((len > 1) && (len & 0x01)) {
REDEBUG("Input data length must be >1 and even, got %zu", len);
*/
static xlat_action_t xlat_func_cast(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *name = fr_dlist_head(in);
+ fr_value_box_t *name = fr_value_box_list_head(in);
fr_value_box_t *arg;
fr_type_t type;
fr_sbuff_t *agg;
fr_value_box_t *dst;
- (void) fr_dlist_pop_head(in);
+ (void) fr_value_box_list_pop_head(in);
talloc_free(name);
FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, 8192);
* Copy inputs to outputs, casting them along the way.
*/
arg = name;
- while ((arg = fr_dlist_next(in, arg)) != NULL) {
+ while ((arg = fr_value_box_list_next(in, arg)) != NULL) {
fr_value_box_t *vb, *p;
fr_assert(arg->type == FR_TYPE_GROUP);
- vb = fr_dlist_head(&arg->vb_group);
+ vb = fr_value_box_list_head(&arg->vb_group);
while (vb) {
- p = fr_dlist_remove(&arg->vb_group, vb);
+ p = fr_value_box_list_remove(&arg->vb_group, vb);
if (fr_value_box_cast_in_place(vb, vb, type, NULL) < 0) {
RPEDEBUG("Failed casting %pV to data type '%s'", vb, fr_type_to_str(type));
return XLAT_ACTION_FAIL;
}
fr_dcursor_append(out, vb);
- vb = fr_dlist_next(&arg->vb_group, p);
+ vb = fr_value_box_list_next(&arg->vb_group, p);
}
}
*/
static xlat_action_t xlat_func_concat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *result;
- fr_value_box_t *list = fr_dlist_head(in);
- fr_value_box_t *separator = fr_dlist_next(in, list);
+ fr_value_box_t *list = fr_value_box_list_head(in);
+ fr_value_box_t *separator = fr_value_box_list_next(in, list);
char *buff;
char const *sep;
*/
static xlat_action_t xlat_func_hex(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char *new_buff;
- fr_value_box_t *bin = fr_dlist_pop_head(in); /* First argument */
+ fr_value_box_t *bin = fr_value_box_list_pop_head(in); /* First argument */
/*
* Use existing box, but with new buffer
} hmac_type;
static xlat_action_t xlat_hmac(TALLOC_CTX *ctx, fr_dcursor_t *out,
- fr_value_box_list_t *in, uint8_t *digest, int digest_len, hmac_type type)
+ FR_DLIST_HEAD(fr_value_box_list) *in, uint8_t *digest, int digest_len, hmac_type type)
{
fr_value_box_t *vb, *data, *key;
- data = fr_dlist_head(in);
- key = fr_dlist_next(in, data);
+ data = fr_value_box_list_head(in);
+ key = fr_value_box_list_next(in, data);
if (type == HMAC_MD5) {
/* coverity[dereference] */
*/
static xlat_action_t xlat_func_hmac_md5(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t digest[MD5_DIGEST_LENGTH];
return xlat_hmac(ctx, out, in, digest, MD5_DIGEST_LENGTH, HMAC_MD5);
*/
static xlat_action_t xlat_func_hmac_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t digest[SHA1_DIGEST_LENGTH];
return xlat_hmac(ctx, out, in, digest, SHA1_DIGEST_LENGTH, HMAC_SHA1);
*/
static xlat_action_t xlat_func_join(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *arg = NULL, *vb, *p;
- while ((arg = fr_dlist_next(in, arg))) {
+ while ((arg = fr_value_box_list_next(in, arg))) {
fr_assert(arg->type == FR_TYPE_GROUP);
- vb = fr_dlist_head(&arg->vb_group);
+ vb = fr_value_box_list_head(&arg->vb_group);
while (vb) {
- p = fr_dlist_remove(&arg->vb_group, vb);
+ p = fr_value_box_list_remove(&arg->vb_group, vb);
fr_dcursor_append(out, vb);
- vb = fr_dlist_next(&arg->vb_group, p);
+ vb = fr_value_box_list_next(&arg->vb_group, p);
}
}
return XLAT_ACTION_DONE;
}
-static void ungroup(fr_dcursor_t *out, fr_value_box_list_t *in)
+static void ungroup(fr_dcursor_t *out, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
- while ((vb = fr_dlist_pop_head(in)) != NULL) {
+ while ((vb = fr_value_box_list_pop_head(in)) != NULL) {
if (vb->type != FR_TYPE_GROUP) {
fr_dcursor_append(out, vb);
continue;
*/
static xlat_action_t xlat_func_ungroup(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *arg = NULL;
- while ((arg = fr_dlist_next(in, arg)) != NULL) {
+ while ((arg = fr_value_box_list_next(in, arg)) != NULL) {
fr_assert(arg->type == FR_TYPE_GROUP);
ungroup(out, &arg->vb_group);
*/
static xlat_action_t xlat_func_length(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb = NULL;
- while ((vb = fr_dlist_next(in, vb))) {
+ while ((vb = fr_value_box_list_next(in, vb))) {
fr_value_box_t *my;
MEM(my = fr_value_box_alloc(ctx, FR_TYPE_SIZE, NULL, false));
*/
static xlat_action_t xlat_func_md4(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t digest[MD5_DIGEST_LENGTH];
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
if (in_head) {
fr_md4_calc(digest, in_head->vb_octets, in_head->vb_length);
*/
static xlat_action_t xlat_func_md5(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t digest[MD5_DIGEST_LENGTH];
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
if (in_head) {
fr_md5_calc(digest, in_head->vb_octets, in_head->vb_length);
*/
static xlat_action_t xlat_func_module(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb = NULL;
*/
static xlat_action_t xlat_func_pack(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
* Input boxes are already cast to FR_TYPE_OCTETS and concatenated
* by the input argument parser - so simply move to the output
*/
- vb = fr_dlist_pop_head(in);
+ vb = fr_value_box_list_pop_head(in);
fr_dcursor_append(out, vb);
return XLAT_ACTION_DONE;
*/
static xlat_action_t xlat_func_pairs(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
tmpl_t *vpt = NULL;
fr_dcursor_t cursor;
tmpl_dcursor_ctx_t cc;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_pair_t *vp;
*/
static xlat_action_t xlat_func_rand(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
int64_t result;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
result = in_head->vb_uint32;
*/
static xlat_action_t xlat_func_randstr(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
/*
* Lookup tables for randstr char classes
unsigned int reps;
size_t outlen = 0;
fr_value_box_t* vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/** Max repetitions of a single character class
*
*/
static xlat_action_t xlat_func_regex(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/*
* Return the complete capture if no other capture is specified
*/
fr_value_box_t *vb;
char *p;
- if (fr_dlist_next(in, in_head)) {
+ if (fr_value_box_list_next(in, in_head)) {
REDEBUG("Only one subcapture argument allowed");
return XLAT_ACTION_FAIL;
}
*/
static xlat_action_t xlat_func_sha1(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t digest[SHA1_DIGEST_LENGTH];
fr_sha1_ctx sha1_ctx;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_sha1_init(&sha1_ctx);
if (in_head) {
#ifdef HAVE_OPENSSL_EVP_H
static xlat_action_t xlat_evp_md(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in, EVP_MD const *md)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in, EVP_MD const *md)
{
uint8_t digest[EVP_MAX_MD_SIZE];
unsigned int digestlen;
EVP_MD_CTX *md_ctx;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
md_ctx = EVP_MD_CTX_create();
EVP_DigestInit_ex(md_ctx, md, NULL);
static xlat_action_t xlat_func_##_md(TALLOC_CTX *ctx, fr_dcursor_t *out,\
xlat_ctx_t const *xctx, \
request_t *request,\
- fr_value_box_list_t *in)\
+ FR_DLIST_HEAD(fr_value_box_list) *in)\
{\
return xlat_evp_md(ctx, out, xctx, request, in, EVP_##_md_func());\
}
*/
static xlat_action_t xlat_func_string(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *in_head = fr_dlist_pop_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_pop_head(in);
/*
* Casting and concat is done by arg processing
*/
static xlat_action_t xlat_func_strlen(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_SIZE, NULL, false));
*/
static xlat_action_t xlat_func_subst_regex(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *p, *q, *end;
char const *regex;
regex_t *pattern;
fr_regex_flags_t flags;
fr_value_box_t *vb;
- fr_value_box_t *subject_vb = fr_dlist_head(in);
- fr_value_box_t *regex_vb = fr_dlist_next(in, subject_vb);
- fr_value_box_t *rep_vb = fr_dlist_next(in, regex_vb);
+ fr_value_box_t *subject_vb = fr_value_box_list_head(in);
+ fr_value_box_t *regex_vb = fr_value_box_list_next(in, subject_vb);
+ fr_value_box_t *rep_vb = fr_value_box_list_next(in, regex_vb);
/* coverity[dereference] */
p = regex_vb->vb_strvalue;
#else
UNUSED xlat_ctx_t const *xctx,
#endif
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *p, *q, *end;
char *vb_str;
size_t pattern_len, rep_len;
fr_value_box_t *rep_vb, *vb;
- fr_value_box_t *subject_vb = fr_dlist_head(in);
- fr_value_box_t *pattern_vb = fr_dlist_next(in, subject_vb);
+ fr_value_box_t *subject_vb = fr_value_box_list_head(in);
+ fr_value_box_t *pattern_vb = fr_value_box_list_next(in, subject_vb);
/* coverity[dereference] */
pattern = pattern_vb->vb_strvalue;
return XLAT_ACTION_FAIL;
}
- rep_vb = fr_dlist_next(in, pattern_vb);
+ rep_vb = fr_value_box_list_next(in, pattern_vb);
rep = rep_vb->vb_strvalue;
rep_len = rep_vb->vb_length;
* If upper is true, change to uppercase, otherwise, change to lowercase
*/
static xlat_action_t xlat_change_case(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
- UNUSED request_t *request, fr_value_box_list_t *in, bool upper)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in, bool upper)
{
char *p;
char const *end;
- fr_value_box_t *vb = fr_dlist_pop_head(in);
+ fr_value_box_t *vb = fr_value_box_list_pop_head(in);
p = UNCONST(char *, vb->vb_strvalue);
end = p + vb->vb_length;
*/
static xlat_action_t xlat_func_tolower(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
return xlat_change_case(ctx, out, request, in, false);
}
*/
static xlat_action_t xlat_func_toupper(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
return xlat_change_case(ctx, out, request, in, true);
}
*/
static xlat_action_t xlat_func_urlquote(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *p, *end;
char *buff_p;
size_t outlen = 0;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
p = in_head->vb_strvalue;
end = p + in_head->vb_length;
*/
static xlat_action_t xlat_func_urlunquote(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *p, *end;
char *buff_p;
char *c1, *c2;
size_t outlen = 0;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
p = in_head->vb_strvalue;
end = p + in_head->vb_length;
*/
static xlat_action_t protocol_decode_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
int decoded;
fr_value_box_t *vb;
*/
static xlat_action_t protocol_encode_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
tmpl_t *vpt;
fr_pair_t *vp;
uint8_t binbuf[2048];
uint8_t *p = binbuf, *end = p + sizeof(binbuf);
ssize_t len = 0;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
void *encode_ctx = NULL;
fr_test_point_pair_encode_t const *tp_encode;
* @param[in] node Being processed.
* @param[in] args from previous expansion.
*/
-static inline void xlat_debug_log_expansion(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *args, UNUSED int line)
+static inline void xlat_debug_log_expansion(request_t *request, xlat_exp_t const *node, FR_DLIST_HEAD(fr_value_box_list) const *args, UNUSED int line)
{
if (node->flags.constant) return;
* @param[in] request The current request.
* @param[in] result of the expansion.
*/
-static inline void xlat_debug_log_list_result(request_t *request, xlat_exp_t const *node, fr_value_box_list_t const *result)
+static inline void xlat_debug_log_list_result(request_t *request, xlat_exp_t const *node, FR_DLIST_HEAD(fr_value_box_list) const *result)
{
if (node->flags.constant) return;
* - XLAT_ACTION_DONE on success.
* - XLAT_ACTION_FAIL on failure.
*/
-static xlat_action_t xlat_process_arg_list(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request,
+static xlat_action_t xlat_process_arg_list(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *list, request_t *request,
char const *name, xlat_arg_parser_t const *arg, unsigned int arg_num)
{
fr_value_box_t *vb;
} \
} while (0)
- if (fr_dlist_empty(list)) {
+ if (fr_value_box_list_empty(list)) {
if (arg->required) {
RWDEBUG("Function %s is missing required argument %u", name, arg_num);
return XLAT_ACTION_FAIL;
return XLAT_ACTION_DONE;
}
- vb = fr_dlist_head(list);
+ vb = fr_value_box_list_head(list);
/*
* Concatenate child boxes, casting to desired type,
*/
if (arg->concat) {
if (arg->func) {
- do ESCAPE(arg, vb, arg_num); while ((vb = fr_dlist_next(list, vb)));
+ do ESCAPE(arg, vb, arg_num); while ((vb = fr_value_box_list_next(list, vb)));
- vb = fr_dlist_head(list); /* Reset */
+ vb = fr_value_box_list_head(list); /* Reset */
}
if (fr_value_box_list_concat_in_place(ctx,
RPEDEBUG("Function %s failed concatenating arguments to type %s", name, fr_type_to_str(arg->type));
return XLAT_ACTION_FAIL;
}
- fr_assert(fr_dlist_num_elements(list) <= 1);
+ fr_assert(fr_value_box_list_num_elements(list) <= 1);
return XLAT_ACTION_DONE;
}
* just one, cast to the correct type
*/
if (arg->single) {
- if (fr_dlist_num_elements(list) > 1) {
+ if (fr_value_box_list_num_elements(list) > 1) {
RPEDEBUG("Function %s was provided an incorrect number of values at argument %u, "
"expected %s got %u",
name, arg_num,
arg->required ? "0-1" : "1",
- fr_dlist_num_elements(list));
+ fr_value_box_list_num_elements(list));
return XLAT_ACTION_FAIL;
}
if (vb->type == arg->type) continue;
if (fr_value_box_cast_in_place(ctx, vb,
arg->type, NULL) < 0) goto cast_error;
- } while ((vb = fr_dlist_next(list, vb)));
+ } while ((vb = fr_value_box_list_next(list, vb)));
/*
* If it's not a void type we still need to escape the values
*/
} else if (arg->func) {
- do ESCAPE(arg, vb, arg_num); while ((vb = fr_dlist_next(list, vb)));
+ do ESCAPE(arg, vb, arg_num); while ((vb = fr_value_box_list_next(list, vb)));
}
#undef ESCAPE
* @param[in] func to call
*/
static inline CC_HINT(always_inline)
-xlat_action_t xlat_process_args(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request, xlat_t const *func)
+xlat_action_t xlat_process_args(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *list, request_t *request, xlat_t const *func)
{
xlat_arg_parser_t const *arg_p = func->args;
xlat_action_t xa;
* xlat consumes a sequence of arguments.
*/
case XLAT_INPUT_ARGS:
- vb = fr_dlist_head(list);
+ vb = fr_value_box_list_head(list);
while (arg_p->type != FR_TYPE_NULL) {
/*
* Separate check to see if the group
* pre-advance, in case the vb is replaced
* during processing.
*/
- next = fr_dlist_next(list, vb);
+ next = fr_value_box_list_next(list, vb);
xa = xlat_process_arg_list(ctx, &vb->vb_group, request, func->name, arg_p,
(unsigned int)((arg_p - func->args) + 1));
if (xa != XLAT_ACTION_DONE) return xa;
/*
* This argument doesn't exist. That might be OK, or it may be a fatal error.
*/
- if (fr_dlist_empty(&vb->vb_group)) {
+ if (fr_value_box_list_empty(&vb->vb_group)) {
/*
* Empty groups for optional arguments are OK, we can just stop processing the list.
*/
* accessing the box as vb_uint8, hoping that it's being passed
* the right thing.
*/
- fr_dlist_remove(list, vb);
+ fr_value_box_list_remove(list, vb);
talloc_free(vb);
break;
}
* xlat_process_arg_list() has already done concatenations for us.
*/
if (arg_p->single || arg_p->concat) {
- fr_dlist_replace(list, vb, fr_dlist_pop_head(&vb->vb_group));
+ fr_value_box_list_replace(list, vb, fr_value_box_list_pop_head(&vb->vb_group));
talloc_free(vb);
}
*
*/
static inline CC_HINT(always_inline)
-xlat_action_t xlat_eval_one_letter(TALLOC_CTX *ctx, fr_value_box_list_t *out, request_t *request, char letter)
+xlat_action_t xlat_eval_one_letter(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, request_t *request, char letter)
{
char buffer[64];
return XLAT_ACTION_FAIL;
}
- fr_dlist_insert_tail(out, value);
+ fr_value_box_list_insert_tail(out, value);
return XLAT_ACTION_DONE;
}
typedef struct {
int status;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
} xlat_exec_rctx_t;
static xlat_action_t xlat_exec_resume(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
+ UNUSED request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_exec_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_exec_rctx_t);
return XLAT_ACTION_FAIL;
}
- fr_dlist_move(out->dlist, &rctx->list);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, &rctx->list);
return XLAT_ACTION_DONE;
}
*/
xlat_action_t xlat_frame_eval_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_func_t resume, xlat_exp_t const *exp,
- request_t *request, fr_value_box_list_t *result, void *rctx)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *result, void *rctx)
{
xlat_thread_inst_t *t;
xlat_action_t xa;
xlat_action_t xlat_frame_eval_repeat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_exp_head_t const **child, bool *alternate,
request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in,
- fr_value_box_list_t *result)
+ FR_DLIST_HEAD(fr_value_box_list) *result)
{
xlat_exp_t const *node = *in;
{
xlat_action_t xa;
xlat_thread_inst_t *t;
- fr_value_box_list_t result_copy;
+ FR_DLIST_HEAD(fr_value_box_list) result_copy;
t = xlat_thread_instance_find(node);
fr_assert(t);
if (RDEBUG_ENABLED2) fr_value_box_list_acopy(unlang_interpret_frame_talloc_ctx(request), &result_copy, result);
xa = xlat_process_args(ctx, result, request, node->call.func);
if (xa == XLAT_ACTION_FAIL) {
- fr_dlist_talloc_free(&result_copy);
+ fr_value_box_list_talloc_free(&result_copy);
return xa;
}
xlat_debug_log_expansion(request, *in, &result_copy, __LINE__);
RINDENT();
}
- fr_dlist_talloc_free(&result_copy);
+ fr_value_box_list_talloc_free(&result_copy);
switch (xa) {
case XLAT_ACTION_FAIL:
/*
* No result from the first child, try the alternate
*/
- if (fr_dlist_empty(result)) {
+ if (fr_value_box_list_empty(result)) {
/*
* Already tried the alternate
*/
xlat_debug_log_list_result(request, *in, result);
VALUE_BOX_TALLOC_LIST_VERIFY(result);
- fr_dlist_move(out->dlist, result);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, result);
}
break;
MEM(arg = fr_value_box_alloc(ctx, FR_TYPE_GROUP, NULL, false));
- if (!fr_dlist_empty(result)) {
+ if (!fr_value_box_list_empty(result)) {
VALUE_BOX_TALLOC_LIST_VERIFY(result);
- fr_dlist_move(&arg->vb_group, result);
+ fr_value_box_list_move(&arg->vb_group, result);
}
// xlat_debug_log_expansion(request, *in, NULL, __LINE__);
fr_assert(tmpl_is_exec(node->vpt));
if (tmpl_eval_cast(ctx, result, node->vpt) < 0) {
- fr_dlist_talloc_free(result);
+ fr_value_box_list_talloc_free(result);
return XLAT_ACTION_FAIL;
}
* First entry is the command to run. Subsequent entries are the options to pass to the
* command.
*/
- fr_dlist_move(out->dlist, result);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, result);
break;
default:
{
xlat_action_t xa = XLAT_ACTION_DONE;
xlat_exp_t const *node;
- fr_value_box_list_t result; /* tmp list so debug works correctly */
+ FR_DLIST_HEAD(fr_value_box_list) result; /* tmp list so debug works correctly */
fr_value_box_t *value;
fr_value_box_list_init(&result);
for (node = *in; node; node = xlat_exp_next(head, node)) {
*in = node; /* Update node in our caller */
fr_dcursor_tail(out); /* Needed for debugging */
- VALUE_BOX_TALLOC_LIST_VERIFY(out->dlist);
+ VALUE_BOX_TALLOC_LIST_VERIFY((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist);
- fr_assert(fr_dlist_num_elements(&result) == 0); /* Should all have been moved */
+ fr_assert(fr_value_box_list_num_elements(&result) == 0); /* Should all have been moved */
switch (node->type) {
case XLAT_BOX:
xlat_debug_log_expansion(request, node, NULL, __LINE__);
if (xlat_eval_one_letter(ctx, &result, request, node->fmt[0]) == XLAT_ACTION_FAIL) {
fail:
- fr_dlist_talloc_free(&result);
+ fr_value_box_list_talloc_free(&result);
xa = XLAT_ACTION_FAIL;
goto finish;
}
xlat_debug_log_list_result(request, *in, &result);
- fr_dlist_move(out->dlist, &result);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, &result);
continue;
case XLAT_TMPL:
tmpl_value(node->vpt)->tainted));
fr_value_box_copy(value, value, tmpl_value(node->vpt)); /* Also dups taint */
- fr_dlist_insert_tail(&result, value);
+ fr_value_box_list_insert_tail(&result, value);
/*
* Cast the results if necessary.
*/
if (tmpl_eval_cast(ctx, &result, node->vpt) < 0) goto fail;
- fr_dlist_move(out->dlist, &result);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, &result);
continue;
} else if (tmpl_is_attr(node->vpt) || tmpl_is_list(node->vpt)) {
}
xlat_debug_log_list_result(request, node, &result);
- fr_dlist_move(out->dlist, &result);
+ fr_value_box_list_move((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist, &result);
continue;
case XLAT_VIRTUAL:
}
finish:
- VALUE_BOX_TALLOC_LIST_VERIFY(out->dlist);
+ VALUE_BOX_TALLOC_LIST_VERIFY((FR_DLIST_HEAD(fr_value_box_list) *)out->dlist);
XLAT_DEBUG("** [%i] %s << %s", unlang_interpret_stack_depth(request),
__FUNCTION__, fr_table_str_by_value(xlat_action_table, xa, "<INVALID>"));
static ssize_t xlat_eval_sync(TALLOC_CTX *ctx, char **out, request_t *request, xlat_exp_head_t const * const head,
xlat_escape_legacy_t escape, void const *escape_ctx)
{
- fr_value_box_list_t result;
+ FR_DLIST_HEAD(fr_value_box_list) result;
bool success = false;
TALLOC_CTX *pool = talloc_new(NULL);
rlm_rcode_t rcode;
}
if (!success) goto eval_failed;
- if (!fr_dlist_empty(&result)) {
+ if (!fr_value_box_list_empty(&result)) {
if (escape) {
fr_value_box_t *vb = NULL;
/*
* For tainted boxes perform the requested escaping
*/
- while ((vb = fr_dlist_next(&result, vb))) {
- fr_dlist_t entry;
+ while ((vb = fr_value_box_list_next(&result, vb))) {
+ FR_DLIST_ENTRY(fr_value_box_list) entry;
size_t len, real_len;
char *escaped;
my_argv[i++] = talloc_steal(my_argv, node->group);
}
- fr_dlist_talloc_free(&head->dlist);
+ fr_value_box_list_talloc_free((FR_DLIST_HEAD(fr_value_box_list) *)&head->dlist);
return count;
}
static xlat_action_t xlat_binary_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in,
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in,
fr_token_t op,
fr_type_t default_type, fr_dict_attr_t const *enumv)
{
/*
* Each argument is a FR_TYPE_GROUP, with one or more elements in a list.
*/
- a = fr_dlist_head(in);
- b = fr_dlist_next(in, a);
+ a = fr_value_box_list_head(in);
+ b = fr_value_box_list_next(in, a);
#ifdef STATIC_ANALYZER
if (!a || !b) return XLAT_ACTION_FAIL;
fr_assert(b->type == FR_TYPE_GROUP);
if (!fr_equality_op[op]) {
- if (fr_dlist_num_elements(&a->vb_group) != 1) {
+ if (fr_value_box_list_num_elements(&a->vb_group) != 1) {
REDEBUG("Expected one value as the first argument, got %d",
- fr_dlist_num_elements(&a->vb_group));
+ fr_value_box_list_num_elements(&a->vb_group));
return XLAT_ACTION_FAIL;
}
- if (fr_dlist_num_elements(&b->vb_group) != 1) {
+ if (fr_value_box_list_num_elements(&b->vb_group) != 1) {
REDEBUG("Expected one value as the second argument, got %d",
- fr_dlist_num_elements(&b->vb_group));
+ fr_value_box_list_num_elements(&b->vb_group));
return XLAT_ACTION_FAIL;
}
rcode = fr_value_calc_binary_op(dst, dst, default_type,
- fr_dlist_head(&a->vb_group),
+ fr_value_box_list_head(&a->vb_group),
op,
- fr_dlist_head(&b->vb_group));
+ fr_value_box_list_head(&b->vb_group));
} else {
rcode = fr_value_calc_list_cmp(dst, dst, &a->vb_group, op, &b->vb_group);
}
*/
static xlat_action_t xlat_paircmp_func(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *dst, *vb_da, *vb;
fr_dict_attr_t const *da;
char const *p;
- vb_da = fr_dlist_head(in);
- vb = fr_dlist_next(in, vb_da);
+ vb_da = fr_value_box_list_head(in);
+ vb = fr_value_box_list_next(in, vb_da);
#ifdef STATIC_ANALYZER
if (!vb_da || !vb) return XLAT_ACTION_FAIL;
#define XLAT_BINARY_FUNC(_name, _op) \
static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
xlat_ctx_t const *xctx, \
- request_t *request, fr_value_box_list_t *in) \
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in) \
{ \
return xlat_binary_op(ctx, out, xctx, request, in, _op, FR_TYPE_NULL, NULL); \
}
#define XLAT_CMP_FUNC(_name, _op) \
static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
xlat_ctx_t const *xctx, \
- request_t *request, fr_value_box_list_t *in) \
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in) \
{ \
return xlat_binary_op(ctx, out, xctx, request, in, _op, FR_TYPE_BOOL, attr_expr_bool_enum); \
}
typedef struct {
bool last_success;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
} xlat_regex_rctx_t;
static fr_slen_t xlat_expr_print_regex(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
* - 0 for "no match".
* - 1 for "match".
*/
-static xlat_action_t xlat_regex_match(TALLOC_CTX *ctx, request_t *request, fr_value_box_list_t *in, regex_t **preg,
+static xlat_action_t xlat_regex_match(TALLOC_CTX *ctx, request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in, regex_t **preg,
fr_dcursor_t *out, fr_token_t op)
{
uint32_t subcaptures;
FR_SBUFF_TALLOC_THREAD_LOCAL(&agg, 256, 8192);
- arg = fr_dlist_head(in);
+ arg = fr_value_box_list_head(in);
fr_assert(arg != NULL);
fr_assert(arg->type == FR_TYPE_GROUP);
if (!subcaptures) subcaptures = REQUEST_MAX_REGEX + 1; /* +1 for %{0} (whole match) capture group */
MEM(regmatch = regex_match_data_alloc(NULL, subcaptures));
- while ((vb = fr_dlist_pop_head(&arg->vb_group)) != NULL) {
+ while ((vb = fr_value_box_list_pop_head(&arg->vb_group)) != NULL) {
if (vb->type == FR_TYPE_STRING) {
subject = vb->vb_strvalue;
len = vb->vb_length;
} else {
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
fr_value_box_list_init(&list);
- fr_dlist_insert_head(&list, vb);
+ fr_value_box_list_insert_head(&list, vb);
vb = NULL;
/*
static xlat_action_t xlat_regex_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_regex_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_regex_inst_t);
xlat_regex_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_regex_rctx_t);
static xlat_action_t xlat_regex_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in,
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in,
fr_token_t op)
{
xlat_regex_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_regex_inst_t);
#define XLAT_REGEX_FUNC(_name, _op) \
static xlat_action_t xlat_func_ ## _name(TALLOC_CTX *ctx, fr_dcursor_t *out, \
xlat_ctx_t const *xctx, \
- request_t *request, fr_value_box_list_t *in) \
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in) \
{ \
return xlat_regex_op(ctx, out, xctx, request, in, _op); \
}
bool last_success;
fr_value_box_t *box; //!< output value-box
int current;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
} xlat_logical_rctx_t;
static fr_slen_t xlat_expr_print_logical(fr_sbuff_t *out, xlat_exp_t const *node, void *instance, fr_sbuff_escape_rules_t const *e_rules)
*
* Empty lists are not truthy.
*/
-static bool xlat_logical_match(fr_value_box_t **dst, fr_value_box_list_t const *in, bool logical_or)
+static bool xlat_logical_match(fr_value_box_t **dst, FR_DLIST_HEAD(fr_value_box_list) const *in, bool logical_or)
{
fr_value_box_t *last = NULL;
/*
* Empty lists are !truthy.
*/
- if (!fr_dlist_num_elements(in)) {
- return false;
- }
+ if (!fr_value_box_list_num_elements(in)) return false;
/*
* Loop over the input list. If the box is a group, then do this recursively.
*/
- fr_value_box_foreach(in, box) {
+ fr_value_box_list_foreach(in, box) {
if (fr_box_is_group(box)) {
if (!xlat_logical_match(dst, &box->vb_group, logical_or)) return false;
continue;
static xlat_action_t xlat_logical_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in);
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in);
/** Process one argument of a logical operation.
*
*/
static xlat_action_t xlat_logical_process_arg(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
xlat_logical_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_logical_rctx_t);
*/
static xlat_action_t xlat_logical_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_logical_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_logical_inst_t);
xlat_logical_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_logical_rctx_t);
}
next:
- fr_dlist_talloc_free(&rctx->list);
+ fr_value_box_list_talloc_free(&rctx->list);
rctx->current++;
/*
*/
static xlat_action_t xlat_func_logical(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_logical_rctx_t *rctx;
static xlat_action_t xlat_func_unary_op(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in, fr_token_t op)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in, fr_token_t op)
{
int rcode;
fr_value_box_t *dst, *group, *vb;
/*
* We do some basic type checks here.
*/
- group = fr_dlist_head(in);
- vb = fr_dlist_head(&group->vb_group);
+ group = fr_value_box_list_head(in);
+ vb = fr_value_box_list_head(&group->vb_group);
/*
* -NULL is an error
static xlat_action_t xlat_func_unary_not(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- UNUSED request_t *request, fr_value_box_list_t *in)
+ UNUSED request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *dst, *group, *vb;
- group = fr_dlist_head(in);
- vb = fr_dlist_head(&group->vb_group);
+ group = fr_value_box_list_head(in);
+ vb = fr_value_box_list_head(&group->vb_group);
/*
* Don't call calc_unary_op(), because we want the enum names.
static xlat_action_t xlat_func_unary_minus(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
return xlat_func_unary_op(ctx, out, xctx, request, in, T_SUB);
}
static xlat_action_t xlat_func_unary_complement(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
return xlat_func_unary_op(ctx, out, xctx, request, in, T_COMPLEMENT);
}
*/
static xlat_action_t xlat_func_rcode(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
- fr_value_box_t *src = fr_dlist_head(in);
+ fr_value_box_t *src = fr_value_box_list_head(in);
/*
* Query the rcode if there's no argument. Otherwise do a boolean check if the passed string
typedef struct {
bool last_success;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
} xlat_exists_rctx_t;
static xlat_arg_parser_t const xlat_func_exists_arg = {
static xlat_action_t xlat_exists_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_exists_rctx_t *rctx = talloc_get_type_abort(xctx->rctx, xlat_exists_rctx_t);
ssize_t slen;
return XLAT_ACTION_FAIL;
}
- vb = fr_dlist_head(&rctx->list);
+ vb = fr_value_box_list_head(&rctx->list);
slen = tmpl_afrom_attr_str(ctx, NULL, &vpt, vb->vb_strvalue,
&(tmpl_rules_t) {
*/
static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
xlat_exists_inst_t const *inst = talloc_get_type_abort_const(xctx->inst, xlat_exists_inst_t);
xlat_exists_rctx_t *rctx;
*/
int xlat_decode_value_box_list(TALLOC_CTX *ctx, fr_pair_list_t *out,
request_t *request, void *decode_ctx, fr_pair_decode_t decode,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
int decoded = 0;
fr_value_box_t *vb = NULL;
fr_pair_list_init(&head);
- while ((vb = fr_dlist_next(in, vb))) {
+ while ((vb = fr_value_box_list_next(in, vb))) {
ssize_t len;
if (vb->type != FR_TYPE_OCTETS) {
xlat_action_t xlat_frame_eval_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_func_t resume, xlat_exp_t const *exp,
- request_t *request, fr_value_box_list_t *result, void *rctx);
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *result, void *rctx);
xlat_action_t xlat_frame_eval_repeat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_exp_head_t const **child, bool *alternate,
request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in,
- fr_value_box_list_t *result) CC_HINT(nonnull(1,2,3,5));
+ FR_DLIST_HEAD(fr_value_box_list) *result) CC_HINT(nonnull(1,2,3,5));
xlat_action_t xlat_frame_eval(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_exp_head_t const **child,
request_t *request, xlat_exp_head_t const *head, xlat_exp_t const **in);
void unlang_xlat_init(void);
-int unlang_xlat_push_node(TALLOC_CTX *ctx, bool *p_success, fr_value_box_list_t *out,
+int unlang_xlat_push_node(TALLOC_CTX *ctx, bool *p_success, FR_DLIST_HEAD(fr_value_box_list) *out,
request_t *request, xlat_exp_t *node);
int xlat_decode_value_box_list(TALLOC_CTX *ctx, fr_pair_list_t *out,
request_t *request, void *decode_ctx, fr_pair_decode_t decode,
- fr_value_box_list_t *in);
+ FR_DLIST_HEAD(fr_value_box_list) *in);
/*
* xlat_expr.c
*/
#include <freeradius-devel/unlang/xlat_priv.h>
#include <freeradius-devel/util/calc.h>
-static void xlat_value_list_to_xlat(xlat_exp_head_t *head, fr_value_box_list_t *list)
+static void xlat_value_list_to_xlat(xlat_exp_head_t *head, FR_DLIST_HEAD(fr_value_box_list) *list)
{
fr_value_box_t *box;
xlat_exp_t *node;
- while ((box = fr_dlist_pop_head(list)) != NULL) {
+ while ((box = fr_value_box_list_pop_head(list)) != NULL) {
MEM(node = xlat_exp_alloc_null(head));
node->type = XLAT_BOX;
int rcode;
bool success;
xlat_exp_head_t *group;
- fr_value_box_list_t list;
+ FR_DLIST_HEAD(fr_value_box_list) list;
xlat_flags_t our_flags;
if (!head->flags.can_purify) return 0;
*/
rcode = 0; /* in case group is empty */
- while ((vb = fr_dlist_next(&src->vb_group, vb)) != NULL) {
+ while ((vb = fr_value_box_list_next(&src->vb_group, vb)) != NULL) {
rcode = fr_value_calc_binary_op(ctx, dst, dst->type, dst, op, vb);
if (rcode < 0) break;
}
/** Apply a set of operations in order to create an output box.
*
*/
-int fr_value_calc_list_op(TALLOC_CTX *ctx, fr_value_box_t *box, fr_token_t op, fr_value_box_list_t const *list)
+int fr_value_calc_list_op(TALLOC_CTX *ctx, fr_value_box_t *box, fr_token_t op, FR_DLIST_HEAD(fr_value_box_list) const *list)
{
/*
* For octets and string and prepend / append, figure out
uint8_t *str, *p;
fr_value_box_t src;
- fr_dlist_foreach(list,fr_value_box_t const, a) {
+ fr_value_box_list_foreach(list, a) {
if (a->type != box->type) {
len = 0;
break;
}
p = str;
- fr_dlist_foreach(list,fr_value_box_t const, a) {
+ fr_value_box_list_foreach(list, a) {
memcpy(p, a->vb_octets, a->vb_length);
p += a->vb_length;
tainted |= a->tainted;
}
brute_force:
- fr_dlist_foreach(list,fr_value_box_t const, a) {
+ fr_value_box_list_foreach(list, a) {
if (fr_value_calc_binary_op(ctx, box, box->type, box, op, a) < 0) return -1;
}
* This implementation is arguably wrong... it should be checking individual entries in list1 against individual entries in list2.
* Instead, it checks if ANY entry in list1 matches ANY entry in list2.
*/
-int fr_value_calc_list_cmp(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_list_t const *list1, fr_token_t op, fr_value_box_list_t const *list2)
+int fr_value_calc_list_cmp(TALLOC_CTX *ctx, fr_value_box_t *dst, FR_DLIST_HEAD(fr_value_box_list) const *list1, fr_token_t op, FR_DLIST_HEAD(fr_value_box_list) const *list2)
{
int rcode;
bool invert = false;
/*
* Emulate v3. :(
*/
- fr_dlist_foreach(list1, fr_value_box_t, a) {
- fr_dlist_foreach(list2, fr_value_box_t, b) {
+ fr_value_box_list_foreach(list1, a) {
+ fr_value_box_list_foreach(list2, b) {
rcode = fr_value_calc_binary_op(ctx, dst, FR_TYPE_BOOL, a, op, b);
if (rcode < 0) return rcode;
int fr_value_calc_unary_op(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_token_t op, fr_value_box_t const *src) CC_HINT(nonnull(1));
-int fr_value_calc_list_op(TALLOC_CTX *ctx, fr_value_box_t *box, fr_token_t op, fr_value_box_list_t const *list);
+int fr_value_calc_list_op(TALLOC_CTX *ctx, fr_value_box_t *box, fr_token_t op, FR_DLIST_HEAD(fr_value_box_list) const *list);
-int fr_value_calc_list_cmp(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_value_box_list_t const *list1, fr_token_t op, fr_value_box_list_t const *list2) CC_HINT(nonnull);
+int fr_value_calc_list_cmp(TALLOC_CTX *ctx, fr_value_box_t *dst, FR_DLIST_HEAD(fr_value_box_list) const *list1, fr_token_t op, FR_DLIST_HEAD(fr_value_box_list) const *list2) CC_HINT(nonnull);
#ifdef __cplusplus
}
fr_dict_attr_t *dict_attr_child_by_num(fr_dict_attr_t const *parent, unsigned int attr);
-ssize_t dict_by_protocol_substr(fr_dict_attr_err_t *err,
+fr_slen_t dict_by_protocol_substr(fr_dict_attr_err_t *err,
fr_dict_t **out, fr_sbuff_t *name, fr_dict_t const *dict_def);
fr_dict_t *dict_by_protocol_name(char const *name);
* Does nothing if the list was not initialised with #fr_dlist_talloc_init.
*/
#ifndef TALLOC_GET_TYPE_ABORT_NOOP
-static inline CC_HINT(nonnull) void fr_dlist_verify(NDEBUG_UNUSED char const *file, NDEBUG_UNUSED int line,
- fr_dlist_head_t const *list_head)
+static inline CC_HINT(nonnull) void _fr_dlist_verify(char const *file, int line, fr_dlist_head_t const *list_head)
{
void *item;
if (!list_head->type) return;
- fr_assert_msg(fr_dlist_initialised(list_head), "CONSISTENCY CHECK FAILED %s[%i]: dlist not initialised",
- file, line);
+ fr_assert_msg(fr_dlist_initialised(list_head), "CONSISTENCY CHECK FAILED %s[%i]: dlist not initialised", file, line);
for (item = fr_dlist_head(list_head);
item;
item = _talloc_get_type_abort(item, list_head->type, __location__);
}
}
-# define FR_DLIST_VERIFY(_head) fr_dlist_verify(__FILE__, __LINE__, _head)
-#elif !defined(NDEBUG)
-# define FR_DLIST_VERIFY(_head) fr_assert(_head)
#else
-# define FR_DLIST_VERIFY(_head)
+static inline void _fr_dlist_verify(UNUSED char const *file, UNUSED int line, fr_dlist_head_t const *list_head)
+{
+ if (!fr_cond_assert(list_head != NULL)) return;
+}
#endif
+#define fr_dlist_verify(_head) _fr_dlist_verify(__FILE__, __LINE__, _head)
/** Merge two lists, inserting the source at the tail of the destination
*
#define FR_DLIST_FUNCS(_name, _element_type, _element_entry) \
DIAG_OFF(unused-function) \
_Static_assert(IS_FIELD_COMPATIBLE(_element_type, _element_entry, FR_DLIST_ENTRY(_name)) == 1, "Bad dlist entry field type");\
- static inline fr_dlist_head_t *_name ## _list_head(FR_DLIST_HEAD(_name) const *list) \
+ static inline fr_dlist_head_t *_name ## _dlist_head(FR_DLIST_HEAD(_name) const *list) \
{ return UNCONST(fr_dlist_head_t *, &list->head); } \
+\
+ static inline fr_dlist_t *_name ## _dlist_entry(FR_DLIST_ENTRY(_name) const *entry) \
+ { return UNCONST(fr_dlist_t *, &entry->entry ); } \
\
static inline void _name ## _entry_init(_element_type *entry) \
{ \
\
static inline _element_type *_name ## _replace(FR_DLIST_HEAD(_name) *list, _element_type *item, _element_type *ptr) \
{ return fr_dlist_replace(&list->head, item, ptr); } \
+\
+ static inline void _##_name ## _verify(char const *file, int line, FR_DLIST_HEAD(_name) const *list_head) \
+ { _fr_dlist_verify(file, line, UNCONST(fr_dlist_head_t *, &list_head->head)); } \
\
static inline int _name ## _move(FR_DLIST_HEAD(_name) *dst, FR_DLIST_HEAD(_name) *src) \
{ return fr_dlist_move(&dst->head, &src->head); } \
{ fr_dlist_sort(&list->head, cmp); } \
DIAG_ON(unused-function)
+/*
+ * In addition to the above call to FR_DLIST_FUNCS two additional macros should be defined
+ *
+ * Unfortunately as there's no way to dynamically define macro names these need to be done manually.
+ *
+ * #define <name>_foreach(_list_head, _iter) fr_dlist_foreach(<name>_dlist_head(_list_head), <element_type>, _iter)
+ * #define <name>_foreach_safe(_list_head, _iter) fr_dlist_foreach_safe(<name>_dlist_head(_list_head), <element_type>, _iter)
+ * #define <name>_verify(_list_head) _<name>_verify(__FILE__, __LINE__, _list_head)
+ */
+
#ifdef __cplusplus
}
#endif
value = fr_value_box_alloc(dst, vp->data.type, vp->da, vp->data.tainted);
if (!value) {
fail:
- fr_dlist_talloc_free_to_tail(&dst->vb_group, first_added);
+ fr_value_box_list_talloc_free_to_tail(&dst->vb_group, first_added);
return -1;
}
fr_value_box_copy(value, value, &vp->data);
}
if (!first_added) first_added = value;
- fr_dlist_insert_tail(&dst->vb_group, value);
+ fr_value_box_list_insert_tail(&dst->vb_group, value);
}
return cnt;
case 'M':
{
- fr_value_box_list_t const *in = va_arg(ap_q, fr_value_box_list_t const *);
+ FR_DLIST_HEAD(fr_value_box_list) const *in = va_arg(ap_q, FR_DLIST_HEAD(fr_value_box_list) const *);
if (!in) {
subst = talloc_strdup(NULL, "(null)");
* - 0 on success
* - -1 on failure
*/
-int fr_uri_escape(fr_value_box_list_t *uri, fr_uri_part_t const *uri_parts, void *uctx)
+int fr_uri_escape(FR_DLIST_HEAD(fr_value_box_list) *uri, fr_uri_part_t const *uri_parts, void *uctx)
{
- fr_value_box_t *uri_vb = NULL;
fr_uri_part_t const *uri_part;
fr_sbuff_t sbuff;
fr_strerror_clear();
- while ((uri_vb = fr_dlist_next(uri, uri_vb))){
+ fr_value_box_list_foreach_safe(uri, uri_vb) {
if (uri_vb->tainted && !uri_part->tainted_allowed) {
fr_strerror_printf_push("Tainted value not allowed for %s", uri_part->name);
return -1;
* so remove it from the list and re-insert after the escaping
* has been done
*/
- fr_value_box_t *prev = fr_dlist_remove(uri, uri_vb);
+ fr_value_box_t *prev = fr_value_box_list_remove(uri, uri_vb);
if (uri_part->func(uri_vb, uctx) < 0) {
fr_strerror_printf_push("Unable to escape tainted input %pV", uri_vb);
return -1;
}
- fr_dlist_insert_after(uri, prev, uri_vb);
+ fr_value_box_list_insert_after(uri, prev, uri_vb);
}
continue;
}
uri_part += uri_part->part_adv[fr_sbuff_char(&sbuff, '\0')];
if (!uri_part->terminals) break;
} while (fr_sbuff_advance(&sbuff, 1) > 0);
- }
+ }}
return 0;
}
#define XLAT_URI_PART_TERMINATOR { .name = NULL, .terminals = NULL, .tainted_allowed = false, .func = NULL }
-int fr_uri_escape(fr_value_box_list_t *uri, fr_uri_part_t const *uri_parts, void *uctx);
+int fr_uri_escape(FR_DLIST_HEAD(fr_value_box_list) *uri, fr_uri_part_t const *uri_parts, void *uctx);
#ifdef __cplusplus
}
dst->type = src->type;
dst->tainted = src->tainted;
dst->safe = src->safe;
- fr_dlist_entry_init(&dst->entry);
+ fr_value_box_list_entry_init(dst);
}
/** Compare two values
case FR_TYPE_GROUP:
return fr_value_box_list_concat_in_place(ctx,
- dst, UNCONST(fr_value_box_list_t *, &src->vb_group),
+ dst, UNCONST(FR_DLIST_HEAD(fr_value_box_list) *, &src->vb_group),
FR_TYPE_STRING,
FR_VALUE_BOX_LIST_NONE, false,
SIZE_MAX);
case FR_TYPE_GROUP:
return fr_value_box_list_concat_in_place(ctx,
- dst, UNCONST(fr_value_box_list_t *, &src->vb_group),
+ dst, UNCONST(FR_DLIST_HEAD(fr_value_box_list) *, &src->vb_group),
FR_TYPE_OCTETS,
FR_VALUE_BOX_LIST_NONE, false,
SIZE_MAX);
/*
* Store list poiters to restore later - fr_value_box_cast clears them
*/
- fr_dlist_t entry = vb->entry;
+ FR_DLIST_ENTRY(fr_value_box_list) entry = vb->entry;
/*
* Simple case, destination type and current
* box is left in a consistent state.
*/
fr_value_box_copy_shallow(NULL, vb, &tmp);
- vb->entry.next = entry.next;
- vb->entry.prev = entry.prev;
+ vb->entry = entry;
return -1;
}
fr_value_box_clear(&tmp); /* Clear out any old buffers */
/*
* Restore list pointers
*/
- vb->entry.next = entry.next;
- vb->entry.prev = entry.prev;
+ vb->entry = entry;
return 0;
}
{
fr_value_box_t *vb = NULL;
- while ((vb = fr_dlist_next(&data->vb_group, vb))) {
+ while ((vb = fr_value_box_list_next(&data->vb_group, vb))) {
fr_value_box_clear_value(vb);
talloc_free(vb);
}
fr_value_box_copy_meta(dst, src); /* Initialises group child dlist */
- while ((child = fr_dlist_next(&src->vb_group, child))) {
+ while ((child = fr_value_box_list_next(&src->vb_group, child))) {
fr_value_box_t *new;
/*
if (unlikely(!new)) {
group_error:
fr_strerror_const("Failed duplicating group child");
- fr_dlist_talloc_free(&dst->vb_group);
+ fr_value_box_list_talloc_free(&dst->vb_group);
return -1;
}
* child.
*/
if (unlikely(fr_value_box_copy(new, new, child) < 0)) goto group_error;
- fr_dlist_insert_tail(&dst->vb_group, new);
+ fr_value_box_list_insert_tail(&dst->vb_group, new);
}
}
break;
{
fr_value_box_t *child;
- while ((child = fr_dlist_pop_head(&src->vb_group))) {
+ while ((child = fr_value_box_list_pop_head(&src->vb_group))) {
child = talloc_steal(ctx, child);
if (unlikely(!child)) {
fr_strerror_const("Failed stealing child");
return -1;
}
- fr_dlist_insert_tail(&dst->vb_group, child);
+ fr_value_box_list_insert_tail(&dst->vb_group, child);
}
}
return 0;
* Fixup enumvs
*/
dst->enumv = dst_enumv;
- fr_dlist_entry_init(&dst->entry);
+ fr_value_box_list_entry_init(dst);
FR_SBUFF_SET_RETURN(in, &our_in);
}
*/
FR_SBUFF_IN_CHAR_RETURN(&our_out, '{');
FR_SBUFF_RETURN(fr_value_box_list_concat_as_string,
- NULL, &our_out, UNCONST(fr_value_box_list_t *, &data->vb_group),
+ NULL, &our_out, UNCONST(FR_DLIST_HEAD(fr_value_box_list) *, &data->vb_group),
", ", (sizeof(", ") - 1), e_rules,
0, false, true);
FR_SBUFF_IN_CHAR_RETURN(&our_out, '}');
* - <0 how many additional bytes we would have needed to
* concat the next box.
*/
-ssize_t fr_value_box_list_concat_as_string(bool *tainted, fr_sbuff_t *sbuff, fr_value_box_list_t *list,
+ssize_t fr_value_box_list_concat_as_string(bool *tainted, fr_sbuff_t *sbuff, FR_DLIST_HEAD(fr_value_box_list) *list,
char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules,
fr_value_box_list_action_t proc_action, bool flatten, bool printable)
{
fr_sbuff_t our_sbuff = FR_SBUFF(sbuff);
ssize_t slen;
- if (fr_dlist_empty(list)) return 0;
+ if (fr_value_box_list_empty(list)) return 0;
- fr_dlist_foreach(list, fr_value_box_t, vb) {
+ fr_value_box_list_foreach(list, vb) {
switch (vb->type) {
case FR_TYPE_GROUP:
if (!flatten) goto print;
return slen;
}
- if (sep && fr_dlist_next(list, vb)) {
+ if (sep && fr_value_box_list_next(list, vb)) {
slen = fr_sbuff_in_bstrncpy(&our_sbuff, sep, sep_len);
if (slen < 0) goto error;
}
* an issue concating them, everything
* is still in a known state.
*/
- fr_dlist_foreach_safe(list, fr_value_box_t, vb) {
+ fr_value_box_list_foreach_safe(list, vb) {
if (tainted && vb->tainted) *tainted = true;
- if (vb_should_remove(proc_action)) fr_dlist_remove(list, vb);
+ if (vb_should_remove(proc_action)) fr_value_box_list_remove(list, vb);
if (vb_should_free_value(proc_action)) fr_value_box_clear(vb);
if (vb_should_free(proc_action)) talloc_free(vb);
}}
* - <0 how many additional bytes we would have needed to
* concat the next box.
*/
-ssize_t fr_value_box_list_concat_as_octets(bool *tainted, fr_dbuff_t *dbuff, fr_value_box_list_t *list,
+ssize_t fr_value_box_list_concat_as_octets(bool *tainted, fr_dbuff_t *dbuff, FR_DLIST_HEAD(fr_value_box_list) *list,
uint8_t const *sep, size_t sep_len,
fr_value_box_list_action_t proc_action, bool flatten)
{
TALLOC_CTX *tmp_ctx = NULL;
ssize_t slen;
- if (fr_dlist_empty(list)) return 0;
+ if (fr_value_box_list_empty(list)) return 0;
- fr_dlist_foreach(list, fr_value_box_t, vb) {
+ fr_value_box_list_foreach(list, vb) {
switch (vb->type) {
case FR_TYPE_GROUP:
if (!flatten) goto cast;
return slen;
}
- if (sep && fr_dlist_next(list, vb)) {
+ if (sep && fr_value_box_list_next(list, vb)) {
slen = fr_dbuff_in_memcpy(&our_dbuff, sep, sep_len);
if (slen < 0) goto error;
}
* an issue concating them, everything
* is still in a known state.
*/
- fr_dlist_foreach_safe(list, fr_value_box_t, vb) {
+ fr_value_box_list_foreach_safe(list, vb) {
if (tainted && vb->tainted) *tainted = true;
- if (vb_should_remove(proc_action)) fr_dlist_remove(list, vb);
+ if (vb_should_remove(proc_action)) fr_value_box_list_remove(list, vb);
if (vb_should_free_value(proc_action)) fr_value_box_clear(vb);
if (vb_should_free(proc_action)) talloc_free(vb);
}}
* - -1 on failure.
*/
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx,
- fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type,
+ fr_value_box_t *out, FR_DLIST_HEAD(fr_value_box_list) *list, fr_type_t type,
fr_value_box_list_action_t proc_action, bool flatten,
size_t max_size)
{
- fr_dbuff_t dbuff; /* FR_TYPE_OCTETS */
- fr_dbuff_uctx_talloc_t dbuff_tctx;
+ fr_dbuff_t dbuff; /* FR_TYPE_OCTETS */
+ fr_dbuff_uctx_talloc_t dbuff_tctx;
- fr_sbuff_t sbuff; /* FR_TYPE_STRING */
- fr_sbuff_uctx_talloc_t sbuff_tctx;
+ fr_sbuff_t sbuff; /* FR_TYPE_STRING */
+ fr_sbuff_uctx_talloc_t sbuff_tctx;
- fr_value_box_t *head_vb = fr_dlist_head(list);
- bool tainted = false;
+ fr_value_box_t *head_vb = fr_value_box_list_head(list);
+ bool tainted = false;
- fr_dlist_t entry;
+ FR_DLIST_ENTRY(fr_value_box_list) entry;
- if (fr_dlist_empty(list)) {
+ if (fr_value_box_list_empty(list)) {
fr_strerror_const("Invalid arguments. List contains no elements");
return -1;
}
if (fr_value_box_list_concat_as_string(&tainted, &sbuff, list,
NULL, 0, NULL,
proc_action, flatten, true) < 0) {
- fr_dlist_insert_head(list, head_vb);
+ fr_value_box_list_insert_head(list, head_vb);
goto error;
}
(void)fr_sbuff_trim_talloc(&sbuff, SIZE_MAX);
if (fr_value_box_list_concat_as_octets(&tainted, &dbuff, list,
NULL, 0,
proc_action, flatten) < 0) {
- fr_dlist_insert_head(list, head_vb);
+ fr_value_box_list_insert_head(list, head_vb);
goto error;
}
(void)fr_dbuff_trim_talloc(&dbuff, SIZE_MAX);
default:
break;
}
- fr_dlist_insert_head(list, out);
+ fr_value_box_list_insert_head(list, out);
/*
* Merge all the boxes in the list into
* a single contiguous buffer.
* - NULL on error.
* - The concatenation of the string values of the value box list on success.
*/
-char *fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim,
+char *fr_value_box_list_aprint(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) const *list, char const *delim,
fr_sbuff_escape_rules_t const *e_rules)
{
- fr_value_box_t const *vb = fr_dlist_head(list);
+ fr_value_box_t const *vb = fr_value_box_list_head(list);
char *aggr, *td = NULL;
TALLOC_CTX *pool = NULL;
fr_value_box_aprint(ctx, &aggr, vb, e_rules);
if (!aggr) return NULL;
- if (!fr_dlist_next(list, vb)) return aggr;
+ if (!fr_value_box_list_next(list, vb)) return aggr;
/*
* If we're aggregating more values,
pool = talloc_pool(NULL, 255);
if (delim) td = talloc_typed_strdup(pool, delim);
- while ((vb = fr_dlist_next(list, vb))) {
+ while ((vb = fr_value_box_list_next(list, vb))) {
char *str, *new_aggr;
fr_value_box_aprint(pool, &str, vb, e_rules);
* - A duplicate list of value boxes, allocated in the context of 'ctx'
* - NULL on error, or empty input list.
*/
-int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
+int fr_value_box_list_acopy(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, FR_DLIST_HEAD(fr_value_box_list) const *in)
{
fr_value_box_t const *in_p = NULL;
- while ((in_p = fr_dlist_next(in, in_p))) {
+ while ((in_p = fr_value_box_list_next(in, in_p))) {
fr_value_box_t *n = NULL;
n = fr_value_box_alloc_null(ctx);
if (!n) {
error:
- fr_dlist_talloc_free(out);
+ fr_value_box_list_talloc_free(out);
return -1;
}
if (fr_value_box_copy(n, n, in_p) < 0) goto error;
- fr_dlist_insert_tail(out, n);
+ fr_dlist_insert_tail(fr_value_box_list_dlist_head(out), n);
}
return 0;
* - true if a list member is tainted.
* - false if no list members are tainted.
*/
-bool fr_value_box_list_tainted(fr_value_box_list_t const *head)
+bool fr_value_box_list_tainted(FR_DLIST_HEAD(fr_value_box_list) const *head)
{
fr_value_box_t *vb = NULL;
- while ((vb = fr_dlist_next(head, vb))) {
+ while ((vb = fr_value_box_list_next(head, vb))) {
if (fr_type_is_group(vb->type) && fr_value_box_list_tainted(&vb->vb_group)) return true;
if (vb->tainted) return true;
}
*
* @param[in] head of list.
*/
-void fr_value_box_list_taint(fr_value_box_list_t *head)
+void fr_value_box_list_taint(FR_DLIST_HEAD(fr_value_box_list) *head)
{
fr_value_box_t *vb = NULL;
- while ((vb = fr_dlist_next(head, vb))) {
+ while ((vb = fr_value_box_list_next(head, vb))) {
if (fr_type_is_group(vb->type)) fr_value_box_list_taint(&vb->vb_group);
vb->tainted = true;
}
*
* @param[in] head of list.
*/
-void fr_value_box_list_untaint(fr_value_box_list_t *head)
+void fr_value_box_list_untaint(FR_DLIST_HEAD(fr_value_box_list) *head)
{
fr_value_box_t *vb = NULL;
- while ((vb = fr_dlist_next(head, vb))) {
+ while ((vb = fr_value_box_list_next(head, vb))) {
if (fr_type_is_group(vb->type)) fr_value_box_list_untaint(&vb->vb_group);
vb->tainted = false;
}
}
}
-void value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list, bool talloced)
+void value_box_list_verify(char const *file, int line, FR_DLIST_HEAD(fr_value_box_list) const *list, bool talloced)
{
fr_value_box_t const *vb = NULL;
- while ((vb = fr_dlist_next(list, vb))) value_box_verify(file, line, vb, talloced);
+ while ((vb = fr_value_box_list_next(list, vb))) value_box_verify(file, line, vb, talloced);
}
return false;
case FR_TYPE_STRUCTURAL:
- if (in->type == FR_TYPE_GROUP) return (fr_value_box_list_len(&in->vb_group) > 0);
+ if (in->type == FR_TYPE_GROUP) return (fr_value_box_list_num_elements(&in->vb_group) > 0);
return false;
case FR_TYPE_BOOL:
extern fr_sbuff_escape_rules_t fr_value_escape_unprintables;
-/** Lists of value boxes
- *
- * Specifically define a type for lists of value_box_t to aid type checking
- */
-typedef fr_dlist_head_t fr_value_box_list_t;
+FR_DLIST_TYPES(fr_value_box_list)
/** Union containing all data types supported by the server
*
* fr_type_t should be an enumeration of the values in this union.
*/
struct value_box_s {
- fr_type_t _CONST type; //!< Type of this value-box, at the start, see pair.h
+ fr_type_t _CONST type; //!< Type of this value-box, at the start, see pair.h
union {
/*
* Variable length values
*/
- char const * _CONST strvalue; //!< Pointer to UTF-8 string.
- uint8_t const * _CONST octets; //!< Pointer to binary string.
- void * _CONST ptr; //!< generic pointer.
+ char const * _CONST strvalue; //!< Pointer to UTF-8 string.
+ uint8_t const * _CONST octets; //!< Pointer to binary string.
+ void * _CONST ptr; //!< generic pointer.
/*
* Fixed length values
*/
- fr_ipaddr_t ip; //!< IPv4/6 address/prefix.
+ fr_ipaddr_t ip; //!< IPv4/6 address/prefix.
- fr_ifid_t ifid; //!< IPv6 interface ID.
- fr_ethernet_t ether; //!< Ethernet (MAC) address.
+ fr_ifid_t ifid; //!< IPv6 interface ID.
+ fr_ethernet_t ether; //!< Ethernet (MAC) address.
- bool boolean; //!< A truth value.
+ bool boolean; //!< A truth value.
- uint8_t uint8; //!< 8bit unsigned integer.
- uint16_t uint16; //!< 16bit unsigned integer.
- uint32_t uint32; //!< 32bit unsigned integer.
- uint64_t uint64; //!< 64bit unsigned integer.
- uint128_t uint128; //!< 128bit unsigned integer.
+ uint8_t uint8; //!< 8bit unsigned integer.
+ uint16_t uint16; //!< 16bit unsigned integer.
+ uint32_t uint32; //!< 32bit unsigned integer.
+ uint64_t uint64; //!< 64bit unsigned integer.
+ uint128_t uint128; //!< 128bit unsigned integer.
- int8_t int8; //!< 8bit signed integer.
- int16_t int16; //!< 16bit signed integer.
- int32_t int32; //!< 32bit signed integer.
- int64_t int64; //!< 64bit signed integer;
+ int8_t int8; //!< 8bit signed integer.
+ int16_t int16; //!< 16bit signed integer.
+ int32_t int32; //!< 32bit signed integer.
+ int64_t int64; //!< 64bit signed integer;
- float float32; //!< Single precision float.
- double float64; //!< Double precision float.
+ float float32; //!< Single precision float.
+ double float64; //!< Double precision float.
- fr_unix_time_t date; //!< Date internal format in nanoseconds
+ fr_unix_time_t date; //!< Date internal format in nanoseconds
/*
* System specific - Used for runtime configuration only.
*/
- size_t size; //!< System specific file/memory size.
- fr_time_delta_t time_delta; //!< a delta time in nanoseconds
+ size_t size; //!< System specific file/memory size.
+ fr_time_delta_t time_delta; //!< a delta time in nanoseconds
- fr_value_box_list_t children; //!< for groups
+ FR_DLIST_HEAD(fr_value_box_list) children; //!< for groups
} datum;
- size_t length;
+ size_t length;
- bool tainted; //!< i.e. did it come from an untrusted source
- uint16_t _CONST safe; //!< more detailed safety
+ bool tainted; //!< i.e. did it come from an untrusted source
+ uint16_t _CONST safe; //!< more detailed safety
- fr_dict_attr_t const *enumv; //!< Enumeration values.
+ fr_dict_attr_t const *enumv; //!< Enumeration values.
- fr_dlist_t entry; //!< Doubly linked list entry.
+ FR_DLIST_ENTRY(fr_value_box_list) entry; //!< Doubly linked list entry.
};
+FR_DLIST_FUNCS(fr_value_box_list, fr_value_box_t, entry)
+
+#define fr_value_box_list_foreach(_list_head, _iter) fr_dlist_foreach(fr_value_box_list_dlist_head(_list_head), fr_value_box_t, _iter)
+#define fr_value_box_list_foreach_safe(_list_head, _iter) fr_dlist_foreach_safe(fr_value_box_list_dlist_head(_list_head), fr_value_box_t, _iter)
+#define fr_value_box_list_verify(_list_head) _fr_value_box_list_verify(__FILE__, __LINE__, _list_head)
+
/** Actions to perform when we process a box in a list
*
*/
*/
#define fr_value_box_foreach(_v, _iv) for (fr_value_box_t *_iv = fr_dlist_head(_v); _iv; _iv = fr_dlist_next(_v, _iv))
-/** Returns the number of boxes in a list of value boxes
- *
- * @param[in] list of value boxes.
- * @return Number of boxes in the list.
- */
-static inline CC_HINT(nonnull)
-size_t fr_value_box_list_len(fr_value_box_list_t const *list)
-{
- return fr_dlist_num_elements(list);
-}
-
/** Determines whether a list contains the number of boxes required
*
* @param[in] list of value boxes.
* - false if the list has fewer than min boxes.
*/
static inline CC_HINT(nonnull)
-bool fr_value_box_list_len_min(fr_value_box_list_t const *list, unsigned int min)
+bool fr_value_box_list_len_min(FR_DLIST_HEAD(fr_value_box_list) const *list, unsigned int min)
{
- unsigned int i = fr_dlist_num_elements(list);
+ unsigned int i = fr_value_box_list_num_elements(list);
return (i >= min);
}
-/** Initialise a list of fr_value_box_t
- *
- * @param[in,out] list to initialise
- */
-static inline CC_HINT(nonnull)
-void fr_value_box_list_init(fr_value_box_list_t *list)
-{
- fr_dlist_init(list, fr_value_box_t, entry); /* Not always talloced */
-}
-/** @} */
-
/** @name Box to box copying
*
* @{
.enumv = enumv,
.tainted = tainted
});
- fr_dlist_entry_init(&vb->entry);
+ fr_value_box_list_entry_init(vb);
/*
* The majority of types are fine to initialise to
*
* @{
*/
-ssize_t fr_value_box_list_concat_as_string(bool *tainted, fr_sbuff_t *sbuff, fr_value_box_list_t *list,
- char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules,
- fr_value_box_list_action_t proc_action, bool flatten, bool printable)
+ssize_t fr_value_box_list_concat_as_string(bool *tainted, fr_sbuff_t *sbuff, FR_DLIST_HEAD(fr_value_box_list) *list,
+ char const *sep, size_t sep_len, fr_sbuff_escape_rules_t const *e_rules,
+ fr_value_box_list_action_t proc_action, bool flatten, bool printable)
CC_HINT(nonnull(2,3));
-ssize_t fr_value_box_list_concat_as_octets(bool *tainted, fr_dbuff_t *dbuff, fr_value_box_list_t *list,
+ssize_t fr_value_box_list_concat_as_octets(bool *tainted, fr_dbuff_t *dbuff, FR_DLIST_HEAD(fr_value_box_list) *list,
uint8_t const *sep, size_t sep_len,
fr_value_box_list_action_t proc_action, bool flatten)
CC_HINT(nonnull(2,3));
int fr_value_box_list_concat_in_place(TALLOC_CTX *ctx,
- fr_value_box_t *out, fr_value_box_list_t *list, fr_type_t type,
+ fr_value_box_t *out, FR_DLIST_HEAD(fr_value_box_list) *list, fr_type_t type,
fr_value_box_list_action_t proc_action, bool flatten,
size_t max_size)
CC_HINT(nonnull(2,3));
-char *fr_value_box_list_aprint(TALLOC_CTX *ctx, fr_value_box_list_t const *list, char const *delim,
+char *fr_value_box_list_aprint(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) const *list, char const *delim,
fr_sbuff_escape_rules_t const *e_rules)
CC_HINT(nonnull(2));
-int fr_value_box_list_acopy(TALLOC_CTX *ctx, fr_value_box_list_t *out, fr_value_box_list_t const *in)
+int fr_value_box_list_acopy(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *out, FR_DLIST_HEAD(fr_value_box_list) const *in)
CC_HINT(nonnull(2,3));
-bool fr_value_box_list_tainted(fr_value_box_list_t const *head)
+bool fr_value_box_list_tainted(FR_DLIST_HEAD(fr_value_box_list) const *head)
CC_HINT(nonnull(1));
-void fr_value_box_list_taint(fr_value_box_list_t *head)
+void fr_value_box_list_taint(FR_DLIST_HEAD(fr_value_box_list) *head)
CC_HINT(nonnull(1));
-void fr_value_box_list_untaint(fr_value_box_list_t *head)
+void fr_value_box_list_untaint(FR_DLIST_HEAD(fr_value_box_list) *head)
CC_HINT(nonnull(1));
/** @} */
void value_box_verify(char const *file, int line, fr_value_box_t const *vb, bool talloced)
CC_HINT(nonnull(3));
-void value_box_list_verify(char const *file, int line, fr_value_box_list_t const *list, bool talloced)
+void value_box_list_verify(char const *file, int line, FR_DLIST_HEAD(fr_value_box_list) const *list, bool talloced)
CC_HINT(nonnull(3));
#ifdef WITH_VERIFY_PTR
*/
static xlat_action_t always_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_always_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_always_t);
module_instance_t *mi = inst->mi;
char const *status;
char const *p;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/*
* Expand to the existing status
static CC_HINT(nonnull)
xlat_action_t cache_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cache_entry_t *c = NULL;
rlm_cache_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_cache_t);
ssize_t slen;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
uint8_t buffer[1024];
uint8_t const *key;
ssize_t key_len;
*/
static xlat_action_t xlat_func_chap_password(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
uint8_t chap_password[1 + RADIUS_CHAP_CHALLENGE_LENGTH];
fr_value_box_t *vb;
fr_pair_t *challenge;
uint8_t const *vector;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/*
* Use Chap-Challenge pair if present,
*/
static xlat_action_t cipher_rsa_encrypt_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
size_t ciphertext_len;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
plaintext = in_head->vb_strvalue;
plaintext_len = in_head->vb_length;
*/
static xlat_action_t cipher_rsa_sign_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
unsigned int digest_len = 0;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
msg = in_head->vb_strvalue;
msg_len = in_head->vb_length;
*/
static xlat_action_t cipher_rsa_decrypt_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
size_t plaintext_len;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
ciphertext = in_head->vb_octets;
ciphertext_len = in_head->vb_length;
*/
static xlat_action_t cipher_rsa_verify_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
unsigned int digest_len = 0;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_pop_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_pop_head(in);
fr_value_box_t *args;
/*
/*
* Concat (...) args to get message data
*/
- args = fr_dlist_head(in);
+ args = fr_value_box_list_head(in);
if (fr_value_box_list_concat_in_place(ctx,
args, in, FR_TYPE_STRING,
FR_VALUE_BOX_LIST_FREE, true,
*/
static xlat_action_t cipher_fingerprint_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
char const *md_name;
fr_value_box_t *vb;
uint8_t *digest;
- if (!fr_dlist_next(in, fr_dlist_head(in))) {
+ if (!fr_value_box_list_next(in, fr_value_box_list_head(in))) {
REDEBUG("Missing digest argument");
return XLAT_ACTION_FAIL;
}
/*
* Second arg...
*/
- md_name = ((fr_value_box_t *)fr_dlist_next(in, fr_dlist_head(in)))->vb_strvalue;
+ md_name = ((fr_value_box_t *)fr_value_box_list_next(in, fr_value_box_list_head(in)))->vb_strvalue;
md = EVP_get_digestbyname(md_name);
if (!md) {
REDEBUG("Specified digest \"%s\" is not a valid digest type", md_name);
*/
static xlat_action_t cipher_serial_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
ASN1_INTEGER const *serial;
static xlat_action_t cipher_certificate_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
- char const *attribute = ((fr_value_box_t *)fr_dlist_head(in))->vb_strvalue;
+ char const *attribute = fr_value_box_list_head(in)->vb_strvalue;
fr_value_box_t *vb;
switch (fr_table_value_by_str(cert_attributes, attribute, CIPHER_CERT_ATTR_UNKNOWN)) {
* - #RLM_MODULE_FAIL if an error occurred.
*/
static rlm_rcode_t map_proc_client(UNUSED void *mod_inst, UNUSED void *proc_inst, request_t *request,
- fr_value_box_list_t *client_override, map_list_t const *maps)
+ FR_DLIST_HEAD(fr_value_box_list) *client_override, map_list_t const *maps)
{
rlm_rcode_t rcode = RLM_MODULE_OK;
map_t const *map = NULL;
RADCLIENT *client;
client_get_vp_ctx_t uctx;
- if (!fr_dlist_empty(client_override)) {
+ if (!fr_value_box_list_empty(client_override)) {
fr_ipaddr_t ip;
char const *client_str;
- fr_value_box_t *client_override_head = fr_dlist_head(client_override);
+ fr_value_box_t *client_override_head = fr_value_box_list_head(client_override);
/*
* Concat don't asprint, as this becomes a noop
*/
static xlat_action_t xlat_client(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
char const *value = NULL;
fr_ipaddr_t ip;
CONF_PAIR *cp;
RADCLIENT *client = NULL;
- fr_value_box_t *field = fr_dlist_head(in);
- fr_value_box_t *client_ip = fr_dlist_next(in, field);
+ fr_value_box_t *field = fr_value_box_list_head(in);
+ fr_value_box_t *client_ip = fr_value_box_list_next(in, field);
fr_value_box_t *vb;
if (client_ip) {
#include <freeradius-devel/server/map_proc.h>
static rlm_rcode_t mod_map_proc(void *mod_inst, UNUSED void *proc_inst, request_t *request,
- fr_value_box_list_t *key, map_list_t const *maps);
+ FR_DLIST_HEAD(fr_value_box_list) *key, map_list_t const *maps);
/*
* Define a structure for our module configuration.
* - #RLM_MODULE_FAIL if an error occurred.
*/
static rlm_rcode_t mod_map_proc(void *mod_inst, UNUSED void *proc_inst, request_t *request,
- fr_value_box_list_t *key, map_list_t const *maps)
+ FR_DLIST_HEAD(fr_value_box_list) *key, map_list_t const *maps)
{
rlm_csv_t *inst = talloc_get_type_abort(mod_inst, rlm_csv_t);
- fr_value_box_t *key_head = fr_dlist_head(key);
+ fr_value_box_t *key_head = fr_value_box_list_head(key);
if (!key_head) {
REDEBUG("CSV key cannot be (null)");
*/
static xlat_action_t xlat_date_convert(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_date_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_date_t);
struct tm tminfo;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
memset(&tminfo, 0, sizeof(tminfo));
static xlat_action_t xlat_delay_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_time_t *yielded_at = talloc_get_type_abort(xctx->rctx, fr_time_t);
fr_time_delta_t delayed;
*/
static xlat_action_t xlat_delay(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_delay_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_delay_t);
fr_time_t resume_at, *yielded_at;
- fr_value_box_t *delay = fr_dlist_head(in);
+ fr_value_box_t *delay = fr_value_box_list_head(in);
/*
* Record the time that we yielded the request
*/
static xlat_action_t xlat_dict_attr_by_num(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_dict_attr_t const *da;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
fr_value_box_t *vb;
da = fr_dict_attr_child_by_num(fr_dict_root(request->dict), attr->vb_uint32);
*/
static xlat_action_t xlat_dict_attr_by_oid(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
unsigned int attr = 0;
fr_dict_attr_t const *parent = fr_dict_root(request->dict);
fr_dict_attr_t const *da;
ssize_t ret;
- fr_value_box_t *attr_vb = fr_dlist_head(in);
+ fr_value_box_t *attr_vb = fr_value_box_list_head(in);
fr_value_box_t *vb;
ret = fr_dict_attr_by_oid_legacy(fr_dict_internal(), &parent, &attr, attr_vb->vb_strvalue);
*/
static xlat_action_t xlat_vendor(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
fr_dict_vendor_t const *vendor;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
fr_value_box_t *vb;
if ((xlat_fmt_get_vp(&vp, request, attr->vb_strvalue) < 0) || !vp) return XLAT_ACTION_FAIL;
*/
static xlat_action_t xlat_vendor_num(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
fr_value_box_t *vb;
if ((xlat_fmt_get_vp(&vp, request, attr->vb_strvalue) < 0) || !vp) return XLAT_ACTION_FAIL;
*/
static xlat_action_t xlat_attr(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
fr_value_box_t *vb;
if ((xlat_fmt_get_vp(&vp, request, attr->vb_strvalue) < 0) || !vp) return XLAT_ACTION_FAIL;
*/
static xlat_action_t xlat_attr_num(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_pair_t *vp;
- fr_value_box_t *attr = fr_dlist_head(in);
+ fr_value_box_t *attr = fr_value_box_list_head(in);
fr_value_box_t *vb;
if ((xlat_fmt_get_vp(&vp, request, attr->vb_strvalue) < 0) || !vp) return XLAT_ACTION_FAIL;
*/
static xlat_action_t escape_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_escape_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_escape_t);
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p = arg->vb_strvalue;
size_t len;
fr_value_box_t *vb;
*/
static xlat_action_t unescape_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p, *end;
char *out_p;
char *c1, *c2, c3;
static xlat_action_t exec_xlat_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_exec_state_t *exec = talloc_get_type_abort(xctx->rctx, fr_exec_state_t);
fr_value_box_t *vb;
*/
static xlat_action_t exec_xlat(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_exec_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_exec_t);
fr_pair_list_t *env_pairs = NULL;
request_t *request)
{
rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_exec_t);
- fr_value_box_list_t *box = talloc_get_type_abort(mctx->rctx, fr_value_box_list_t);
+ FR_DLIST_HEAD(fr_value_box_list) *box = talloc_get_type_abort(mctx->rctx, FR_DLIST_HEAD(fr_value_box_list));
fr_pair_list_t *env_pairs = NULL;
/*
}
typedef struct {
- fr_value_box_list_t box;
+ FR_DLIST_HEAD(fr_value_box_list) box;
int status;
} rlm_exec_ctx_t;
/*
* Also prints stdout as an error if there was any...
*/
- rcode = rlm_exec_status2rcode(request, fr_dlist_head(&m->box), m->status);
+ rcode = rlm_exec_status2rcode(request, fr_value_box_list_head(&m->box), m->status);
switch (rcode) {
case RLM_MODULE_OK:
case RLM_MODULE_UPDATED:
- if (inst->output && !fr_dlist_empty(&m->box)) {
+ if (inst->output && !fr_value_box_list_empty(&m->box)) {
TALLOC_CTX *ctx;
fr_pair_list_t vps, *output_pairs;
- fr_value_box_t *box = fr_dlist_head(&m->box);
+ fr_value_box_t *box = fr_value_box_list_head(&m->box);
fr_pair_list_init(&vps);
output_pairs = tmpl_list_head(request, inst->output_list);
fr_pair_list_afrom_box(ctx, &vps, request->dict, box);
if (!fr_pair_list_empty(&vps)) fr_pair_list_move_op(output_pairs, &vps, T_OP_ADD_EQ);
- fr_dlist_talloc_free(&m->box); /* has been consumed */
+ fr_value_box_list_talloc_free(&m->box); /* has been consumed */
}
break;
* Do the asynchronous xlat expansion.
*/
if (!inst->wait) {
- fr_value_box_list_t *box = talloc_zero(ctx, fr_value_box_list_t);
+ FR_DLIST_HEAD(fr_value_box_list) *box = talloc_zero(ctx, FR_DLIST_HEAD(fr_value_box_list));
fr_value_box_list_init(box);
return unlang_module_yield_to_xlat(request, NULL, box, request, tmpl_xlat(inst->tmpl),
static xlat_action_t xlat_icmp_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- UNUSED request_t *request, UNUSED fr_value_box_list_t *in)
+ UNUSED request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_icmp_echo_t *echo = talloc_get_type_abort(xctx->rctx, rlm_icmp_echo_t);
rlm_icmp_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_icmp_thread_t);
*/
static xlat_action_t xlat_icmp(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_icmp_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_icmp_t);
rlm_icmp_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_icmp_thread_t);
ssize_t rcode;
socklen_t salen;
struct sockaddr_storage dst;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
/*
* If there's no input, do we can't ping anything.
*/
static xlat_action_t xlat_idna(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_idn_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_idn_t);
char *idna = NULL;
int res;
size_t len;
int flags = 0;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
fr_value_box_t *vb;
if (inst->use_std3_ascii_rules) {
*/
static xlat_action_t json_quote_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
char *tmp;
if (!in_head) return XLAT_ACTION_DONE; /* Empty input is allowed */
*/
static xlat_action_t jpath_validate_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *path = fr_dlist_head(in);
+ fr_value_box_t *path = fr_value_box_list_head(in);
fr_jpath_node_t *head;
ssize_t slen;
char *jpath_str;
*/
static xlat_action_t json_encode_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_json_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_json_t);
fr_json_format_t const *format = inst->format;
char *json_str = NULL;
fr_value_box_t *vb;
fr_sbuff_t sbuff;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_pair_list_init(&json_vps);
fr_pair_list_init(&vps);
fr_pair_t *vp;
rlm_json_jpath_to_eval_t *to_eval = uctx;
fr_value_box_t *value;
- fr_value_box_list_t head;
+ FR_DLIST_HEAD(fr_value_box_list) head;
int ret;
fr_pair_list_free(out);
return -1;
}
if (ret == 0) return 0;
- fr_assert(!fr_dlist_empty(&head));
+ fr_assert(!fr_value_box_list_empty(&head));
- for (value = fr_dlist_head(&head);
+ for (value = fr_value_box_list_head(&head);
value;
- fr_pair_append(out, vp), value = fr_dlist_next(&head, value)) {
+ fr_pair_append(out, vp), value = fr_value_box_list_next(&head, value)) {
MEM(vp = fr_pair_afrom_da(ctx, tmpl_da(map->lhs)));
if (fr_value_box_steal(vp, &vp->data, value) < 0) {
* - #RLM_MODULE_FAIL if a fault occurred.
*/
static rlm_rcode_t mod_map_proc(UNUSED void *mod_inst, void *proc_inst, request_t *request,
- fr_value_box_list_t *json, map_list_t const *maps)
+ FR_DLIST_HEAD(fr_value_box_list) *json, map_list_t const *maps)
{
rlm_rcode_t rcode = RLM_MODULE_UPDATED;
struct json_tokener *tok;
rlm_json_jpath_to_eval_t to_eval;
char const *json_str = NULL;
- fr_value_box_t *json_head = fr_dlist_head(json);
+ fr_value_box_t *json_head = fr_value_box_list_head(json);
if (!json_head) {
REDEBUG("JSON map input cannot be (null)");
*/
static xlat_action_t ldap_escape_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *vb, *in_vb = fr_dlist_head(in);
+ fr_value_box_t *vb, *in_vb = fr_value_box_list_head(in);
fr_sbuff_t sbuff;
fr_sbuff_uctx_talloc_t sbuff_ctx;
size_t len;
*/
static xlat_action_t ldap_unescape_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *vb, *in_vb = fr_dlist_head(in);
+ fr_value_box_t *vb, *in_vb = fr_value_box_list_head(in);
fr_sbuff_t sbuff;
fr_sbuff_uctx_talloc_t sbuff_ctx;
size_t len;
*/
static xlat_action_t ldap_xlat_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_ldap_query_t *query = talloc_get_type_abort(xctx->rctx, fr_ldap_query_t);
fr_ldap_connection_t *ldap_conn = query->ldap_conn;
*/
static xlat_action_t ldap_xlat(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_ldap_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, fr_ldap_thread_t);
fr_value_box_t *in_vb = NULL;
if (fr_uri_escape(in, ldap_uri_parts, NULL) < 0) return XLAT_ACTION_FAIL;
- in_vb = fr_dlist_head(in);
+ in_vb = fr_value_box_list_head(in);
if (fr_value_box_list_concat_in_place(in_vb, in_vb, in, FR_TYPE_STRING, FR_VALUE_BOX_LIST_FREE,
true, SIZE_MAX) < 0) {
REDEBUG("Failed concattenating input");
* - #RLM_MODULE_FAIL if an error occurred.
*/
static rlm_rcode_t mod_map_proc(void *mod_inst, UNUSED void *proc_inst, request_t *request,
- fr_value_box_list_t *url, map_list_t const *maps)
+ FR_DLIST_HEAD(fr_value_box_list) *url, map_list_t const *maps)
{
rlm_rcode_t rcode = RLM_MODULE_UPDATED;
rlm_ldap_t *inst = talloc_get_type_abort(mod_inst, rlm_ldap_t);
fr_ldap_thread_trunk_t *ttrunk;
fr_ldap_map_exp_t expanded; /* faster than allocing every time */
- fr_value_box_t *url_head = fr_dlist_head(url);
+ fr_value_box_t *url_head = fr_value_box_list_head(url);
/*
* FIXME - Maybe it can be NULL?
*/
static xlat_action_t mschap_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
size_t data_len;
uint8_t const *data = NULL;
fr_pair_t *user_name;
fr_pair_t *chap_challenge, *response;
rlm_mschap_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_mschap_t);
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
fr_value_box_t *vb;
bool tainted = false;
* Return the NT-Hash of the passed string
*/
} else if (strncasecmp(arg->vb_strvalue, "NT-Hash", 7) == 0) {
- arg = fr_dlist_next(in, arg);
+ arg = fr_value_box_list_next(in, arg);
if ((!arg) || (arg->length == 0))
return XLAT_ACTION_FAIL;
* Return the LM-Hash of the passed string
*/
} else if (strncasecmp(arg->vb_strvalue, "LM-Hash", 7) == 0) {
- arg = fr_dlist_next(in, arg);
+ arg = fr_value_box_list_next(in, arg);
if ((!arg) || (arg->length == 0))
return XLAT_ACTION_FAIL;
* - 0 on success
* - -1 on failure
*/
-static int perl_vblist_to_av(AV *av, fr_value_box_list_t *head) {
+static int perl_vblist_to_av(AV *av, FR_DLIST_HEAD(fr_value_box_list) *head) {
fr_value_box_t *vb = NULL;
SV *sv;
- while ((vb = fr_dlist_next(head, vb))) {
+ while ((vb = fr_value_box_list_next(head, vb))) {
switch (vb->type) {
case FR_TYPE_STRING:
sv = newSVpvn(vb->vb_strvalue, vb->length);
* - 0 on success
* - -1 on failure
*/
-static int perl_sv_to_vblist(TALLOC_CTX *ctx, fr_value_box_list_t *list, request_t *request, SV *sv) {
+static int perl_sv_to_vblist(TALLOC_CTX *ctx, FR_DLIST_HEAD(fr_value_box_list) *list, request_t *request, SV *sv) {
fr_value_box_t *vb = NULL;
char *tmp;
STRLEN len;
RPEDEBUG("Failed to allocate %d for output", sv_len);
return -1;
}
- fr_dlist_insert_tail(list, vb);
+ fr_value_box_list_insert_tail(list, vb);
/*
* Now process value
}
- if (vb) fr_dlist_insert_tail(list, vb);
+ if (vb) fr_value_box_list_insert_tail(list, vb);
return 0;
}
*/
static xlat_action_t perl_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_perl_thread_t const *t = talloc_get_type_abort_const(xctx->mctx->thread, rlm_perl_thread_t);
int count, i;
xlat_action_t ret = XLAT_ACTION_FAIL;
STRLEN n_a;
- fr_value_box_t *func = fr_dlist_pop_head(in);
+ fr_value_box_t *func = fr_value_box_list_pop_head(in);
fr_value_box_t *arg = NULL, *child;
SV *sv;
AV *av;
- fr_value_box_list_t list, sub_list;
+ FR_DLIST_HEAD(fr_value_box_list) list, sub_list;
fr_value_box_t *vb = NULL;
fr_value_box_list_init(&list);
PUSHMARK(SP);
- while ((arg = fr_dlist_next(in, arg))) {
+ while ((arg = fr_value_box_list_next(in, arg))) {
fr_assert(arg->type == FR_TYPE_GROUP);
- if (fr_dlist_empty(&arg->vb_group)) continue;
+ if (fr_value_box_list_empty(&arg->vb_group)) continue;
- if (fr_dlist_num_elements(&arg->vb_group) == 1) {
- child = fr_dlist_head(&arg->vb_group);
+ if (fr_value_box_list_num_elements(&arg->vb_group) == 1) {
+ child = fr_value_box_list_head(&arg->vb_group);
/*
* Single child value - add as scalar
*/
for (i = 0; i < count; i++) {
sv = POPs;
if (perl_sv_to_vblist(ctx, &sub_list, request, sv) < 0) goto cleanup;
- fr_dlist_move_head(&list, &sub_list);
+ fr_value_box_list_move_head(&list, &sub_list);
}
ret = XLAT_ACTION_DONE;
/*
* Move the assembled list of boxes to the output
*/
- while ((vb = fr_dlist_pop_head(&list))) fr_dcursor_append(out, vb);
+ while ((vb = fr_value_box_list_pop_head(&list))) fr_dcursor_append(out, vb);
cleanup:
PUTBACK;
*/
static xlat_action_t redis_remap_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
fr_redis_conn_t *conn;
fr_redis_cluster_rcode_t rcode;
fr_value_box_t *vb;
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
if (fr_inet_pton_port(&node_addr.inet.dst_ipaddr, &node_addr.inet.dst_port, in_head->vb_strvalue, in_head->vb_length,
AF_UNSPEC, true, true) < 0) {
*/
static xlat_action_t redis_node_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
unsigned long idx = 0;
fr_value_box_t *vb;
- fr_value_box_t *key = fr_dlist_head(in);
- fr_value_box_t *idx_vb = fr_dlist_next(in, key);
+ fr_value_box_t *key = fr_value_box_list_head(in);
+ fr_value_box_t *idx_vb = fr_value_box_list_next(in, key);
if (idx_vb) idx = idx_vb->vb_uint32;
*/
static xlat_action_t redis_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
xlat_action_t action = XLAT_ACTION_DONE;
redisReply *reply = NULL;
int s_ret;
- fr_value_box_t *first = fr_dlist_head(in);
+ fr_value_box_t *first = fr_value_box_list_head(in);
fr_sbuff_t sbuff = FR_SBUFF_IN(first->vb_strvalue, first->vb_length);
int argc = 0;
return XLAT_ACTION_FAIL;
}
- fr_dlist_talloc_free_head(in); /* Remove and free server arg */
+ fr_value_box_list_talloc_free_head(in); /* Remove and free server arg */
- fr_dlist_foreach(in, fr_value_box_t, vb) {
+ fr_value_box_list_foreach(in, vb) {
if (argc == NUM_ELEMENTS(argv)) {
REDEBUG("Too many arguments (%i)", argc);
REXDENT();
argc++;
}
- RDEBUG2("Executing command: %pV", fr_dlist_head(in));
+ RDEBUG2("Executing command: %pV", fr_value_box_list_head(in));
if (argc > 1) {
RDEBUG2("With arguments");
RINDENT();
RDEBUG2("REDIS command arguments");
RINDENT();
- fr_dlist_foreach(in, fr_value_box_t, vb) {
+ fr_value_box_list_foreach(in, vb) {
if (argc == NUM_ELEMENTS(argv)) {
REDEBUG("Too many arguments (%i)", argc);
REXDENT();
for (s_ret = fr_redis_cluster_state_init(&state, &conn, inst->cluster, request, key, key_len, read_only);
s_ret == REDIS_RCODE_TRY_AGAIN; /* Continue */
s_ret = fr_redis_cluster_state_next(&state, &conn, inst->cluster, request, status, &reply)) {
- RDEBUG2("Executing command: %pV", fr_dlist_head(in));
+ RDEBUG2("Executing command: %pV", fr_value_box_list_head(in));
if (argc > 1) {
RDEBUG2("With arguments");
RINDENT();
"local owner_key" EOL /* 5 */
"pool_key = '{' .. KEYS[1] .. '}:"IPPOOL_POOL_KEY"'" EOL /* 6 */
- "owner_key = '{' .. KEYS[1] .. '}:"IPPOOL_OWNER_KEY":' .. ARGV[3]" EOL /* 7 */
+ "owner_key = '{' .. KEYS[1] .. '}:"IPPOOL_OWNER_KEY":' .. ARGV[3]" EOL /* 7 */
/*
* Check to see if the client already has a lease,
" if expires_in > 0 then" EOL /* 11 */
" ip = redis.call('HMGET', '{' .. KEYS[1] .. '}:"IPPOOL_ADDRESS_KEY":' .. exists, 'device', 'range', 'counter')" EOL /* 12 */
" if ip and (ip[1] == ARGV[3]) then" EOL /* 13 */
-// " if expires_in < ARGV[2] then" EOL /* 14 */
-// " redis.call('ZADD', pool_key, 'XX', ARGV[1] + ARGV[2], ip[1])" EOL /* 15 */
-// " expires_in = ARGV[2]" EOL /* 16 */
-// " end" EOL /* 17 */
+ " if expires_in < ARGV[2] then" EOL /* 14 */
+ " redis.call('ZADD', pool_key, 'XX', ARGV[1] + ARGV[2], ip[1])" EOL /* 15 */
+ " expires_in = ARGV[2]" EOL /* 16 */
+ " end" EOL /* 17 */
" return {" STRINGIFY(_IPPOOL_RCODE_SUCCESS) ", exists, ip[2], expires_in, ip[3] }" EOL /* 18 */
" end" EOL /* 19 */
" end" EOL /* 20 */
static xlat_action_t rest_xlat_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_rest_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_rest_thread_t);
*/
static xlat_action_t rest_xlat(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_rest_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_rest_thread_t);
fr_curl_io_request_t *randle = NULL;
int ret;
http_method_t method;
- fr_value_box_t *in_vb = fr_dlist_pop_head(in), *uri_vb = NULL;
+ fr_value_box_t *in_vb = fr_value_box_list_pop_head(in), *uri_vb = NULL;
/* There are no configurable parameters other than the URI */
rlm_rest_xlat_rctx_t *rctx;
/*
* If we have more than 1 argument, then the first is the method
*/
- if ((fr_dlist_head(in))) {
- uri_vb = fr_dlist_head(&in_vb->vb_group);
+ if ((fr_value_box_list_head(in))) {
+ uri_vb = fr_value_box_list_head(&in_vb->vb_group);
if (fr_value_box_list_concat_in_place(uri_vb,
uri_vb, &in_vb->vb_group, FR_TYPE_STRING,
FR_VALUE_BOX_LIST_FREE, true,
/*
* Move to next argument
*/
- in_vb = fr_dlist_pop_head(in);
+ in_vb = fr_value_box_list_pop_head(in);
uri_vb = NULL;
} else {
section->method = REST_HTTP_METHOD_GET;
return XLAT_ACTION_FAIL;
}
- uri_vb = fr_dlist_head(&in_vb->vb_group);
+ uri_vb = fr_value_box_list_head(&in_vb->vb_group);
if (fr_value_box_list_concat_in_place(uri_vb,
uri_vb, &in_vb->vb_group, FR_TYPE_STRING,
FR_VALUE_BOX_LIST_FREE, true,
/*
* Any additional arguments are freeform data
*/
- if ((in_vb = fr_dlist_head(in))) {
+ if ((in_vb = fr_value_box_list_head(in))) {
if (fr_value_box_list_concat_in_place(in_vb,
in_vb, in, FR_TYPE_STRING,
FR_VALUE_BOX_LIST_FREE, true,
*/
static xlat_action_t soh_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_value_box_t *vb;
fr_pair_t* vp[6];
char const *osname;
*/
static int sql_xlat_escape(request_t *request, fr_value_box_t *vb, void *uctx)
{
- fr_sbuff_t sbuff;
- fr_sbuff_uctx_talloc_t sbuff_ctx;
+ fr_sbuff_t sbuff;
+ fr_sbuff_uctx_talloc_t sbuff_ctx;
- size_t len;
- rlm_sql_handle_t *handle;
- rlm_sql_t *inst = talloc_get_type_abort(uctx, rlm_sql_t);
- fr_dlist_t entry;
+ size_t len;
+ rlm_sql_handle_t *handle;
+ rlm_sql_t *inst = talloc_get_type_abort(uctx, rlm_sql_t);
+ FR_DLIST_ENTRY(fr_value_box_list) entry;
handle = fr_pool_connection_get(inst->pool, request);
if (!handle) {
*/
static xlat_action_t sql_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_sql_handle_t *handle = NULL;
rlm_sql_row_t row;
sql_rcode_t rcode;
xlat_action_t ret = XLAT_ACTION_DONE;
char const *p;
- fr_value_box_t *arg = fr_dlist_head(in);
+ fr_value_box_t *arg = fr_value_box_list_head(in);
fr_value_box_t *vb = NULL;
bool fetched = false;
* - #RLM_MODULE_FAIL if a fault occurred.
*/
static rlm_rcode_t mod_map_proc(void *mod_inst, UNUSED void *proc_inst, request_t *request,
- fr_value_box_list_t *query, map_list_t const *maps)
+ FR_DLIST_HEAD(fr_value_box_list) *query, map_list_t const *maps)
{
rlm_sql_t *inst = talloc_get_type_abort(mod_inst, rlm_sql_t);
rlm_sql_handle_t *handle = NULL;
char map_rhs_buff[128];
char const *query_str = NULL;
- fr_value_box_t *query_head = fr_dlist_head(query);
+ fr_value_box_t *query_head = fr_value_box_list_head(query);
#define MAX_SQL_FIELD_INDEX (64)
*/
static xlat_action_t trigger_test_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
- fr_value_box_t *in_head = fr_dlist_head(in);
+ fr_value_box_t *in_head = fr_value_box_list_head(in);
fr_value_box_t *vb;
MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL, false));
*/
static xlat_action_t test_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, UNUSED request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb_p = NULL;
fr_value_box_t *vb;
- while ((vb_p = fr_dlist_next(in, vb_p))) {
+ while ((vb_p = fr_value_box_list_next(in, vb_p))) {
MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_STRING, NULL, false));
if (fr_value_box_copy(ctx, vb, vb_p) < 0) {
fr_type_t return_type; //!< Data type to parse results into
bool has_priority; //!< Does the returned data start with a priority field
uint16_t count; //!< Number of results to return
- fr_value_box_list_t list; //!< Where to put the parsed results
+ FR_DLIST_HEAD(fr_value_box_list) list; //!< Where to put the parsed results
TALLOC_CTX *out_ctx; //!< CTX to allocate parsed results in
fr_event_timer_t const *ev; //!< Event for timeout
} unbound_request_t;
&dbuff, rdlength, true) < 0) {
error:
talloc_free(vb);
- fr_dlist_talloc_free(&ur->list);
+ fr_value_box_list_talloc_free(&ur->list);
ur->done = -32;
goto resume;
}
talloc_free(priority_vb);
goto error;
}
- fr_dlist_insert_tail(&ur->list, priority_vb);
+ fr_value_box_list_insert_tail(&ur->list, priority_vb);
}
/* String types require decoding of dns format labels */
goto error;
}
- fr_dlist_insert_tail(&ur->list, vb);
+ fr_value_box_list_insert_tail(&ur->list, vb);
}
*/
static xlat_action_t xlat_unbound_resume(UNUSED TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, UNUSED fr_value_box_list_t *in)
+ request_t *request, UNUSED FR_DLIST_HEAD(fr_value_box_list) *in)
{
fr_value_box_t *vb;
unbound_request_t *ur = talloc_get_type_abort(xctx->rctx, unbound_request_t);
/*
* Move parsed results into xlat cursor
*/
- while ((vb = fr_dlist_pop_head(&ur->list))) {
+ while ((vb = fr_value_box_list_pop_head(&ur->list))) {
fr_dcursor_append(out, vb);
}
*/
static xlat_action_t xlat_unbound(TALLOC_CTX *ctx, fr_dcursor_t *out,
xlat_ctx_t const *xctx,
- request_t *request, fr_value_box_list_t *in)
+ request_t *request, FR_DLIST_HEAD(fr_value_box_list) *in)
{
rlm_unbound_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_unbound_t);
rlm_unbound_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_unbound_thread_t);
- fr_value_box_t *host_vb = fr_dlist_head(in);
- fr_value_box_t *query_vb = fr_dlist_next(in, host_vb);
- fr_value_box_t *count_vb = fr_dlist_next(in, query_vb);
+ fr_value_box_t *host_vb = fr_value_box_list_head(in);
+ fr_value_box_t *query_vb = fr_value_box_list_next(in, host_vb);
+ fr_value_box_t *count_vb = fr_value_box_list_next(in, query_vb);
unbound_request_t *ur;
if (host_vb->length == 0) {
*/
static xlat_action_t unpack_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
UNUSED xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
size_t len, input_len, offset;
fr_type_t type;
uint8_t const *input;
uint8_t blob[256];
- fr_value_box_t *data_vb = fr_dlist_head(in);
- fr_value_box_t *offset_vb = fr_dlist_next(in, data_vb);
- fr_value_box_t *type_vb = fr_dlist_next(in, offset_vb);
+ fr_value_box_t *data_vb = fr_value_box_list_head(in);
+ fr_value_box_t *offset_vb = fr_value_box_list_next(in, data_vb);
+ fr_value_box_t *type_vb = fr_value_box_list_next(in, offset_vb);
fr_value_box_t *vb;
if ((data_vb->type != FR_TYPE_OCTETS) && (data_vb->type != FR_TYPE_STRING)) {
*/
static xlat_action_t modhex_to_hex_xlat(UNUSED TALLOC_CTX *ctx, fr_dcursor_t * out,
UNUSED xlat_ctx_t const *xctx, request_t *request,
- fr_value_box_list_t *in)
+ FR_DLIST_HEAD(fr_value_box_list) *in)
{
ssize_t len;
- fr_value_box_t *arg = fr_dlist_pop_head(in);
+ fr_value_box_t *arg = fr_value_box_list_pop_head(in);
char *p = UNCONST(char *, arg->vb_strvalue);
/*
projects / thirdparty / freeradius-server.git / commitdiff
