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: 9658e3f51ebb5764ec5888e31b31ad21e627bc0a $
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: 9658e3f51ebb5764ec5888e31b31ad21e627bc0a $")
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("dedup_authenticator", fr_client_t, dedup_authenticator), .dflt = "yes" },
452
453 { FR_CONF_OFFSET("response_window", fr_client_t, response_window) },
454
455 { FR_CONF_POINTER("proto", FR_TYPE_STRING, 0, &hs_proto) },
456 { FR_CONF_POINTER("limit", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) limit_config },
457
459};
460
461/** Create a list of clients from a client section
462 *
463 * Iterates over all client definitions in the specified section, adding them to a client list.
464 */
465#ifdef WITH_TLS
466#define TLS_UNUSED
467#else
468#define TLS_UNUSED UNUSED
469#endif
470
472{
473 bool global = false;
474 CONF_SECTION *cs = NULL;
475 fr_client_t *c = NULL;
476 fr_client_list_t *clients = NULL;
477 CONF_SECTION *server_cs = NULL;
478
479 /*
480 * Be forgiving. If there's already a clients, return
481 * it. Otherwise create a new one.
482 */
483 clients = cf_data_value(cf_data_find(section, fr_client_list_t, NULL));
484 if (clients) return clients;
485
486 /*
487 * Parent the client list from the section.
488 */
489 clients = client_list_init(section);
490 if (!clients) return NULL;
491
492 /*
493 * If the section is hung off the config root, this is
494 * the global client list, else it's virtual server
495 * specific client list.
496 */
497 if (cf_root(section) == section) global = true;
498
499 if (strcmp("server", cf_section_name1(section)) == 0) server_cs = section;
500
501 /*
502 * Iterate over all the clients in the section, adding
503 * them to the client list.
504 */
505 while ((cs = cf_section_find_next(section, cs, "client", CF_IDENT_ANY))) {
506 /*
507 * Check this before parsing the client.
508 */
509 if (proto) {
510 CONF_PAIR *cp;
511 int client_proto = IPPROTO_UDP;
512
513 cp = cf_pair_find(cs, "proto");
514 if (cp) {
515 char const *value = cf_pair_value(cp);
516
517 if (!value) {
518 cf_log_err(cs, "'proto' field must have a value");
519 talloc_free(clients);
520 return NULL;
521 }
522
523 if (strcmp(value, "udp") == 0) {
524 /* do nothing */
525
526 } else if (strcmp(value, "tcp") == 0) {
527 client_proto = IPPROTO_TCP;
528#ifdef WITH_TLS
529 } else if (strcmp(value, "tls") == 0) {
530 client_proto = IPPROTO_TCP;
531#endif
532 } else if (strcmp(value, "*") == 0) {
533 client_proto = IPPROTO_IP; /* fake for dual */
534 } else {
535 cf_log_err(cs, "Unknown proto \"%s\".", value);
536 talloc_free(clients);
537 return NULL;
538 }
539 }
540
541 /*
542 * We don't have "proto = *", so the
543 * protocol MUST match what the caller
544 * asked for. Otherwise, we ignore the
545 * client.
546 */
547 if ((client_proto != IPPROTO_IP) && (proto != client_proto)) continue;
548 }
549
550
551 c = client_afrom_cs(cs, cs, server_cs, 0);
552 if (!c) {
553 error:
554 client_free(c);
555 talloc_free(clients);
556 return NULL;
557 }
558
559 /*
560 * TCP sockets are always connected.
561 */
562 c->use_connected |= (c->proto == IPPROTO_TCP);
563
564#ifdef WITH_TLS
565 /*
566 * TLS clients CANNOT use non-TLS listeners.
567 * non-TLS clients CANNOT use TLS listeners.
568 */
569 if (tls_required != c->tls_required) {
570 cf_log_err(cs, "Client does not have the same TLS configuration as the listener");
571 goto error;
572 }
573#endif
574
575 if (!client_add(clients, c)) {
576 cf_log_err(cs, "Failed to add client %s", cf_section_name2(cs));
577 goto error;
578 }
579
580 }
581
582 /*
583 * Associate the clients structure with the section.
584 */
585 if (!cf_data_add(section, clients, NULL, false)) {
586 cf_log_err(section, "Failed to associate clients with section %s", cf_section_name1(section));
587 talloc_free(clients);
588 return NULL;
589 }
590
591 /*
592 * Replace the global list of clients with the new one.
593 * The old one is still referenced from the original
594 * configuration, and will be freed when that is freed.
595 */
596 if (global) root_clients = clients;
597
598 return clients;
599}
600
601/** Create a client CONF_SECTION using a mapping section to map values from a result set to client attributes
602 *
603 * If we hit a CONF_SECTION we recurse and process its CONF_PAIRS too.
604 *
605 * @note Caller should free CONF_SECTION passed in as out, on error.
606 * Contents of that section will be in an undefined state.
607 *
608 * @param[in,out] out Section to perform mapping on. Either the root of the client config, or a parent section
609 * (when this function is called recursively).
610 * Should be alloced with cf_section_alloc, or if there's a separate template section, the
611 * result of calling cf_section_dup on that section.
612 * @param[in] map section.
613 * @param[in] func to call to retrieve CONF_PAIR values. Must return a talloced buffer containing the value.
614 * @param[in] data to pass to func, usually a result pointer.
615 * @return
616 * - 0 on success.
617 * - -1 on failure.
618 */
620{
621 CONF_ITEM const *ci;
622
623 for (ci = cf_item_next(map, NULL);
624 ci != NULL;
625 ci = cf_item_next(map, ci)) {
626 CONF_PAIR const *cp;
627 CONF_PAIR *old;
628 char *value;
629 char const *attr;
630
631 /*
632 * Recursively process map subsection
633 */
634 if (cf_item_is_section(ci)) {
635 CONF_SECTION *cs, *cc;
636
637 cs = cf_item_to_section(ci);
638 /*
639 * Use pre-existing section or alloc a new one
640 */
642 if (!cc) {
644 if (!cc) return -1;
645 }
646
647 if (client_map_section(cc, cs, func, data) < 0) return -1;
648 continue;
649 }
650
651 cp = cf_item_to_pair(ci);
652 attr = cf_pair_attr(cp);
653
654 /*
655 * The callback can return 0 (success) and not provide a value
656 * in which case we skip the mapping pair.
657 *
658 * Or return -1 in which case we error out.
659 */
660 if (func(&value, cp, data) < 0) {
661 cf_log_err(out, "Failed performing mapping \"%s\" = \"%s\"", attr, cf_pair_value(cp));
662 return -1;
663 }
664 if (!value) continue;
665
666 /*
667 * Replace an existing CONF_PAIR
668 */
669 old = cf_pair_find(out, attr);
670 if (old) {
673 continue;
674 }
675
676 /*
677 * ...or add a new CONF_PAIR
678 */
680 if (!cp) {
681 cf_log_err(out, "Failed allocing pair \"%s\" = \"%s\"", attr, value);
683 return -1;
684 }
687 }
688
689 return 0;
690}
691
692/** Allocate a new client from a config section
693 *
694 * @param ctx to allocate new clients in.
695 * @param cs to process as a client.
696 * @param server_cs The virtual server that this client belongs to.
697 * @param extra 0 allocate sizeof(fr_client_t) bytes
698 * >sizeof(client_t) number of bytes to allocate
699 * @return new fr_client_t struct.
700 */
701fr_client_t *client_afrom_cs(TALLOC_CTX *ctx, CONF_SECTION *cs, CONF_SECTION *server_cs, size_t extra)
702{
703 fr_client_t *c;
704 char const *name2;
705 CONF_PAIR *cp;
706
707 name2 = cf_section_name2(cs);
708 if (!name2) {
709 cf_log_err(cs, "Missing client name");
710 return NULL;
711 }
712
713 /*
714 * The size is fine.. Let's create the buffer
715 */
716 if (!extra) {
717 c = talloc_zero(ctx, fr_client_t);
718 if (!c) return NULL;
719 } else {
720 fr_assert(extra > sizeof(fr_client_t));
721
722 c = (fr_client_t *) talloc_zero_array(ctx, uint8_t, extra);
723 if (!c) return NULL;
724
725 talloc_set_name_const(c, "fr_client_t");
726 }
727
728 c->cs = cs;
729
730 memset(&cl_ipaddr, 0, sizeof(cl_ipaddr));
731 if (cf_section_rules_push(cs, client_config) < 0) return NULL;
732
733 if (cf_section_parse(c, c, cs) < 0) {
734 cf_log_err(cs, "Error parsing client section");
735 error:
736 client_free(c);
737 hs_proto = NULL;
738 cl_srcipaddr = NULL;
739 return NULL;
740 }
741
742 /*
743 * Allow for binary secrets.
744 */
745 cp = cf_pair_find(cs, "secret");
746 if (cp && (cf_pair_operator(cp) == T_BARE_WORD)) {
747 char const *value;
748
749 value = cf_pair_value(cp);
750 if ((value[0] == '0') && (value[1] == 'x')) {
751 size_t bin_len, hex_len, converted;
752 uint8_t *bin;
753
754 /*
755 * '0x...' plus trailing NUL.
756 */
757 hex_len = talloc_array_length(value) - 3;
758 bin_len = (hex_len / 2) + 1;
759 MEM(bin = talloc_array(c, uint8_t, bin_len));
760 converted = fr_base16_decode(NULL,
761 &FR_DBUFF_TMP(bin, bin_len),
762 &FR_SBUFF_IN(value + 2, hex_len), false);
763 if (converted < (bin_len - 1)) {
764 cf_log_err(cs, "Invalid hex string in shared secret");
765 goto error;
766 }
767
769 c->secret = (char const *) bin;
770 }
771 }
772
773 /*
774 * Find the virtual server for this client.
775 */
776 if (c->server) {
777 virtual_server_t const *vs;
778 if (server_cs) {
779 cf_log_err(cs, "Clients inside of a 'server' section cannot point to a server");
780 goto error;
781 }
782
784 if (!vs) goto error;
785
787 if (!c->server_cs) {
788 cf_log_err(cs, "Failed to find virtual server %s", c->server);
789 goto error;
790 }
791
792 } else if (server_cs) {
793 c->server = cf_section_name2(server_cs);
794 c->server_cs = server_cs;
795
796 } /* else don't set c->server or c->server_cs, we will use listener->server */
797
798 /*
799 * Newer style client definitions with either ipaddr or ipaddr6
800 * config items.
801 */
802 if (cf_pair_find(cs, "ipaddr") || cf_pair_find(cs, "ipv4addr") || cf_pair_find(cs, "ipv6addr")) {
803 char buffer[128];
804
805 /*
806 * Sets ipv4/ipv6 address and prefix.
807 */
808 c->ipaddr = cl_ipaddr;
809
810 /*
811 * Set the long name to be the result of a reverse lookup on the IP address.
812 */
813 fr_inet_ntoh(&c->ipaddr, buffer, sizeof(buffer));
815
816 /*
817 * Set the short name to the name2.
818 */
819 if (!c->shortname) c->shortname = talloc_typed_strdup(c, name2);
820 /*
821 * No "ipaddr" or "ipv6addr", use old-style "client <ipaddr> {" syntax.
822 */
823 } else {
824 cf_log_err(cs, "No 'ipaddr' or 'ipv4addr' or 'ipv6addr' configuration "
825 "directive found in client %s", name2);
826 goto error;
827 }
828
829 c->proto = IPPROTO_UDP;
830 if (hs_proto) {
831 if (strcmp(hs_proto, "udp") == 0) {
832 hs_proto = NULL;
833
834 } else if (strcmp(hs_proto, "tcp") == 0) {
835 hs_proto = NULL;
836 c->proto = IPPROTO_TCP;
837#ifdef WITH_TLS
838 } else if (strcmp(hs_proto, "tls") == 0) {
839 hs_proto = NULL;
840 c->proto = IPPROTO_TCP;
841 c->tls_required = true;
842
843#endif
844 } else if (strcmp(hs_proto, "*") == 0) {
845 hs_proto = NULL;
846 c->proto = IPPROTO_IP; /* fake for dual */
847 } else {
848 cf_log_err(cs, "Unknown proto \"%s\".", hs_proto);
849 goto error;
850 }
851 }
852
853 /*
854 * If a src_ipaddr is specified, when we send the return packet
855 * we will use this address instead of the src from the
856 * request.
857 */
858 if (cl_srcipaddr) {
859 switch (c->ipaddr.af) {
860 case AF_INET:
861 if (fr_inet_pton4(&c->src_ipaddr, cl_srcipaddr, -1, true, false, true) < 0) {
862 cf_log_perr(cs, "Failed parsing src_ipaddr");
863 goto error;
864 }
865 break;
866
867 case AF_INET6:
868 if (fr_inet_pton6(&c->src_ipaddr, cl_srcipaddr, -1, true, false, true) < 0) {
869 cf_log_perr(cs, "Failed parsing src_ipaddr");
870 goto error;
871 }
872 break;
873 default:
874 cf_log_err(cs, "ipaddr was not defined");
875 goto error;
876 }
877 cl_srcipaddr = NULL;
878 } else {
879 c->src_ipaddr.af = c->ipaddr.af; /* leave the rest as IFADDR_ANY */
880 }
881
882 /*
883 * A response_window of zero is OK, and means that it's
884 * ignored by the rest of the server timers.
885 */
887 FR_TIME_DELTA_BOUND_CHECK("response_window", c->response_window, >=, fr_time_delta_from_usec(1000));
890 }
891
892#ifdef WITH_TLS
893 /*
894 * If the client is TLS only, the secret can be
895 * omitted. When omitted, it's hard-coded to
896 * "radsec". See RFC 6614.
897 */
898 if (c->tls_required) {
899 c->secret = talloc_typed_strdup(cs, "radsec");
900 }
901#endif
902
903 if ((c->proto == IPPROTO_TCP) || (c->proto == IPPROTO_IP)) {
910 }
911
912 return c;
913}
914
915/** Create a new client, consuming all attributes in the control list of the request
916 *
917 * @param ctx the talloc context
918 * @param request containing the client attributes.
919 * @return
920 * - New client on success.
921 * - NULL on error.
922 */
923fr_client_t *client_afrom_request(TALLOC_CTX *ctx, request_t *request)
924{
925 static int cnt;
926 CONF_SECTION *cs;
927 fr_client_t *c;
928 fr_sbuff_t *tmp;
929
930 if (!request) return NULL;
931
932 FR_SBUFF_TALLOC_THREAD_LOCAL(&tmp, 128, SIZE_MAX);
933
934 if (unlikely(fr_sbuff_in_sprintf(tmp, "dynamic_%i_", cnt++) <= 0)) {
935 name_error:
936 RERROR("Failed to generate dynamic client name");
937 return NULL;
938 }
939 if (unlikely(fr_value_box_print(tmp, fr_box_ipaddr(request->packet->socket.inet.src_ipaddr), NULL) <= 0)) goto name_error;
940 fr_sbuff_set_to_start(tmp);
941
942 cs = cf_section_alloc(ctx, NULL, "client", fr_sbuff_current(tmp));
943
944 RDEBUG2("Converting control.FreeRADIUS-Client-* to client {...} section");
945 RINDENT();
946
947 fr_pair_list_foreach(&request->control_pairs, vp) {
948 CONF_PAIR *cp = NULL;
949 char const *value;
950 char const *attr;
951 fr_token_t v_token = T_BARE_WORD;
952
953 if (!fr_dict_attr_is_top_level(vp->da)) continue;
954
955 switch (vp->da->attr) {
956 case FR_FREERADIUS_CLIENT_IP_ADDRESS:
957 attr = "ipv4addr";
958 vb_to_str:
959 fr_sbuff_set_to_start(tmp);
961 RERROR("Failed to convert %pP to string", vp);
962 error:
963 talloc_free(cs);
964 return NULL;
965 }
966 value = fr_sbuff_start(tmp);
967 break;
968
969 case FR_FREERADIUS_CLIENT_IP_PREFIX:
970 attr = "ipv4addr";
971 goto vb_to_str;
972
973 case FR_FREERADIUS_CLIENT_IPV6_ADDRESS:
974 attr = "ipv6addr";
975 goto vb_to_str;
976
977 case FR_FREERADIUS_CLIENT_IPV6_PREFIX:
978 attr = "ipv6addr";
979 goto vb_to_str;
980
981 case FR_FREERADIUS_CLIENT_SECRET:
982 attr = "secret";
983 value = vp->vp_strvalue;
984 break;
985
986 case FR_FREERADIUS_CLIENT_NAS_TYPE:
987 attr = "nas_type";
988 value = vp->vp_strvalue;
989 break;
990
991 case FR_FREERADIUS_CLIENT_SHORTNAME:
992 attr = "shortname";
993 value = vp->vp_strvalue;
994 break;
995
996 case FR_FREERADIUS_CLIENT_SRC_IP_ADDRESS:
997 attr = "src_ipaddr";
998 goto vb_to_str;
999
1000 case FR_FREERADIUS_CLIENT_REQUIRE_MA:
1001 attr = "require_message_authenticator";
1002 goto vb_to_str;
1003
1004 case FR_FREERADIUS_CLIENT_LIMIT_PROXY_STATE:
1005 attr = "limit_proxy_state";
1006 goto vb_to_str;
1007
1008 case FR_FREERADIUS_CLIENT_TRACK_CONNECTIONS:
1009 attr = "track_connections";
1010 goto vb_to_str;
1011
1012 default:
1013 attr = vp->da->name;
1014 fr_sbuff_set_to_start(tmp);
1016 value = fr_sbuff_start(tmp);
1017 v_token = T_SINGLE_QUOTED_STRING;
1018 break;
1019 }
1020
1021 cp = cf_pair_alloc(cs, attr, value, T_OP_SET, T_BARE_WORD, v_token);
1022 if (!cp) {
1023 RERROR("Error creating equivalent conf pair for %s", vp->da->name);
1024 goto error;
1025 }
1026
1027 RDEBUG2("%s = %s", cf_pair_attr(cp), cf_pair_value(cp));
1028 }
1029
1030 REXDENT();
1031
1032 /*
1033 * @todo - allow for setting a DIFFERENT virtual server,
1034 * src IP, protocol, etc. This should all be in TLVs..
1035 */
1036 c = client_afrom_cs(cs, cs, unlang_call_current(request), 0);
1037 if (!c) goto error;
1038
1039 return c;
1040}
1041
1042/** Read a single client from a file
1043 *
1044 * This function supports asynchronous runtime loading of clients.
1045 *
1046 * @param[in] filename To read clients from.
1047 * @param[in] server_cs of virtual server clients should be added to.
1048 * @param[in] check_dns Check reverse lookup of IP address matches filename.
1049 * @return
1050 * - The new client on success.
1051 * - NULL on failure.
1052 */
1053fr_client_t *client_read(char const *filename, CONF_SECTION *server_cs, bool check_dns)
1054{
1055 char const *p;
1056 fr_client_t *c;
1057 CONF_SECTION *cs;
1058 char buffer[256];
1059
1060 if (!filename) return NULL;
1061
1062 cs = cf_section_alloc(NULL, NULL, "main", NULL);
1063 if (!cs) return NULL;
1064
1065 if ((cf_file_read(cs, filename) < 0) || (cf_section_pass2(cs) < 0)) {
1066 talloc_free(cs);
1067 return NULL;
1068 }
1069
1070 cs = cf_section_find(cs, "client", CF_IDENT_ANY);
1071 if (!cs) {
1072 ERROR("No \"client\" section found in client file");
1073 return NULL;
1074 }
1075
1076 c = client_afrom_cs(cs, cs, server_cs, 0);
1077 if (!c) return NULL;
1078 talloc_steal(cs, c);
1079
1080 p = strrchr(filename, FR_DIR_SEP);
1081 if (p) {
1082 p++;
1083 } else {
1084 p = filename;
1085 }
1086
1087 if (!check_dns) return c;
1088
1089 /*
1090 * Additional validations
1091 */
1092 fr_inet_ntoh(&c->ipaddr, buffer, sizeof(buffer));
1093 if (strcmp(p, buffer) != 0) {
1094 ERROR("Invalid client definition in %s: IP address %s does not match name %s", filename, buffer, p);
1095 client_free(c);
1096 return NULL;
1097 }
1098
1099 return c;
1100}
1101
1102/** Search up a list of requests trying to locate one which has a client
1103 *
1104 */
1106{
1107 fr_client_t *client;
1108 request_t *parent = request;
1109
1110 do {
1111 client = parent->client;
1112 } while (!client && (parent = parent->parent));
1113
1114 return client;
1115}
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:3514
int cf_section_pass2(CONF_SECTION *cs)
Definition cf_file.c:750
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:766
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:355
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:1073
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:629
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:62
int8_t fr_ipaddr_cmp(fr_ipaddr_t const *a, fr_ipaddr_t const *b)
Compare two ip addresses.
Definition inet.c:1346
void fr_ipaddr_mask(fr_ipaddr_t *addr, uint8_t prefix)
Zeroes out the host portion of an fr_ipaddr_t.
Definition inet.c:217
uint8_t prefix
Prefix length - Between 0-32 for IPv4 and 0-128 for IPv6.
Definition inet.h:69
union fr_ipaddr_t::@133 addr
int af
Address family.
Definition inet.h:64
#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:141
char const * server
Name of the virtual server client is associated with.
Definition client.h:129
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:143
CONF_SECTION * cs
CONF_SECTION that was parsed to generate the client.
Definition client.h:134
char const * longname
Client identifier.
Definition client.h:87
fr_socket_limit_t limit
Connections per client (TCP clients only).
Definition client.h:144
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:130
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:701
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:619
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:1105
#define TLS_UNUSED
Create a list of clients from a client section.
Definition client.c:468
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:1053
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:923
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:471
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:441
static int talloc_const_free(void const *ptr)
Free const'd memory.
Definition talloc.h:224
#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:2153
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:740
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:1261
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:1285
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:1874
#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:5487
#define fr_box_ipaddr(_val)
Definition value.h:305
static fr_slen_t data
Definition value.h:1274
static size_t char ** out
Definition value.h:1012
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