2 * client.c Read clients into memory.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * Copyright 2000,2006 The FreeRADIUS server project
21 * Copyright 2000 Miquel van Smoorenburg <miquels@cistron.nl>
22 * Copyright 2000 Alan DeKok <aland@ox.org>
25 #include <freeradius-devel/ident.h>
28 #include <freeradius-devel/radiusd.h>
29 #include <freeradius-devel/rad_assert.h>
36 #ifdef WITH_DYNAMIC_CLIENTS
42 struct radclient_list {
44 * FIXME: One set of trees for IPv4, and another for IPv6?
46 rbtree_t *trees[129]; /* for 0..128, inclusive. */
52 static rbtree_t *tree_num = NULL; /* client numbers 0..N */
53 static int tree_num_max = 0;
55 static RADCLIENT_LIST *root_clients = NULL;
57 #ifdef WITH_DYNAMIC_CLIENTS
58 static fr_fifo_t *deleted_clients = NULL;
62 * Callback for freeing a client.
64 void client_free(RADCLIENT *client)
66 #ifdef WITH_DYNAMIC_CLIENTS
67 if (client->dynamic == 2) {
70 if (!deleted_clients) {
71 deleted_clients = fr_fifo_create(1024,
72 (void *) client_free);
73 if (!deleted_clients) return; /* MEMLEAK */
77 * Mark it as in the fifo, and remember when we
81 client->created = now = time(NULL); /* re-set it */
82 fr_fifo_push(deleted_clients, client);
85 * Peek at the head of the fifo. If it might
86 * still be in use, return. Otherwise, pop it
87 * from the queue and delete it.
89 client = fr_fifo_peek(deleted_clients);
90 if ((client->created + 120) >= now) return;
92 client = fr_fifo_pop(deleted_clients);
93 rad_assert(client != NULL);
97 free(client->longname);
99 free(client->shortname);
100 free(client->nastype);
102 free(client->password);
103 free(client->server);
107 #ifdef WITH_ACCOUNTING
112 #ifdef WITH_DYNAMIC_CLIENTS
113 free(client->client_server);
120 * Callback for comparing two clients.
122 static int client_ipaddr_cmp(const void *one, const void *two)
124 const RADCLIENT *a = one;
125 const RADCLIENT *b = two;
128 return fr_ipaddr_cmp(&a->ipaddr, &b->ipaddr);
132 rcode = fr_ipaddr_cmp(&a->ipaddr, &b->ipaddr);
133 if (rcode != 0) return rcode;
138 if ((a->proto == IPPROTO_IP) ||
139 (b->proto == IPPROTO_IP)) return 0;
141 return (a->proto - b->proto);
146 static int client_num_cmp(const void *one, const void *two)
148 const RADCLIENT *a = one;
149 const RADCLIENT *b = two;
151 return (a->number - b->number);
156 * Free a RADCLIENT list.
158 void clients_free(RADCLIENT_LIST *clients)
162 if (!clients) return;
164 for (i = 0; i <= 128; i++) {
165 if (clients->trees[i]) rbtree_free(clients->trees[i]);
166 clients->trees[i] = NULL;
169 if (clients == root_clients) {
171 if (tree_num) rbtree_free(tree_num);
178 #ifdef WITH_DYNAMIC_CLIENTS
180 * FIXME: No fr_fifo_delete()
188 * Return a new, initialized, set of clients.
190 RADCLIENT_LIST *clients_init(void)
192 RADCLIENT_LIST *clients = calloc(1, sizeof(RADCLIENT_LIST));
194 if (!clients) return NULL;
196 clients->min_prefix = 128;
203 * Sanity check a client.
205 static int client_sane(RADCLIENT *client)
207 switch (client->ipaddr.af) {
209 if (client->prefix > 32) {
214 * Zero out the subnet bits.
216 if (client->prefix == 0) {
217 memset(&client->ipaddr.ipaddr.ip4addr, 0,
218 sizeof(client->ipaddr.ipaddr.ip4addr));
220 } else if (client->prefix < 32) {
223 mask <<= (32 - client->prefix);
224 client->ipaddr.ipaddr.ip4addr.s_addr &= htonl(mask);
229 if (client->prefix > 128) return 0;
231 if (client->prefix == 0) {
232 memset(&client->ipaddr.ipaddr.ip6addr, 0,
233 sizeof(client->ipaddr.ipaddr.ip6addr));
235 } else if (client->prefix < 128) {
237 uint32_t mask, *addr;
239 addr = (uint32_t *) &client->ipaddr.ipaddr.ip6addr;
241 for (i = client->prefix; i < 128; i += 32) {
243 mask <<= ((128 - i) & 0x1f);
244 addr[i / 32] &= mask;
258 * Add a client to the tree.
260 int client_add(RADCLIENT_LIST *clients, RADCLIENT *client)
269 * If "clients" is NULL, it means add to the global list.
273 * Initialize it, if not done already.
276 root_clients = clients_init();
277 if (!root_clients) return 0;
279 clients = root_clients;
282 if ((client->prefix < 0) || (client->prefix > 128)) {
286 if (!client_sane(client)) return 0;
289 * Create a tree for it.
291 if (!clients->trees[client->prefix]) {
292 clients->trees[client->prefix] = rbtree_create(client_ipaddr_cmp,
293 (void *) client_free, 0);
294 if (!clients->trees[client->prefix]) {
299 #define namecmp(a) ((!old->a && !client->a) || (old->a && client->a && (strcmp(old->a, client->a) == 0)))
302 * Cannot insert the same client twice.
304 old = rbtree_finddata(clients->trees[client->prefix], client);
307 * If it's a complete duplicate, then free the new
308 * one, and return "OK".
310 if ((fr_ipaddr_cmp(&old->ipaddr, &client->ipaddr) == 0) &&
311 (old->prefix == client->prefix) &&
312 namecmp(longname) && namecmp(secret) &&
313 namecmp(shortname) && namecmp(nastype) &&
314 namecmp(login) && namecmp(password) && namecmp(server) &&
315 #ifdef WITH_DYNAMIC_CLIENTS
316 (old->lifetime == client->lifetime) &&
317 namecmp(client_server) &&
321 (old->coa_server == client->coa_server) &&
322 (old->coa_pool == client->coa_pool) &&
324 (old->message_authenticator == client->message_authenticator)) {
325 DEBUG("WARNING: Ignoring duplicate client %s", client->longname);
330 radlog(L_ERR, "Failed to add duplicate client %s",
337 * Other error adding client: likely is fatal.
339 if (!rbtree_insert(clients->trees[client->prefix], client)) {
345 tree_num = rbtree_create(client_num_cmp, NULL, 0);
350 * Catch clients added by rlm_sql.
353 client->auth = rad_malloc(sizeof(*client->auth));
354 memset(client->auth, 0, sizeof(*client->auth));
357 #ifdef WITH_ACCOUNTING
359 client->acct = rad_malloc(sizeof(*client->acct));
360 memset(client->acct, 0, sizeof(*client->acct));
364 #ifdef WITH_DYNAMIC_CLIENTS
366 * More catching of clients added by rlm_sql.
368 * The sql modules sets the dynamic flag BEFORE calling
369 * us. The client_create() function sets it AFTER
372 if (client->dynamic && (client->lifetime == 0)) {
376 * If there IS an enclosing network,
377 * inherit the lifetime from it.
379 network = client_find(clients, &client->ipaddr
385 client->lifetime = network->lifetime;
390 client->number = tree_num_max;
392 if (tree_num) rbtree_insert(tree_num, client);
395 if (client->prefix < clients->min_prefix) {
396 clients->min_prefix = client->prefix;
403 #ifdef WITH_DYNAMIC_CLIENTS
404 void client_delete(RADCLIENT_LIST *clients, RADCLIENT *client)
406 if (!clients || !client) return;
408 rad_assert((client->prefix >= 0) && (client->prefix <= 128));
410 client->dynamic = 2; /* signal to client_free */
412 rbtree_deletebydata(tree_num, client);
413 rbtree_deletebydata(clients->trees[client->prefix], client);
419 * Find a client in the RADCLIENTS list by number.
420 * This is a support function for the statistics code.
422 RADCLIENT *client_findbynumber(const RADCLIENT_LIST *clients,
426 if (!clients) clients = root_clients;
428 if (!clients) return NULL;
430 if (number >= tree_num_max) return NULL;
435 myclient.number = number;
437 return rbtree_finddata(tree_num, &myclient);
440 clients = clients; /* -Wunused */
441 number = number; /* -Wunused */
448 * Find a client in the RADCLIENTS list.
450 RADCLIENT *client_find(const RADCLIENT_LIST *clients,
451 const fr_ipaddr_t *ipaddr
460 if (!clients) clients = root_clients;
462 if (!clients || !ipaddr) return NULL;
464 switch (ipaddr->af) {
477 for (i = max_prefix; i >= clients->min_prefix; i--) {
481 myclient.ipaddr = *ipaddr;
483 myclient.proto = proto;
485 client_sane(&myclient); /* clean up the ipaddress */
487 if (!clients->trees[i]) continue;
489 data = rbtree_finddata(clients->trees[i], &myclient);
500 * Old wrapper for client_find
502 RADCLIENT *client_find_old(const fr_ipaddr_t *ipaddr)
504 return client_find(root_clients, ipaddr, IPPROTO_UDP);
507 static struct in_addr cl_ip4addr;
508 static struct in6_addr cl_ip6addr;
510 static char *hs_proto = NULL;
513 static const CONF_PARSER client_config[] = {
514 { "ipaddr", PW_TYPE_IPADDR,
515 0, &cl_ip4addr, NULL },
516 { "ipv6addr", PW_TYPE_IPV6ADDR,
517 0, &cl_ip6addr, NULL },
518 { "netmask", PW_TYPE_INTEGER,
519 offsetof(RADCLIENT, prefix), 0, NULL },
521 { "require_message_authenticator", PW_TYPE_BOOLEAN,
522 offsetof(RADCLIENT, message_authenticator), 0, "no" },
524 { "secret", PW_TYPE_STRING_PTR,
525 offsetof(RADCLIENT, secret), 0, NULL },
526 { "shortname", PW_TYPE_STRING_PTR,
527 offsetof(RADCLIENT, shortname), 0, NULL },
528 { "nastype", PW_TYPE_STRING_PTR,
529 offsetof(RADCLIENT, nastype), 0, NULL },
530 { "login", PW_TYPE_STRING_PTR,
531 offsetof(RADCLIENT, login), 0, NULL },
532 { "password", PW_TYPE_STRING_PTR,
533 offsetof(RADCLIENT, password), 0, NULL },
534 { "virtual_server", PW_TYPE_STRING_PTR,
535 offsetof(RADCLIENT, server), 0, NULL },
536 { "server", PW_TYPE_STRING_PTR, /* compatability with 2.0-pre */
537 offsetof(RADCLIENT, server), 0, NULL },
540 { "proto", PW_TYPE_STRING_PTR,
541 0, &hs_proto, NULL },
542 { "max_connections", PW_TYPE_INTEGER,
543 offsetof(RADCLIENT, max_connections), 0, "16" },
546 #ifdef WITH_DYNAMIC_CLIENTS
547 { "dynamic_clients", PW_TYPE_STRING_PTR,
548 offsetof(RADCLIENT, client_server), 0, NULL },
549 { "lifetime", PW_TYPE_INTEGER,
550 offsetof(RADCLIENT, lifetime), 0, NULL },
554 { "coa_server", PW_TYPE_STRING_PTR,
555 offsetof(RADCLIENT, coa_name), 0, NULL },
558 { NULL, -1, 0, NULL, NULL }
562 static RADCLIENT *client_parse(CONF_SECTION *cs, int in_server)
567 name2 = cf_section_name2(cs);
569 cf_log_err(cf_sectiontoitem(cs),
570 "Missing client name");
575 * The size is fine.. Let's create the buffer
577 c = rad_malloc(sizeof(*c));
578 memset(c, 0, sizeof(*c));
582 c->auth = rad_malloc(sizeof(*c->auth));
583 memset(c->auth, 0, sizeof(*c->auth));
585 #ifdef WITH_ACCOUNTING
586 c->acct = rad_malloc(sizeof(*c->acct));
587 memset(c->acct, 0, sizeof(*c->acct));
591 memset(&cl_ip4addr, 0, sizeof(cl_ip4addr));
592 memset(&cl_ip6addr, 0, sizeof(cl_ip6addr));
595 if (cf_section_parse(cs, c, client_config) < 0) {
596 cf_log_err(cf_sectiontoitem(cs),
597 "Error parsing client section.");
609 * Global clients can set servers to use,
610 * per-server clients cannot.
612 if (in_server && c->server) {
613 cf_log_err(cf_sectiontoitem(cs),
614 "Clients inside of an server section cannot point to a server.");
619 * No "ipaddr" or "ipv6addr", use old-style
620 * "client <ipaddr> {" syntax.
622 if (!cf_pair_find(cs, "ipaddr") &&
623 !cf_pair_find(cs, "ipv6addr")) {
626 prefix_ptr = strchr(name2, '/');
632 c->prefix = atoi(prefix_ptr + 1);
633 if ((c->prefix < 0) || (c->prefix > 128)) {
634 cf_log_err(cf_sectiontoitem(cs),
635 "Invalid Prefix value '%s' for IP.",
639 /* Replace '/' with '\0' */
644 * Always get the numeric representation of IP
646 if (ip_hton(name2, AF_UNSPEC, &c->ipaddr) < 0) {
647 cf_log_err(cf_sectiontoitem(cs),
648 "Failed to look up hostname %s: %s",
649 name2, fr_strerror());
653 if (prefix_ptr) *prefix_ptr = '/';
654 c->longname = strdup(name2);
656 if (!c->shortname) c->shortname = strdup(c->longname);
662 * Figure out which one to use.
664 if (cf_pair_find(cs, "ipaddr")) {
665 c->ipaddr.af = AF_INET;
666 c->ipaddr.ipaddr.ip4addr = cl_ip4addr;
668 if ((c->prefix < -1) || (c->prefix > 32)) {
669 cf_log_err(cf_sectiontoitem(cs),
670 "Netmask must be between 0 and 32");
674 } else if (cf_pair_find(cs, "ipv6addr")) {
675 c->ipaddr.af = AF_INET6;
676 c->ipaddr.ipaddr.ip6addr = cl_ip6addr;
678 if ((c->prefix < -1) || (c->prefix > 128)) {
679 cf_log_err(cf_sectiontoitem(cs),
680 "Netmask must be between 0 and 128");
684 cf_log_err(cf_sectiontoitem(cs),
685 "No IP address defined for the client");
689 ip_ntoh(&c->ipaddr, buffer, sizeof(buffer));
690 c->longname = strdup(buffer);
693 * Set the short name to the name2
695 if (!c->shortname) c->shortname = strdup(name2);
698 c->proto = IPPROTO_UDP;
700 if (strcmp(hs_proto, "udp") == 0) {
704 } else if (strcmp(hs_proto, "tcp") == 0) {
707 c->proto = IPPROTO_TCP;
709 } else if (strcmp(hs_proto, "*") == 0) {
712 c->proto = IPPROTO_IP; /* fake for dual */
715 cf_log_err(cf_sectiontoitem(cs),
716 "Unknown proto \"%s\".", hs_proto);
723 if (c->prefix < 0) switch (c->ipaddr.af) {
734 #ifdef WITH_DYNAMIC_CLIENTS
735 if (c->client_server) {
737 c->secret = strdup("testing123");
739 if (((c->ipaddr.af == AF_INET) &&
740 (c->prefix == 32)) ||
741 ((c->ipaddr.af == AF_INET6) &&
742 (c->prefix == 128))) {
743 cf_log_err(cf_sectiontoitem(cs),
744 "Dynamic clients MUST be a network, not a single IP address.");
752 if (!c->secret || !*c->secret) {
754 const char *value = NULL;
755 CONF_PAIR *cp = cf_pair_find(cs, "dhcp");
757 if (cp) value = cf_pair_value(cp);
760 * Secrets aren't needed for DHCP.
762 if (value && (strcmp(value, "yes") == 0)) return c;
765 cf_log_err(cf_sectiontoitem(cs),
766 "secret must be at least 1 character long");
772 * Point the client to the home server pool, OR to the
773 * home server. This gets around the problem of figuring
774 * out which port to use.
777 c->coa_pool = home_pool_byname(c->coa_name, HOME_TYPE_COA);
779 c->coa_server = home_server_byname(c->coa_name,
782 if (!c->coa_pool && !c->coa_server) {
783 cf_log_err(cf_sectiontoitem(cs), "No such home_server or home_server_pool \"%s\"", c->coa_name);
794 * Create the linked list of clients from the new configuration
795 * type. This way we don't have to change too much in the other
798 RADCLIENT_LIST *clients_parse_section(CONF_SECTION *section)
800 int global = FALSE, in_server = FALSE;
803 RADCLIENT_LIST *clients;
806 * Be forgiving. If there's already a clients, return
807 * it. Otherwise create a new one.
809 clients = cf_data_find(section, "clients");
810 if (clients) return clients;
812 clients = clients_init();
813 if (!clients) return NULL;
815 if (cf_top_section(section) == section) global = TRUE;
817 if (strcmp("server", cf_section_name1(section)) == 0) in_server = TRUE;
820 * Associate the clients structure with the section, where
821 * it will be freed once the section is freed.
823 if (cf_data_add(section, "clients", clients, (void *) clients_free) < 0) {
824 cf_log_err(cf_sectiontoitem(section),
825 "Failed to associate clients with section %s",
826 cf_section_name1(section));
827 clients_free(clients);
831 for (cs = cf_subsection_find_next(section, NULL, "client");
833 cs = cf_subsection_find_next(section, cs, "client")) {
834 c = client_parse(cs, in_server);
840 * FIXME: Add the client as data via cf_data_add,
841 * for migration issues.
844 #ifdef WITH_DYNAMIC_CLIENTS
846 if (c->client_server) {
851 struct stat stat_buf;
855 * Find the directory where individual
856 * client definitions are stored.
858 cp = cf_pair_find(cs, "directory");
859 if (!cp) goto add_client;
861 value = cf_pair_value(cp);
863 cf_log_err(cf_sectiontoitem(cs),
864 "The \"directory\" entry must not be empty");
869 DEBUG("including dynamic clients in %s", value);
871 dir = opendir(value);
873 cf_log_err(cf_sectiontoitem(cs), "Error reading directory %s: %s", value, strerror(errno));
879 * Read the directory, ignoring "." files.
881 while ((dp = readdir(dir)) != NULL) {
885 if (dp->d_name[0] == '.') continue;
888 * Check for valid characters
890 for (p = dp->d_name; *p != '\0'; p++) {
891 if (isalpha((int)*p) ||
894 (*p == '.')) continue;
897 if (*p != '\0') continue;
899 snprintf(buf2, sizeof(buf2), "%s/%s",
902 if ((stat(buf2, &stat_buf) != 0) ||
903 S_ISDIR(stat_buf.st_mode)) continue;
905 dc = client_read(buf2, in_server, TRUE);
907 cf_log_err(cf_sectiontoitem(cs),
908 "Failed reading client file \"%s\"", buf2);
914 * Validate, and add to the list.
916 if (!client_validate(clients, c, dc)) {
921 } /* loop over the directory */
923 #endif /* HAVE_DIRENT_H */
924 #endif /* WITH_DYNAMIC_CLIENTS */
927 if (!client_add(clients, c)) {
928 cf_log_err(cf_sectiontoitem(cs),
929 "Failed to add client %s",
930 cf_section_name2(cs));
938 * Replace the global list of clients with the new one.
939 * The old one is still referenced from the original
940 * configuration, and will be freed when that is freed.
943 root_clients = clients;
949 #ifdef WITH_DYNAMIC_CLIENTS
951 * We overload this structure a lot.
953 static const CONF_PARSER dynamic_config[] = {
954 { "FreeRADIUS-Client-IP-Address", PW_TYPE_IPADDR,
955 offsetof(RADCLIENT, ipaddr), 0, NULL },
956 { "FreeRADIUS-Client-IPv6-Address", PW_TYPE_IPV6ADDR,
957 offsetof(RADCLIENT, ipaddr), 0, NULL },
959 { "FreeRADIUS-Client-Require-MA", PW_TYPE_BOOLEAN,
960 offsetof(RADCLIENT, message_authenticator), NULL, NULL },
962 { "FreeRADIUS-Client-Secret", PW_TYPE_STRING_PTR,
963 offsetof(RADCLIENT, secret), 0, "" },
964 { "FreeRADIUS-Client-Shortname", PW_TYPE_STRING_PTR,
965 offsetof(RADCLIENT, shortname), 0, "" },
966 { "FreeRADIUS-Client-NAS-Type", PW_TYPE_STRING_PTR,
967 offsetof(RADCLIENT, nastype), 0, NULL },
968 { "FreeRADIUS-Client-Virtual-Server", PW_TYPE_STRING_PTR,
969 offsetof(RADCLIENT, server), 0, NULL },
971 { NULL, -1, 0, NULL, NULL }
975 int client_validate(RADCLIENT_LIST *clients, RADCLIENT *master, RADCLIENT *c)
980 * No virtual server defined. Inherit the parent's
983 if (master->server && !c->server) {
984 c->server = strdup(master->server);
988 * If the client network isn't global (not tied to a
989 * virtual server), then ensure that this clients server
990 * is the same as the enclosing networks virtual server.
992 if (master->server &&
993 (strcmp(master->server, c->server) != 0)) {
994 DEBUG("- Cannot add client %s: Virtual server %s is not the same as the virtual server for the network.",
996 buffer, sizeof(buffer)),
1002 if (!client_add(clients, c)) {
1003 DEBUG("- Cannot add client %s: Internal error",
1005 buffer, sizeof(buffer)));
1011 * Initialize the remaining fields.
1014 c->lifetime = master->lifetime;
1015 c->created = time(NULL);
1016 c->longname = strdup(c->shortname);
1018 DEBUG("- Added client %s with shared secret %s",
1019 ip_ntoh(&c->ipaddr, buffer, sizeof(buffer)),
1030 RADCLIENT *client_create(RADCLIENT_LIST *clients, REQUEST *request)
1037 if (!clients || !request) return NULL;
1039 c = rad_malloc(sizeof(*c));
1040 memset(c, 0, sizeof(*c));
1041 c->cs = request->client->cs;
1042 c->ipaddr.af = AF_UNSPEC;
1044 for (i = 0; dynamic_config[i].name != NULL; i++) {
1048 da = dict_attrbyname(dynamic_config[i].name);
1050 DEBUG("- Cannot add client %s: attribute \"%s\"is not in the dictionary",
1051 ip_ntoh(&request->packet->src_ipaddr,
1052 buffer, sizeof(buffer)),
1053 dynamic_config[i].name);
1059 vp = pairfind(request->config_items, da->attr);
1062 * Not required. Skip it.
1064 if (!dynamic_config[i].dflt) continue;
1066 DEBUG("- Cannot add client %s: Required attribute \"%s\" is missing.",
1067 ip_ntoh(&request->packet->src_ipaddr,
1068 buffer, sizeof(buffer)),
1069 dynamic_config[i].name);
1073 switch (dynamic_config[i].type) {
1074 case PW_TYPE_IPADDR:
1075 c->ipaddr.af = AF_INET;
1076 c->ipaddr.ipaddr.ip4addr.s_addr = vp->vp_ipaddr;
1080 case PW_TYPE_IPV6ADDR:
1081 c->ipaddr.af = AF_INET6;
1082 c->ipaddr.ipaddr.ip6addr = vp->vp_ipv6addr;
1086 case PW_TYPE_STRING_PTR:
1087 p = (char **) ((char *) c + dynamic_config[i].offset);
1089 *p = strdup(vp->vp_strvalue);
1092 case PW_TYPE_BOOLEAN:
1093 pi = (int *) ((char *) c + dynamic_config[i].offset);
1094 *pi = vp->vp_integer;
1102 if (c->ipaddr.af == AF_UNSPEC) {
1103 DEBUG("- Cannot add client %s: No IP address was specified.",
1104 ip_ntoh(&request->packet->src_ipaddr,
1105 buffer, sizeof(buffer)));
1110 if (fr_ipaddr_cmp(&request->packet->src_ipaddr, &c->ipaddr) != 0) {
1113 DEBUG("- Cannot add client %s: IP address %s do not match",
1114 ip_ntoh(&request->packet->src_ipaddr,
1115 buffer, sizeof(buffer)),
1117 buf2, sizeof(buf2)));
1121 if (!client_validate(clients, request->client, c)) {
1129 * Read a client definition from the given filename.
1131 RADCLIENT *client_read(const char *filename, int in_server, int flag)
1138 if (!filename) return NULL;
1140 cs = cf_file_read(filename);
1141 if (!cs) return NULL;
1143 c = client_parse(cf_section_sub_find(cs, "client"), in_server);
1145 p = strrchr(filename, FR_DIR_SEP);
1152 if (!flag) return c;
1155 * Additional validations
1157 ip_ntoh(&c->ipaddr, buffer, sizeof(buffer));
1158 if (strcmp(p, buffer) != 0) {
1159 DEBUG("Invalid client definition in %s: IP address %s does not match name %s", filename, buffer, p);