add and use request->local_dict

which is initialized to request->dict (the protocol dictionary)
in request_init().

it is saved, updated, and restored every time the interpreter
defines a local attribute

update request_init() to set dict to internal if it isn't passed
in.

update nearly all references to run-time parsing from request->dict
to request->local_dict.  Only the protocol encoders are left
unchanged.

this means that maps, %debug() etc. can now reference local
attributes, which they couldn't before.

update %eval() to use the local dict, too.

update fr_listen_t to have a dict, so the worker thread can use it.

and don't set request->dict in the listen decode any more.

Author: alandekok

src/bin/unit_test_module.c

@@ -190,35 +190,28 @@ static request_t *request_from_file(TALLOC_CTX *ctx, FILE *fp, fr_client_t *clie
 
 	static int	number = 0;
 
-	/*
-	 *	Create and initialize the new request.
-	 */
-	request = request_local_alloc_external(ctx, NULL);
-
-	/*
-	 *	FIXME - Should be less RADIUS centric, but everything
-	 *	else assumes RADIUS at the moment so we can fix this later.
-	 */
-	request->dict = dict_protocol;
-	if (!request->dict) {
+	if (!dict_protocol) {
 		fr_strerror_printf_push("%s dictionary failed to load", PROTOCOL_NAME);
-	error:
-		talloc_free(request);
 		return NULL;
 	}
 
+	/*
+	 *	Create and initialize the new request.
+	 */
+	request = request_local_alloc_external(ctx, (&(request_init_args_t){ .namespace = dict_protocol }));
+
 	request->packet = fr_packet_alloc(request, false);
 	if (!request->packet) {
+	oom:
 		fr_strerror_const("No memory");
-		goto error;
+	error:
+		talloc_free(request);
+		return NULL;
 	}
 	request->packet->timestamp = fr_time();
 
 	request->reply = fr_packet_alloc(request, false);
-	if (!request->reply) {
-		fr_strerror_const("No memory");
-		goto error;
-	}
+	if (!request->reply) goto oom;
 
 	request->client = client;
 	request->number = number++;
@@ -606,7 +599,7 @@ static request_t *request_clone(request_t *old, int number, CONF_SECTION *server
 {
 	request_t *request;
 
-	request = request_alloc_internal(NULL, NULL);
+	request = request_alloc_internal(NULL, (&(request_init_args_t){ .namespace = old->dict }));
 	if (!request) return NULL;
 
 	if (!request->packet) request->packet = fr_packet_alloc(request, false);
@@ -621,7 +614,6 @@ static request_t *request_clone(request_t *old, int number, CONF_SECTION *server
 	unlang_call_push(request, server_cs, UNLANG_TOP_FRAME);
 
 	request->master_state = REQUEST_ACTIVE;
-	request->dict = old->dict;
 
 	return request;
 }

src/lib/io/listen.h

@@ -27,6 +27,7 @@ struct fr_listen {
 
 	int			fd;			//!< file descriptor for this socket - set by open
 	char const		*name;			//!< printable name for this socket - set by open
+	fr_dict_t const		*dict;			//!< dictionary for this listener
 
 	fr_app_io_t const	*app_io;		//!< I/O path functions.
 	void const    		*app_io_instance;	//!< I/O path configuration context.

src/lib/io/network.c

@@ -237,6 +237,10 @@ int fr_network_listen_add(fr_network_t *nr, fr_listen_t *li)
 {
 	fr_ring_buffer_t *rb;
 
+	fr_assert(li->server_cs != NULL);
+	li->dict = virtual_server_dict_by_cs(li->server_cs);
+	fr_assert(li->dict != NULL);
+
 	/*
 	 *	Skip a bunch of work if we're already in the network thread.
 	 */

src/lib/io/worker.c

@@ -803,11 +803,17 @@ static void worker_request_bootstrap(fr_worker_t *worker, fr_channel_data_t *cd,
 	int			ret = -1;
 	request_t		*request;
 	TALLOC_CTX		*ctx;
-	fr_listen_t const	*listen;
+	fr_listen_t		*listen = cd->listen;
 
 	if (fr_minmax_heap_num_elements(worker->time_order) >= (uint32_t) worker->config.max_requests) goto nak;
 
-	ctx = request = request_alloc_external(NULL, NULL);
+	/*
+	 *	Receive a message to the worker queue, and decode it
+	 *	to a request.
+	 */
+	fr_assert(listen != NULL);
+
+	ctx = request = request_alloc_external(NULL, (&(request_init_args_t){ .namespace = listen->dict }));
 	if (!request) goto nak;
 
 	worker_request_init(worker, request, now);
@@ -820,23 +826,16 @@ static void worker_request_bootstrap(fr_worker_t *worker, fr_channel_data_t *cd,
 
 	request->packet->timestamp = cd->request.recv_time; /* Legacy - Remove once everything looks at request->async */
 
-	/*
-	 *	Receive a message to the worker queue, and decode it
-	 *	to a request.
-	 */
-	fr_assert(cd->listen != NULL);
-
 	/*
 	 *	Update the transport-specific fields.
 	 */
 	request->async->channel = cd->channel.ch;
 
 	request->async->recv_time = cd->request.recv_time;
 
-	request->async->listen = cd->listen;
+	request->async->listen = listen;
 	request->async->packet_ctx = cd->packet_ctx;
 	request->async->priority = cd->priority;
-	listen = request->async->listen;
 
 	/*
 	 *	Now that the "request" structure has been initialized, go decode the packet.

src/lib/server/map.c

@@ -1921,7 +1921,7 @@ int map_to_request(request_t *request, map_t const *map, radius_map_getvalue_t f
 		slen = tmpl_afrom_attr_str(tmp_ctx, NULL, &exp_lhs, attr_str,
 					   &(tmpl_rules_t){
 					   	.attr = {
-					   		.dict_def = request->dict,
+							.dict_def = request->local_dict,
 							.list_def = request_attr_request,
 				   		}
 					   });

src/lib/server/map_async.c

@@ -320,7 +320,7 @@ int map_to_list_mod(TALLOC_CTX *ctx, vp_list_mod_t **out,
 		slen = tmpl_afrom_attr_str(tmp_ctx, NULL, &map_tmp.lhs, lhs_result_head->vb_strvalue,
 					   &(tmpl_rules_t){
 					   	.attr = {
-					   		.dict_def = request->dict,
+							.dict_def = request->local_dict,
 							.list_def = request_attr_request,
 				   		}
 					   });

src/lib/server/pair_server_tests.c

@@ -79,7 +79,7 @@ static request_t *request_fake_alloc(void)
 	/*
 	 *	Create and initialize the new request.
 	 */
-	request = request_local_alloc_external(autofree, NULL);
+	request = request_local_alloc_external(autofree, (&(request_init_args_t){ .namespace = test_dict }));
 
 	request->packet = fr_packet_alloc(request, false);
 	TEST_CHECK(request->packet != NULL);

src/lib/server/request.c

@@ -31,8 +31,6 @@ RCSID("$Id$")
 #include <freeradius-devel/util/debug.h>
 #include <freeradius-devel/util/atexit.h>
 
-static request_init_args_t	default_args;
-
 static fr_dict_t const *dict_freeradius;
 
 extern fr_dict_autoload_t request_dict[];
@@ -198,7 +196,7 @@ static inline CC_HINT(always_inline) int request_detachable_init(request_t *chil
 static inline CC_HINT(always_inline) int request_child_init(request_t *child, request_t *parent)
 {
 	child->number = parent->child_number++;
-	if (!child->dict) child->dict = parent->dict;
+	if (!child->dict) child->local_dict = child->dict = parent->dict;
 
 	if ((parent->seq_start == 0) || (parent->number == parent->seq_start)) {
 		child->name = talloc_typed_asprintf(child, "%s.%" PRIu64, parent->name, child->number);
@@ -243,16 +241,28 @@ static inline CC_HINT(always_inline) int request_init(char const *file, int line
 						      request_t *request, request_type_t type,
 						      request_init_args_t const *args)
 {
+	fr_dict_t const *dict;
 
 	/*
 	 *	Sanity checks for different requests types
 	 */
 	switch (type) {
 	case REQUEST_TYPE_EXTERNAL:
+		fr_assert(args);
+
 		if (!fr_cond_assert_msg(!args->parent, "External requests must NOT have a parent")) return -1;
+
+		fr_assert(args->namespace);
+
+		dict = args->namespace;
 		break;
 
 	case REQUEST_TYPE_INTERNAL:
+		if (!args || !args->namespace) {
+			dict = fr_dict_internal();
+		} else {
+			dict = args->namespace;
+		}
 		break;
 
 	case REQUEST_TYPE_DETACHED:
@@ -267,10 +277,11 @@ static inline CC_HINT(always_inline) int request_init(char const *file, int line
 #endif
 		.type = type,
 		.master_state = REQUEST_ACTIVE,
-		.dict = args->namespace,
+		.dict = dict,
+		.local_dict = dict,
 		.component = "<pre-core>",
 		.flags = {
-			.detachable = args->detachable
+			.detachable = args && args->detachable,
 		},
 		.alloc_file = file,
 		.alloc_line = line
@@ -306,7 +317,7 @@ static inline CC_HINT(always_inline) int request_init(char const *file, int line
 		 *	the any uninitialised lists and
 		 *	create them locally.
 		 */
-		memcpy(&request->pair_list, &args->pair_list, sizeof(request->pair_list));
+		if (args) memcpy(&request->pair_list, &args->pair_list, sizeof(request->pair_list));
 
 #define list_init(_ctx, _list) \
 	do { \
@@ -337,7 +348,7 @@ static inline CC_HINT(always_inline) int request_init(char const *file, int line
 	 *	fields if this is going to be a
 	 *	child request.
 	 */
-	if (args->parent) {
+	if (args && args->parent) {
 		if (request_child_init(request, args->parent) < 0) return -1;
 
 		if (args->detachable) {
@@ -504,8 +515,6 @@ request_t *_request_alloc(char const *file, int line, TALLOC_CTX *ctx,
 	request_t		*request;
 	fr_dlist_head_t		*free_list;
 
-	if (!args) args = &default_args;
-
 	/*
 	 *	Setup the free list, or return the free
 	 *	list for this thread.
@@ -610,8 +619,6 @@ request_t *_request_local_alloc(char const *file, int line, TALLOC_CTX *ctx,
 {
 	request_t *request;
 
-	if (!args) args = &default_args;
-
 	request = request_alloc_pool(ctx);
 	if (request_init(file, line, request, type, args) < 0) return NULL;
 
@@ -814,6 +821,9 @@ void request_verify(char const *file, int line, request_t const *request)
 	fr_pair_list_verify(file, line, request->session_state_ctx, &request->session_state_pairs);
 	fr_pair_list_verify(file, line, request->local_ctx, &request->local_pairs);
 
+	fr_assert(request->dict != NULL);
+	fr_assert(request->local_dict != NULL);
+
 	if (request->packet) {
 		packet_verify(file, line, request, request->packet, &request->request_pairs, "request");
 	}

src/lib/server/request.h

@@ -184,6 +184,7 @@ struct request_s {
 	uint64_t		seq_start;	//!< State sequence ID.  Stable identifier for a sequence of requests
 						//!< and responses.
 	fr_dict_t const		*dict;		//!< Dictionary of the protocol that this request belongs to.
+	fr_dict_t const		*local_dict;	//!< dictionary for local variables
 
 	fr_pair_t		*pair_root;	//!< Root attribute which contains the
 						///< other list attributes as children.

src/lib/server/tmpl_dcursor_tests.c

@@ -41,7 +41,7 @@ static request_t *request_fake_alloc(void)
 	/*
 	 *	Create and initialize the new request.
 	 */
-	request = request_local_alloc_external(autofree, NULL);
+	request = request_local_alloc_external(autofree, (&(request_init_args_t){ .namespace = test_dict }));
 
 	request->packet = fr_packet_alloc(request, false);
 	TEST_CHECK(request->packet != NULL);