The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
client.c
Go to the documentation of this file.
1/*
2 * This program is is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or (at
5 * your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: 17b467337dc61bc55e8b75d6fcb7e159197f303d $
19 * @file src/lib/server/client.c
20 * @brief Manage clients allowed to communicate with the server.
21 *
22 * @copyright 2015 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
23 * @copyright 2000,2006 The FreeRADIUS server project
24 * @copyright 2000 Alan DeKok (aland@freeradius.org)
25 * @copyright 2000 Miquel van Smoorenburg (miquels@cistron.nl)
26 */
27RCSID("$Id: 17b467337dc61bc55e8b75d6fcb7e159197f303d $")
28
29#include <freeradius-devel/protocol/freeradius/freeradius.internal.h>
30#include <freeradius-devel/server/cf_file.h>
31#include <freeradius-devel/server/cf_parse.h>
32#include <freeradius-devel/server/client.h>
33#include <freeradius-devel/server/main_config.h>
34#include <freeradius-devel/server/module.h>
35#include <freeradius-devel/server/virtual_servers.h>
36#include <freeradius-devel/unlang/call.h>
37
38#include <freeradius-devel/util/base16.h>
39#include <freeradius-devel/util/misc.h>
40#include <freeradius-devel/util/trie.h>
41
42#include <fcntl.h>
43#include <sys/stat.h>
44
45//#define WITH_TRIE (1)
46
47/** Group of clients
48 *
49 */
51 char const *name; //!< Name of the client list.
52#ifdef WITH_TRIE
53 fr_trie_t *v4_udp;
54 fr_trie_t *v6_udp;
55 fr_trie_t *v4_tcp;
56 fr_trie_t *v6_tcp;
57#else
59#endif
60};
61
62static fr_client_list_t *root_clients = NULL; //!< Global client list.
63
64#ifndef WITH_TRIE
65static int8_t client_cmp(void const *one, void const *two)
66{
67 int ret;
68 fr_client_t const *a = one;
69 fr_client_t const *b = two;
70
71 ret = fr_ipaddr_cmp(&a->ipaddr, &b->ipaddr);
72 if (ret != 0) return ret;
73
74 /*
75 * 0 is "wildcard", or "both" protocols
76 */
77 if ((a->proto == IPPROTO_IP) || (b->proto == IPPROTO_IP)) return 0;
78
79 return CMP(a->proto, b->proto);
80}
81
82#endif
83
85{
86 TALLOC_FREE(root_clients);
87}
88
89/** Free a client
90 *
91 * It's up to the caller to ensure that it's deleted from any fr_client_list_t.
92 */
94{
95 if (!client) return;
96
97 talloc_free(client);
98}
99
100/** Return a new client list
101 *
102 * @note The container won't contain any clients.
103 *
104 * @return
105 * - New client list on success.
106 * - NULL on error (OOM).
107 */
109{
110 fr_client_list_t *clients = talloc_zero(cs, fr_client_list_t);
111
112 if (!clients) return NULL;
113
114 clients->name = talloc_strdup(clients, cs ? cf_section_name1(cs) : "root");
115
116#ifdef WITH_TRIE
117 clients->v4_udp = fr_trie_alloc(clients, NULL, NULL);
118 if (!clients->v4_udp) {
119 talloc_free(clients);
120 return NULL;
121 }
122
123 clients->v6_udp = fr_trie_alloc(clients, NULL, NULL);
124 if (!clients->v6_udp) {
125 talloc_free(clients);
126 return NULL;
127 }
128
129 clients->v4_tcp = fr_trie_alloc(clients, NULL, NULL);
130 if (!clients->v4_tcp) {
131 talloc_free(clients);
132 return NULL;
133 }
134
135 clients->v6_tcp = fr_trie_alloc(clients, NULL, NULL);
136 if (!clients->v6_tcp) {
137 talloc_free(clients);
138 return NULL;
139 }
140#endif /* WITH_TRIE */
141
142 return clients;
143}
144
145#ifdef WITH_TRIE
146/*
147 * @todo - either support client definitions where "proto = *",
148 * or update this code to allow for that. i.e. we create yet
149 * another set of v4/v6 tries, for "proto = *" clients. And then
150 * do lookups there, too. Or, just unify the udp/tcp tries, and
151 * instead do post-processing? Though those two clients can have
152 * different secrets... and the trie code doesn't allow 2
153 * fr_trie_user_t nodes in a row. So we would have to instead
154 * handle that ourselves, with a wrapper around the fr_client_t
155 * structure that does udp/tcp/wildcard demultiplexing
156 */
157static fr_trie_t *clients_trie(fr_client_list_t const *clients, fr_ipaddr_t const *ipaddr,
158 int proto)
159{
160 if (ipaddr->af == AF_INET) {
161 if (proto == IPPROTO_TCP) return clients->v4_tcp;
162
163 return clients->v4_udp;
164 }
165
166 fr_assert(ipaddr->af == AF_INET6);
167
168 if (proto == IPPROTO_TCP) return clients->v6_tcp;
169
170 return clients->v6_udp;
171}
172#endif /* WITH_TRIE */
173
174/** Add a client to a fr_client_list_t
175 *
176 * @param clients list to add client to, may be NULL if global client list is being used.
177 * @param client to add.
178 * @return
179 * - true on success.
180 * - false on failure.
181 */
183{
184#ifdef WITH_TRIE
185 fr_trie_t *trie;
186#else
187#endif
188 fr_client_t *old;
190
191 if (!client) return false;
192
193 /*
194 * Hack to fixup wildcard clients
195 *
196 * If the IP is all zeros, with a 32 or 128 bit netmask
197 * assume the user meant to configure 0.0.0.0/0 instead
198 * of 0.0.0.0/32 - which would require the src IP of
199 * the client to be all zeros.
200 */
201 if (fr_ipaddr_is_inaddr_any(&client->ipaddr) == 1) switch (client->ipaddr.af) {
202 case AF_INET:
203 if (client->ipaddr.prefix == 32) client->ipaddr.prefix = 0;
204 break;
205
206 case AF_INET6:
207 if (client->ipaddr.prefix == 128) client->ipaddr.prefix = 0;
208 break;
209
210 default:
211 fr_assert(0);
212 }
213
214 fr_inet_ntop_prefix(buffer, sizeof(buffer), &client->ipaddr);
215 DEBUG3("Adding client %s (%s) to prefix tree %i", buffer, client->longname, client->ipaddr.prefix);
216
217 /*
218 * If "clients" is NULL, it means add to the global list,
219 * unless we're trying to add it to a virtual server...
220 */
221 if (!clients) {
222 if (client->server != NULL) {
223 CONF_SECTION *cs;
224 CONF_SECTION *subcs;
225
226 if (!client->cs) {
227 ERROR("Failed to find configuration section in client. Ignoring 'virtual_server' directive");
228 return false;
229 }
230
231 cs = cf_section_find(cf_root(client->cs), "server", client->server);
232 if (!cs) {
233 ERROR("Failed to find virtual server %s", client->server);
234 return false;
235 }
236
237 /*
238 * If this server has no "listen" section, add the clients
239 * to the global client list.
240 */
241 subcs = cf_section_find(cs, "listen", NULL);
242 if (!subcs) goto global_clients;
243
244 /*
245 * If the client list already exists, use that.
246 * Otherwise, create a new client list.
247 */
248 clients = cf_data_value(cf_data_find(cs, fr_client_list_t, NULL));
249 if (!clients) {
250 MEM(clients = client_list_init(cs));
251 if (!cf_data_add(cs, clients, NULL, true)) {
252 ERROR("Failed to associate clients with virtual server %s", client->server);
253 talloc_free(clients);
254 return false;
255 }
256 }
257
258 } else {
259 global_clients:
260 /*
261 * Initialize the global list, if not done already.
262 */
263 if (!root_clients) {
265 if (!root_clients) return false;
266 }
267 clients = root_clients;
268 }
269 }
270
271#define namecmp(a) ((!old->a && !client->a) || (old->a && client->a && (strcmp(old->a, client->a) == 0)))
272
273#ifdef WITH_TRIE
274 trie = clients_trie(clients, &client->ipaddr, client->proto);
275
276 /*
277 * Cannot insert the same client twice.
278 */
279 old = fr_trie_match_by_key(trie, &client->ipaddr.addr, client->ipaddr.prefix);
280
281#else /* WITH_TRIE */
282
283 if (!clients->tree[client->ipaddr.prefix]) {
284 clients->tree[client->ipaddr.prefix] = fr_rb_inline_talloc_alloc(clients, fr_client_t, node, client_cmp,
285 NULL);
286 if (!clients->tree[client->ipaddr.prefix]) {
287 return false;
288 }
289 }
290
291 old = fr_rb_find(clients->tree[client->ipaddr.prefix], client);
292#endif
293 if (old) {
294 /*
295 * If it's a complete duplicate, then free the new
296 * one, and return "OK".
297 */
298 if (namecmp(longname) && namecmp(secret) &&
299 namecmp(shortname) && namecmp(nas_type) &&
300 namecmp(server) &&
302 WARN("Ignoring duplicate client %s", client->longname);
303 client_free(client);
304 return true;
305 }
306
307 ERROR("Failed to add duplicate client %s", client->shortname);
308 client_free(client);
309 return false;
310 }
311#undef namecmp
312
313#ifdef WITH_TRIE
314 /*
315 * Other error adding client: likely is fatal.
316 */
317 if (fr_trie_insert_by_key(trie, &client->ipaddr.addr, client->ipaddr.prefix, client) < 0) {
318 client_free(client);
319 return false;
320 }
321#else
322 if (!fr_rb_insert(clients->tree[client->ipaddr.prefix], client)) {
323 client_free(client);
324 return false;
325 }
326#endif
327
328 /*
329 * @todo - do we want to do this for dynamic clients?
330 */
331 (void) talloc_steal(clients, client); /* reparent it */
332
333 return true;
334}
335
336
338{
339#ifdef WITH_TRIE
340 fr_trie_t *trie;
341#endif
342
343 if (!client) return;
344
345 if (!clients) clients = root_clients;
346
347 fr_assert(client->ipaddr.prefix <= 128);
348
349#ifdef WITH_TRIE
350 trie = clients_trie(clients, &client->ipaddr, client->proto);
351
352 /*
353 * Don't free the client. The caller is responsible for that.
354 */
355 (void) fr_trie_remove_by_key(trie, &client->ipaddr.addr, client->ipaddr.prefix);
356#else
357
358 if (!clients->tree[client->ipaddr.prefix]) return;
359
360 (void) fr_rb_delete(clients->tree[client->ipaddr.prefix], client);
361#endif
362}
363
365{
366 return NULL;
367}
368
369
370/*
371 * Find a client in the fr_client_tS list.
372 */
373fr_client_t *client_find(fr_client_list_t const *clients, fr_ipaddr_t const *ipaddr, int proto)
374{
375#ifdef WITH_TRIE
376 fr_trie_t *trie;
377#else
378 int i, max;
379 fr_client_t my_client, *client;
380#endif
381
382 if (!clients) clients = root_clients;
383
384 if (!clients || !ipaddr) return NULL;
385
386#ifdef WITH_TRIE
387 trie = clients_trie(clients, ipaddr, proto);
388
389 return fr_trie_lookup_by_key(trie, &ipaddr->addr, ipaddr->prefix);
390#else
391
392 if (proto == AF_INET) {
393 max = 32;
394 } else {
395 max = 128;
396 }
397
398 if (max > ipaddr->prefix) max = ipaddr->prefix;
399
400 my_client.proto = proto;
401 for (i = max; i >= 0; i--) {
402 if (!clients->tree[i]) continue;
403
404 my_client.ipaddr = *ipaddr;
405 fr_ipaddr_mask(&my_client.ipaddr, i);
406 client = fr_rb_find(clients->tree[i], &my_client);
407 if (client) {
408 return client;
409 }
410 }
411
412 return NULL;
413#endif
414}
415
417static char const *cl_srcipaddr = NULL;
418static char const *hs_proto = NULL;
419
421 { FR_CONF_OFFSET("max_connections", fr_client_t, limit.max_connections), .dflt = "16" },
422
423 { FR_CONF_OFFSET("lifetime", fr_client_t, limit.lifetime), .dflt = "0" },
424
425 { FR_CONF_OFFSET("idle_timeout", fr_client_t, limit.idle_timeout), .dflt = "30s" },
427};
428
429static const conf_parser_t client_config[] = {
431 { FR_CONF_POINTER("ipv4addr", FR_TYPE_IPV4_PREFIX, 0, &cl_ipaddr) },
432 { FR_CONF_POINTER("ipv6addr", FR_TYPE_IPV6_PREFIX, 0, &cl_ipaddr) },
433
434 { FR_CONF_POINTER("src_ipaddr", FR_TYPE_STRING, 0, &cl_srcipaddr) },
435
437 { FR_CONF_OFFSET("shortname", fr_client_t, shortname) },
438
439 { FR_CONF_OFFSET("nas_type", fr_client_t, nas_type) },
440
441 { FR_CONF_OFFSET_IS_SET("require_message_authenticator", FR_TYPE_UINT32, 0, fr_client_t, require_message_authenticator),
444 .dflt = "no" },
445
446 { FR_CONF_OFFSET_IS_SET("limit_proxy_state", FR_TYPE_UINT32, 0, fr_client_t, limit_proxy_state),
447 .func = cf_table_parse_int,
449 .dflt = "auto" },
450
451 { FR_CONF_OFFSET("response_window", fr_client_t, response_window) },
452
453 { FR_CONF_POINTER("proto", FR_TYPE_STRING, 0, &hs_proto) },
454 { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
455
457};
458
459/** Create a list of clients from a client section
460 *
461 * Iterates over all client definitions in the specified section, adding them to a client list.
462 */
463#ifdef WITH_TLS
464#define TLS_UNUSED
465#else
466#define TLS_UNUSED UNUSED
467#endif
468
470{
471 bool global = false;
472 CONF_SECTION *cs = NULL;
473 fr_client_t *c = NULL;
474 fr_client_list_t *clients = NULL;
475 CONF_SECTION *server_cs = NULL;
476
477 /*
478 * Be forgiving. If there's already a clients, return
479 * it. Otherwise create a new one.
480 */
481 clients = cf_data_value(cf_data_find(section, fr_client_list_t, NULL));
482 if (clients) return clients;
483
484 /*
485 * Parent the client list from the section.
486 */
487 clients = client_list_init(section);
488 if (!clients) return NULL;
489
490 /*
491 * If the section is hung off the config root, this is
492 * the global client list, else it's virtual server
493 * specific client list.
494 */
495 if (cf_root(section) == section) global = true;
496
497 if (strcmp("server", cf_section_name1(section)) == 0) server_cs = section;
498
499 /*
500 * Iterate over all the clients in the section, adding
501 * them to the client list.
502 */
503 while ((cs = cf_section_find_next(section, cs, "client", CF_IDENT_ANY))) {
504 /*
505 * Check this before parsing the client.
506 */
507 if (proto) {
508 CONF_PAIR *cp;
509 int client_proto = IPPROTO_UDP;
510
511 cp = cf_pair_find(cs, "proto");
512 if (cp) {
513 char const *value = cf_pair_value(cp);
514
515 if (!value) {
516 cf_log_err(cs, "'proto' field must have a value");
517 talloc_free(clients);
518 return NULL;
519 }
520
521 if (strcmp(value, "udp") == 0) {
522 /* do nothing */
523
524 } else if (strcmp(value, "tcp") == 0) {
525 client_proto = IPPROTO_TCP;
526#ifdef WITH_TLS
527 } else if (strcmp(value, "tls") == 0) {
528 client_proto = IPPROTO_TCP;
529#endif
530 } else if (strcmp(value, "*") == 0) {
531 client_proto = IPPROTO_IP; /* fake for dual */
532 } else {
533 cf_log_err(cs, "Unknown proto \"%s\".", value);
534 talloc_free(clients);
535 return NULL;
536 }
537 }
538
539 /*
540 * We don't have "proto = *", so the
541 * protocol MUST match what the caller
542 * asked for. Otherwise, we ignore the
543 * client.
544 */
545 if ((client_proto != IPPROTO_IP) && (proto != client_proto)) continue;
546 }
547
548
549 c = client_afrom_cs(cs, cs, server_cs, 0);
550 if (!c) {
551 error:
552 client_free(c);
553 talloc_free(clients);
554 return NULL;
555 }
556
557 /*
558 * TCP sockets are always connected.
559 */
560 c->use_connected |= (c->proto == IPPROTO_TCP);
561
562#ifdef WITH_TLS
563 /*
564 * TLS clients CANNOT use non-TLS listeners.
565 * non-TLS clients CANNOT use TLS listeners.
566 */
567 if (tls_required != c->tls_required) {
568 cf_log_err(cs, "Client does not have the same TLS configuration as the listener");
569 goto error;
570 }
571#endif
572
573 if (!client_add(clients, c)) {
574 cf_log_err(cs, "Failed to add client %s", cf_section_name2(cs));
575 goto error;
576 }
577
578 }
579
580 /*
581 * Associate the clients structure with the section.
582 */
583 if (!cf_data_add(section, clients, NULL, false)) {
584 cf_log_err(section, "Failed to associate clients with section %s", cf_section_name1(section));
585 talloc_free(clients);
586 return NULL;
587 }
588
589 /*
590 * Replace the global list of clients with the new one.
591 * The old one is still referenced from the original
592 * configuration, and will be freed when that is freed.
593 */
594 if (global) root_clients = clients;
595
596 return clients;
597}
598
599/** Create a client CONF_SECTION using a mapping section to map values from a result set to client attributes
600 *
601 * If we hit a CONF_SECTION we recurse and process its CONF_PAIRS too.
602 *
603 * @note Caller should free CONF_SECTION passed in as out, on error.
604 * Contents of that section will be in an undefined state.
605 *
606 * @param[in,out] out Section to perform mapping on. Either the root of the client config, or a parent section
607 * (when this function is called recursively).
608 * Should be alloced with cf_section_alloc, or if there's a separate template section, the
609 * result of calling cf_section_dup on that section.
610 * @param[in] map section.
611 * @param[in] func to call to retrieve CONF_PAIR values. Must return a talloced buffer containing the value.
612 * @param[in] data to pass to func, usually a result pointer.
613 * @return
614 * - 0 on success.
615 * - -1 on failure.
616 */
618{
619 CONF_ITEM const *ci;
620
621 for (ci = cf_item_next(map, NULL);
622 ci != NULL;
623 ci = cf_item_next(map, ci)) {
624 CONF_PAIR const *cp;
625 CONF_PAIR *old;
626 char *value;
627 char const *attr;
628
629 /*
630 * Recursively process map subsection
631 */
632 if (cf_item_is_section(ci)) {
633 CONF_SECTION *cs, *cc;
634
635 cs = cf_item_to_section(ci);
636 /*
637 * Use pre-existing section or alloc a new one
638 */
640 if (!cc) {
642 if (!cc) return -1;
643 }
644
645 if (client_map_section(cc, cs, func, data) < 0) return -1;
646 continue;
647 }
648
649 cp = cf_item_to_pair(ci);
650 attr = cf_pair_attr(cp);
651
652 /*
653 * The callback can return 0 (success) and not provide a value
654 * in which case we skip the mapping pair.
655 *
656 * Or return -1 in which case we error out.
657 */
658 if (func(&value, cp, data) < 0) {
659 cf_log_err(out, "Failed performing mapping \"%s\" = \"%s\"", attr, cf_pair_value(cp));
660 return -1;
661 }
662 if (!value) continue;
663
664 /*
665 * Replace an existing CONF_PAIR
666 */
667 old = cf_pair_find(out, attr);
668 if (old) {
671 continue;
672 }
673
674 /*
675 * ...or add a new CONF_PAIR
676 */
678 if (!cp) {
679 cf_log_err(out, "Failed allocing pair \"%s\" = \"%s\"", attr, value);
681 return -1;
682 }
685 }
686
687 return 0;
688}
689
690/** Allocate a new client from a config section
691 *
692 * @param ctx to allocate new clients in.
693 * @param cs to process as a client.
694 * @param server_cs The virtual server that this client belongs to.
695 * @param extra 0 allocate sizeof(fr_client_t) bytes
696 * >sizeof(client_t) number of bytes to allocate
697 * @return new fr_client_t struct.
698 */
699fr_client_t *client_afrom_cs(TALLOC_CTX *ctx, CONF_SECTION *cs, CONF_SECTION *server_cs, size_t extra)
700{
701 fr_client_t *c;
702 char const *name2;
703 CONF_PAIR *cp;
704
705 name2 = cf_section_name2(cs);
706 if (!name2) {
707 cf_log_err(cs, "Missing client name");
708 return NULL;
709 }
710
711 /*
712 * The size is fine.. Let's create the buffer
713 */
714 if (!extra) {
715 c = talloc_zero(ctx, fr_client_t);
716 if (!c) return NULL;
717 } else {
718 fr_assert(extra > sizeof(fr_client_t));
719
720 c = (fr_client_t *) talloc_zero_array(ctx, uint8_t, extra);
721 if (!c) return NULL;
722
723 talloc_set_name_const(c, "fr_client_t");
724 }
725
726 c->cs = cs;
727
728 memset(&cl_ipaddr, 0, sizeof(cl_ipaddr));
729 if (cf_section_rules_push(cs, client_config) < 0) return NULL;
730
731 if (cf_section_parse(c, c, cs) < 0) {
732 cf_log_err(cs, "Error parsing client section");
733 error:
734 client_free(c);
735 hs_proto = NULL;
736 cl_srcipaddr = NULL;
737 return NULL;
738 }
739
740 /*
741 * Allow for binary secrets.
742 */
743 cp = cf_pair_find(cs, "secret");
744 if (cp && (cf_pair_operator(cp) == T_BARE_WORD)) {
745 char const *value;
746
747 value = cf_pair_value(cp);
748 if ((value[0] == '0') && (value[1] == 'x')) {
749 size_t bin_len, hex_len, converted;
750 uint8_t *bin;
751
752 /*
753 * '0x...' plus trailing NUL.
754 */
755 hex_len = talloc_array_length(value) - 3;
756 bin_len = (hex_len / 2) + 1;
757 MEM(bin = talloc_array(c, uint8_t, bin_len));
758 converted = fr_base16_decode(NULL,
759 &FR_DBUFF_TMP(bin, bin_len),
760 &FR_SBUFF_IN(value + 2, hex_len), false);
761 if (converted < (bin_len - 1)) {
762 cf_log_err(cs, "Invalid hex string in shared secret");
763 goto error;
764 }
765
767 c->secret = (char const *) bin;
768 }
769 }
770
771 /*
772 * Find the virtual server for this client.
773 */
774 if (c->server) {
775 virtual_server_t const *vs;
776 if (server_cs) {
777 cf_log_err(cs, "Clients inside of a 'server' section cannot point to a server");
778 goto error;
779 }
780
782 if (!vs) goto error;
783
785 if (!c->server_cs) {
786 cf_log_err(cs, "Failed to find virtual server %s", c->server);
787 goto error;
788 }
789
790 } else if (server_cs) {
791 c->server = cf_section_name2(server_cs);
792 c->server_cs = server_cs;
793
794 } /* else don't set c->server or c->server_cs, we will use listener->server */
795
796 /*
797 * Newer style client definitions with either ipaddr or ipaddr6
798 * config items.
799 */
800 if (cf_pair_find(cs, "ipaddr") || cf_pair_find(cs, "ipv4addr") || cf_pair_find(cs, "ipv6addr")) {
801 char buffer[128];
802
803 /*
804 * Sets ipv4/ipv6 address and prefix.
805 */
806 c->ipaddr = cl_ipaddr;
807
808 /*
809 * Set the long name to be the result of a reverse lookup on the IP address.
810 */
811 fr_inet_ntoh(&c->ipaddr, buffer, sizeof(buffer));
813
814 /*
815 * Set the short name to the name2.
816 */
817 if (!c->shortname) c->shortname = talloc_typed_strdup(c, name2);
818 /*
819 * No "ipaddr" or "ipv6addr", use old-style "client <ipaddr> {" syntax.
820 */
821 } else {
822 cf_log_err(cs, "No 'ipaddr' or 'ipv4addr' or 'ipv6addr' configuration "
823 "directive found in client %s", name2);
824 goto error;
825 }
826
827 c->proto = IPPROTO_UDP;
828 if (hs_proto) {
829 if (strcmp(hs_proto, "udp") == 0) {
830 hs_proto = NULL;
831
832 } else if (strcmp(hs_proto, "tcp") == 0) {
833 hs_proto = NULL;
834 c->proto = IPPROTO_TCP;
835#ifdef WITH_TLS
836 } else if (strcmp(hs_proto, "tls") == 0) {
837 hs_proto = NULL;
838 c->proto = IPPROTO_TCP;
839 c->tls_required = true;
840
841#endif
842 } else if (strcmp(hs_proto, "*") == 0) {
843 hs_proto = NULL;
844 c->proto = IPPROTO_IP; /* fake for dual */
845 } else {
846 cf_log_err(cs, "Unknown proto \"%s\".", hs_proto);
847 goto error;
848 }
849 }
850
851 /*
852 * If a src_ipaddr is specified, when we send the return packet
853 * we will use this address instead of the src from the
854 * request.
855 */
856 if (cl_srcipaddr) {
857 switch (c->ipaddr.af) {
858 case AF_INET:
859 if (fr_inet_pton4(&c->src_ipaddr, cl_srcipaddr, -1, true, false, true) < 0) {
860 cf_log_perr(cs, "Failed parsing src_ipaddr");
861 goto error;
862 }
863 break;
864
865 case AF_INET6:
866 if (fr_inet_pton6(&c->src_ipaddr, cl_srcipaddr, -1, true, false, true) < 0) {
867 cf_log_perr(cs, "Failed parsing src_ipaddr");
868 goto error;
869 }
870 break;
871 default:
872 cf_log_err(cs, "ipaddr was not defined");
873 goto error;
874 }
875 cl_srcipaddr = NULL;
876 } else {
877 c->src_ipaddr.af = c->ipaddr.af; /* leave the rest as IFADDR_ANY */
878 }
879
880 /*
881 * A response_window of zero is OK, and means that it's
882 * ignored by the rest of the server timers.
883 */
885 FR_TIME_DELTA_BOUND_CHECK("response_window", c->response_window, >=, fr_time_delta_from_usec(1000));
888 }
889
890#ifdef WITH_TLS
891 /*
892 * If the client is TLS only, the secret can be
893 * omitted. When omitted, it's hard-coded to
894 * "radsec". See RFC 6614.
895 */
896 if (c->tls_required) {
897 c->secret = talloc_typed_strdup(cs, "radsec");
898 }
899#endif
900
901 if ((c->proto == IPPROTO_TCP) || (c->proto == IPPROTO_IP)) {
908 }
909
910 return c;
911}
912
913/** Create a new client, consuming all attributes in the control list of the request
914 *
915 * @param ctx the talloc context
916 * @param request containing the client attributes.
917 * @return
918 * - New client on success.
919 * - NULL on error.
920 */
921fr_client_t *client_afrom_request(TALLOC_CTX *ctx, request_t *request)
922{
923 static int cnt;
924 CONF_SECTION *cs;
925 fr_client_t *c;
926 fr_sbuff_t *tmp;
927
928 if (!request) return NULL;
929
930 FR_SBUFF_TALLOC_THREAD_LOCAL(&tmp, 128, SIZE_MAX);
931
932 if (unlikely(fr_sbuff_in_sprintf(tmp, "dynamic_%i_", cnt++) <= 0)) {
933 name_error:
934 RERROR("Failed to generate dynamic client name");
935 return NULL;
936 }
937 if (unlikely(fr_value_box_print(tmp, fr_box_ipaddr(request->packet->socket.inet.src_ipaddr), NULL) <= 0)) goto name_error;
938 fr_sbuff_set_to_start(tmp);
939
940 cs = cf_section_alloc(ctx, NULL, "client", fr_sbuff_current(tmp));
941
942 RDEBUG2("Converting control.FreeRADIUS-Client-* to client {...} section");
943 RINDENT();
944
945 fr_pair_list_foreach(&request->control_pairs, vp) {
946 CONF_PAIR *cp = NULL;
947 char const *value;
948 char const *attr;
949 fr_token_t v_token = T_BARE_WORD;
950
951 if (!fr_dict_attr_is_top_level(vp->da)) continue;
952
953 switch (vp->da->attr) {
954 case FR_FREERADIUS_CLIENT_IP_ADDRESS:
955 attr = "ipv4addr";
956 vb_to_str:
957 fr_sbuff_set_to_start(tmp);
959 RERROR("Failed to convert %pP to string", vp);
960 error:
961 talloc_free(cs);
962 return NULL;
963 }
964 value = fr_sbuff_start(tmp);
965 break;
966
967 case FR_FREERADIUS_CLIENT_IP_PREFIX:
968 attr = "ipv4addr";
969 goto vb_to_str;
970
971 case FR_FREERADIUS_CLIENT_IPV6_ADDRESS:
972 attr = "ipv6addr";
973 goto vb_to_str;
974
975 case FR_FREERADIUS_CLIENT_IPV6_PREFIX:
976 attr = "ipv6addr";
977 goto vb_to_str;
978
979 case FR_FREERADIUS_CLIENT_SECRET:
980 attr = "secret";
981 value = vp->vp_strvalue;
982 break;
983
984 case FR_FREERADIUS_CLIENT_NAS_TYPE:
985 attr = "nas_type";
986 value = vp->vp_strvalue;
987 break;
988
989 case FR_FREERADIUS_CLIENT_SHORTNAME:
990 attr = "shortname";
991 value = vp->vp_strvalue;
992 break;
993
994 case FR_FREERADIUS_CLIENT_SRC_IP_ADDRESS:
995 attr = "src_ipaddr";
996 goto vb_to_str;
997
998 case FR_FREERADIUS_CLIENT_REQUIRE_MA:
999 attr = "require_message_authenticator";
1000 goto vb_to_str;
1001
1002 case FR_FREERADIUS_CLIENT_LIMIT_PROXY_STATE:
1003 attr = "limit_proxy_state";
1004 goto vb_to_str;
1005
1006 case FR_FREERADIUS_CLIENT_TRACK_CONNECTIONS:
1007 attr = "track_connections";
1008 goto vb_to_str;
1009
1010 default:
1011 attr = vp->da->name;
1012 fr_sbuff_set_to_start(tmp);
1014 value = fr_sbuff_start(tmp);
1015 v_token = T_SINGLE_QUOTED_STRING;
1016 break;
1017 }
1018
1019 cp = cf_pair_alloc(cs, attr, value, T_OP_SET, T_BARE_WORD, v_token);
1020 if (!cp) {
1021 RERROR("Error creating equivalent conf pair for %s", vp->da->name);
1022 goto error;
1023 }
1024
1025 RDEBUG2("%s = %s", cf_pair_attr(cp), cf_pair_value(cp));
1026 }
1027
1028 REXDENT();
1029
1030 /*
1031 * @todo - allow for setting a DIFFERENT virtual server,
1032 * src IP, protocol, etc. This should all be in TLVs..
1033 */
1034 c = client_afrom_cs(cs, cs, unlang_call_current(request), 0);
1035 if (!c) goto error;
1036
1037 return c;
1038}
1039
1040/** Read a single client from a file
1041 *
1042 * This function supports asynchronous runtime loading of clients.
1043 *
1044 * @param[in] filename To read clients from.
1045 * @param[in] server_cs of virtual server clients should be added to.
1046 * @param[in] check_dns Check reverse lookup of IP address matches filename.
1047 * @return
1048 * - The new client on success.
1049 * - NULL on failure.
1050 */
1051fr_client_t *client_read(char const *filename, CONF_SECTION *server_cs, bool check_dns)
1052{
1053 char const *p;
1054 fr_client_t *c;
1055 CONF_SECTION *cs;
1056 char buffer[256];
1057
1058 if (!filename) return NULL;
1059
1060 cs = cf_section_alloc(NULL, NULL, "main", NULL);
1061 if (!cs) return NULL;
1062
1063 if ((cf_file_read(cs, filename) < 0) || (cf_section_pass2(cs) < 0)) {
1064 talloc_free(cs);
1065 return NULL;
1066 }
1067
1068 cs = cf_section_find(cs, "client", CF_IDENT_ANY);
1069 if (!cs) {
1070 ERROR("No \"client\" section found in client file");
1071 return NULL;
1072 }
1073
1074 c = client_afrom_cs(cs, cs, server_cs, 0);
1075 if (!c) return NULL;
1076 talloc_steal(cs, c);
1077
1078 p = strrchr(filename, FR_DIR_SEP);
1079 if (p) {
1080 p++;
1081 } else {
1082 p = filename;
1083 }
1084
1085 if (!check_dns) return c;
1086
1087 /*
1088 * Additional validations
1089 */
1090 fr_inet_ntoh(&c->ipaddr, buffer, sizeof(buffer));
1091 if (strcmp(p, buffer) != 0) {
1092 ERROR("Invalid client definition in %s: IP address %s does not match name %s", filename, buffer, p);
1093 client_free(c);
1094 return NULL;
1095 }
1096
1097 return c;
1098}
1099
1100/** Search up a list of requests trying to locate one which has a client
1101 *
1102 */
1104{
1105 fr_client_t *client;
1106 request_t *parent = request;
1107
1108 do {
1109 client = parent->client;
1110 } while (!client && (parent = parent->parent));
1111
1112 return client;
1113}
static int const char char buffer[256]
Definition acutest.h:576
#define fr_base16_decode(_err, _out, _in, _no_trailing)
Definition base16.h:95
#define RCSID(id)
Definition build.h:485
#define CMP(_a, _b)
Same as CMP_PREFER_SMALLER use when you don't really care about ordering, you just want an ordering.
Definition build.h:112
#define unlikely(_x)
Definition build.h:383
#define UNUSED
Definition build.h:317
CONF_SECTION * unlang_call_current(request_t *request)
Return the last virtual server that was called.
Definition call.c:225
int cf_file_read(CONF_SECTION *cs, char const *filename)
Definition cf_file.c:3234
int cf_section_pass2(CONF_SECTION *cs)
Definition cf_file.c:767
int cf_section_parse(TALLOC_CTX *ctx, void *base, CONF_SECTION *cs)
Parse a configuration section into user-supplied variables.
Definition cf_parse.c:1154
int cf_table_parse_int(UNUSED TALLOC_CTX *ctx, void *out, UNUSED void *parent, CONF_ITEM *ci, conf_parser_t const *rule)
Generic function for parsing conf pair values as int.
Definition cf_parse.c:1592
#define CONF_PARSER_TERMINATOR
Definition cf_parse.h:658
cf_parse_t func
Override default parsing behaviour for the specified type with a custom parsing function.
Definition cf_parse.h:612
#define FR_CONF_OFFSET(_name, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:284
#define cf_section_rules_push(_cs, _rule)
Definition cf_parse.h:690
#define FR_CONF_POINTER(_name, _type, _flags, _res_p)
conf_parser_t which parses a single CONF_PAIR producing a single global result
Definition cf_parse.h:339
#define FR_CONF_OFFSET_IS_SET(_name, _type, _flags, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct,...
Definition cf_parse.h:298
#define FR_CONF_OFFSET_FLAGS(_name, _flags, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:272
#define FR_TIME_DELTA_BOUND_CHECK(_name, _var, _op, _bound)
Definition cf_parse.h:529
@ CONF_FLAG_SECRET
Only print value if debug level >= 3.
Definition cf_parse.h:438
@ CONF_FLAG_SUBSECTION
Instead of putting the information into a configuration structure, the configuration file routines MA...
Definition cf_parse.h:428
Defines a CONF_PAIR to C data type mapping.
Definition cf_parse.h:595
Common header for all CONF_* types.
Definition cf_priv.h:49
Configuration AVP similar to a fr_pair_t.
Definition cf_priv.h:70
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:101
char const * cf_section_name2(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1184
void * cf_data_value(CONF_DATA const *cd)
Return the user assigned value of CONF_DATA.
Definition cf_util.c:1762
CONF_PAIR * cf_pair_alloc(CONF_SECTION *parent, char const *attr, char const *value, fr_token_t op, fr_token_t lhs_quote, fr_token_t rhs_quote)
Allocate a CONF_PAIR.
Definition cf_util.c:1278
char const * cf_section_name1(CONF_SECTION const *cs)
Return the second identifier of a CONF_SECTION.
Definition cf_util.c:1170
CONF_SECTION * cf_section_find(CONF_SECTION const *cs, char const *name1, char const *name2)
Find a CONF_SECTION with name1 and optionally name2.
Definition cf_util.c:1027
CONF_SECTION * cf_item_to_section(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_SECTION.
Definition cf_util.c:683
CONF_PAIR * cf_pair_find(CONF_SECTION const *cs, char const *attr)
Search for a CONF_PAIR with a specific name.
Definition cf_util.c:1438
fr_token_t cf_pair_operator(CONF_PAIR const *pair)
Return the operator of a pair.
Definition cf_util.c:1607
bool cf_item_is_section(CONF_ITEM const *ci)
Determine if CONF_ITEM is a CONF_SECTION.
Definition cf_util.c:617
CONF_PAIR * cf_item_to_pair(CONF_ITEM const *ci)
Cast a CONF_ITEM to a CONF_PAIR.
Definition cf_util.c:663
CONF_SECTION * cf_section_find_next(CONF_SECTION const *cs, CONF_SECTION const *prev, char const *name1, char const *name2)
Return the next matching section.
Definition cf_util.c:1048
char const * cf_pair_value(CONF_PAIR const *pair)
Return the value of a CONF_PAIR.
Definition cf_util.c:1593
int cf_pair_replace(CONF_SECTION *cs, CONF_PAIR *cp, char const *value)
Replace pair in a given section with a new pair, of the given value.
Definition cf_util.c:1349
CONF_ITEM * cf_pair_to_item(CONF_PAIR const *cp)
Cast a CONF_PAIR to a CONF_ITEM.
Definition cf_util.c:721
char const * cf_pair_attr(CONF_PAIR const *pair)
Return the attr of a CONF_PAIR.
Definition cf_util.c:1577
#define cf_item_add(_parent, _child)
Definition cf_util.h:83
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:289
#define cf_data_add(_cf, _data, _name, _free)
Definition cf_util.h:255
#define cf_data_find(_cf, _type, _name)
Definition cf_util.h:244
#define cf_root(_cf)
Definition cf_util.h:98
#define cf_item_next(_parent, _curr)
Definition cf_util.h:92
#define cf_log_perr(_cf, _fmt,...)
Definition cf_util.h:296
#define cf_section_alloc(_ctx, _parent, _name1, _name2)
Definition cf_util.h:140
#define CF_IDENT_ANY
Definition cf_util.h:78
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
Definition dbuff.h:514
#define MEM(x)
Definition debug.h:36
#define ERROR(fmt,...)
Definition dhcpclient.c:41
static bool fr_dict_attr_is_top_level(fr_dict_attr_t const *da)
Return true if this attribute is parented directly off the dictionary root.
Definition dict.h:767
Test enumeration values.
Definition dict_test.h:92
char const * fr_inet_ntoh(fr_ipaddr_t const *src, char *out, size_t outlen)
Perform reverse resolution of an IP address.
Definition inet.c:356
char * fr_inet_ntop_prefix(char out[static FR_IPADDR_PREFIX_STRLEN], size_t outlen, fr_ipaddr_t const *addr)
Print a fr_ipaddr_t as a CIDR style network prefix.
Definition inet.c:1074
int fr_inet_pton6(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback, bool mask)
Parse an IPv6 address or IPv6 prefix in presentation format (and others)
Definition inet.c:630
int fr_ipaddr_is_inaddr_any(fr_ipaddr_t const *ipaddr)
Determine if an address is the INADDR_ANY address for its address family.
Definition inet.c:63
int8_t fr_ipaddr_cmp(fr_ipaddr_t const *a, fr_ipaddr_t const *b)
Compare two ip addresses.
Definition inet.c:1347
void fr_ipaddr_mask(fr_ipaddr_t *addr, uint8_t prefix)
Zeroes out the host portion of an fr_ipaddr_t.
Definition inet.c:218
uint8_t prefix
Prefix length - Between 0-32 for IPv4 and 0-128 for IPv6.
Definition inet.h:69
int af
Address family.
Definition inet.h:64
union fr_ipaddr_t::@135 addr
#define FR_IPADDR_PREFIX_STRLEN
Like FR_IPADDR_STRLEN but with space for a prefix.
Definition inet.h:93
IPv4/6 prefix.
fr_time_delta_t response_window
How long the client has to respond.
Definition client.h:140
char const * server
Name of the virtual server client is associated with.
Definition client.h:128
fr_ipaddr_t ipaddr
IPv4/IPv6 address of the host.
Definition client.h:83
fr_radius_require_ma_t require_message_authenticator
Require RADIUS message authenticator for incoming packets.
Definition client.h:94
char const * secret
Secret PSK.
Definition client.h:90
fr_ipaddr_t src_ipaddr
IPv4/IPv6 address to send responses from (family must match ipaddr).
Definition client.h:84
int(* client_value_cb_t)(char **out, CONF_PAIR const *cp, void *data)
Callback for retrieving values when building client sections.
Definition client.h:68
int proto
Protocol number.
Definition client.h:142
CONF_SECTION * cs
CONF_SECTION that was parsed to generate the client.
Definition client.h:133
char const * longname
Client identifier.
Definition client.h:87
fr_socket_limit_t limit
Connections per client (TCP clients only).
Definition client.h:143
char const * shortname
Client nickname.
Definition client.h:88
bool use_connected
do we use connected sockets for this client
Definition client.h:120
CONF_SECTION * server_cs
Virtual server that the client is associated with.
Definition client.h:129
Describes a host allowed to send packets to the server.
Definition client.h:80
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:443
#define DEBUG3(_fmt,...)
Definition log.h:266
#define RERROR(fmt,...)
Definition log.h:298
#define RINDENT()
Indent R* messages by one level.
Definition log.h:430
talloc_free(reap)
main_config_t const * main_config
Main server configuration.
Definition main_config.c:58
fr_worker_config_t worker
Worker thread configuration.
Definition main_config.h:61
@ FR_TYPE_IPV6_PREFIX
IPv6 Prefix.
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_COMBO_IP_PREFIX
IPv4 or IPv6 address prefix depending on length.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_IPV4_PREFIX
IPv4 Prefix.
int fr_inet_pton4(fr_ipaddr_t *out, char const *value, ssize_t inlen, bool resolve, bool fallback, bool mask_bits)
unsigned char uint8_t
size_t fr_radius_limit_proxy_state_table_len
Definition base.c:99
size_t fr_radius_require_ma_table_len
Definition base.c:90
fr_table_num_sorted_t const fr_radius_limit_proxy_state_table[]
Definition base.c:92
fr_table_num_sorted_t const fr_radius_require_ma_table[]
Definition base.c:83
#define fr_assert(_expr)
Definition rad_assert.h:38
static char * secret
#define RDEBUG2(fmt,...)
Definition radclient.h:54
#define WARN(fmt,...)
Definition radclient.h:47
void * fr_rb_find(fr_rb_tree_t const *tree, void const *data)
Find an element in the tree, returning the data, not the node.
Definition rb.c:577
bool fr_rb_insert(fr_rb_tree_t *tree, void const *data)
Insert data into a tree.
Definition rb.c:626
bool fr_rb_delete(fr_rb_tree_t *tree, void const *data)
Remove node and free data (if a free function was specified)
Definition rb.c:741
#define fr_rb_inline_talloc_alloc(_ctx, _type, _field, _data_cmp, _data_free)
Allocs a red black that verifies elements are of a specific talloc type.
Definition rb.h:246
The main red black tree structure.
Definition rb.h:73
ssize_t fr_sbuff_in_sprintf(fr_sbuff_t *sbuff, char const *fmt,...)
Print using a fmt string to an sbuff.
Definition sbuff.c:1597
#define fr_sbuff_start(_sbuff_or_marker)
#define FR_SBUFF_IN(_start, _len_or_end)
#define fr_sbuff_current(_sbuff_or_marker)
#define FR_SBUFF_TALLOC_THREAD_LOCAL(_out, _init, _max)
fr_time_delta_t idle_timeout
Definition socket.h:38
fr_time_delta_t lifetime
Definition socket.h:37
fr_client_t * client_afrom_cs(TALLOC_CTX *ctx, CONF_SECTION *cs, CONF_SECTION *server_cs, size_t extra)
Allocate a new client from a config section.
Definition client.c:699
fr_client_t * client_find(fr_client_list_t const *clients, fr_ipaddr_t const *ipaddr, int proto)
Definition client.c:373
#define namecmp(a)
static int8_t client_cmp(void const *one, void const *two)
Definition client.c:65
char const * name
Name of the client list.
Definition client.c:51
fr_client_list_t * client_list_init(CONF_SECTION *cs)
Return a new client list.
Definition client.c:108
fr_client_t * client_findbynumber(UNUSED const fr_client_list_t *clients, UNUSED int number)
Definition client.c:364
fr_rb_tree_t * tree[129]
Definition client.c:58
int client_map_section(CONF_SECTION *out, CONF_SECTION const *map, client_value_cb_t func, void *data)
Create a client CONF_SECTION using a mapping section to map values from a result set to client attrib...
Definition client.c:617
void client_free(fr_client_t *client)
Free a client.
Definition client.c:93
static fr_ipaddr_t cl_ipaddr
Definition client.c:416
fr_client_t * client_from_request(request_t *request)
Search up a list of requests trying to locate one which has a client.
Definition client.c:1103
#define TLS_UNUSED
Create a list of clients from a client section.
Definition client.c:466
static conf_parser_t limit_config[]
Definition client.c:420
fr_client_t * client_read(char const *filename, CONF_SECTION *server_cs, bool check_dns)
Read a single client from a file.
Definition client.c:1051
static char const * cl_srcipaddr
Definition client.c:417
static const conf_parser_t client_config[]
Definition client.c:429
static fr_client_list_t * root_clients
Global client list.
Definition client.c:62
fr_client_t * client_afrom_request(TALLOC_CTX *ctx, request_t *request)
Create a new client, consuming all attributes in the control list of the request.
Definition client.c:921
void client_list_free(void)
Definition client.c:84
fr_client_list_t * client_list_parse_section(CONF_SECTION *section, int proto, TLS_UNUSED bool tls_required)
Definition client.c:469
void client_delete(fr_client_list_t *clients, fr_client_t *client)
Definition client.c:337
bool client_add(fr_client_list_t *clients, fr_client_t *client)
Add a client to a fr_client_list_t.
Definition client.c:182
static char const * hs_proto
Definition client.c:418
Group of clients.
Definition client.c:50
fr_pair_t * vp
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
char * talloc_typed_strdup(TALLOC_CTX *ctx, char const *p)
Call talloc_strdup, setting the type on the new chunk correctly.
Definition talloc.c:467
static int talloc_const_free(void const *ptr)
Free const'd memory.
Definition talloc.h:229
#define fr_time_delta_lt(_a, _b)
Definition time.h:285
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
#define fr_time_delta_wrap(_time)
Definition time.h:152
#define fr_time_delta_ispos(_a)
Definition time.h:290
static fr_time_delta_t fr_time_delta_from_usec(int64_t usec)
Definition time.h:568
enum fr_token fr_token_t
@ T_SINGLE_QUOTED_STRING
Definition token.h:122
@ T_BARE_WORD
Definition token.h:120
@ T_OP_SET
Definition token.h:84
void * fr_trie_remove_by_key(fr_trie_t *ft, void const *key, size_t keylen)
Remove a key and return the associated user ctx.
Definition trie.c:2154
fr_trie_t * fr_trie_alloc(TALLOC_CTX *ctx, fr_trie_key_t get_key, fr_free_t free_data)
Allocate a trie.
Definition trie.c:741
void * fr_trie_lookup_by_key(fr_trie_t const *ft, void const *key, size_t keylen)
Lookup a key in a trie and return user ctx, if any.
Definition trie.c:1262
void * fr_trie_match_by_key(fr_trie_t const *ft, void const *key, size_t keylen)
Match a key and length in a trie and return user ctx, if any.
Definition trie.c:1286
int fr_trie_insert_by_key(fr_trie_t *ft, void const *key, size_t keylen, void const *data)
Insert a key and user ctx into a trie.
Definition trie.c:1875
#define fr_pair_list_foreach(_list_head, _iter)
Iterate over the contents of a fr_pair_list_t.
Definition pair.h:261
ssize_t fr_pair_print_value_quoted(fr_sbuff_t *out, fr_pair_t const *vp, fr_token_t quote)
Print the value of an attribute to a string.
Definition pair_print.c:53
static fr_slen_t parent
Definition pair.h:845
fr_sbuff_escape_rules_t fr_value_escape_single
Definition value.c:387
ssize_t fr_value_box_print(fr_sbuff_t *out, fr_value_box_t const *data, fr_sbuff_escape_rules_t const *e_rules)
Print one boxed value to a string.
Definition value.c:5496
#define fr_box_ipaddr(_val)
Definition value.h:313
static fr_slen_t data
Definition value.h:1288
static size_t char ** out
Definition value.h:1020
virtual_server_t const * virtual_server_find(char const *name)
Return virtual server matching the specified name.
CONF_SECTION * virtual_server_cs(virtual_server_t const *vs)
Return the configuration section for a virtual server.
fr_time_delta_t max_request_time
maximum time a request can be processed
Definition worker.h:67