No empty .Rs/.Re
[netbsd-mini2440.git] / crypto / dist / heimdal / lib / krb5 / krbhst.c
blob5f7ec322f2d1e1cb594c0be1b52e5397ea1969c4
1 /*
2 * Copyright (c) 2001 - 2003 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
34 #include "krb5_locl.h"
35 #include <resolve.h>
36 #include "locate_plugin.h"
38 __RCSID("$Heimdal: krbhst.c 21457 2007-07-10 12:53:25Z lha $"
39 "$NetBSD$");
41 static int
42 string_to_proto(const char *string)
44 if(strcasecmp(string, "udp") == 0)
45 return KRB5_KRBHST_UDP;
46 else if(strcasecmp(string, "tcp") == 0)
47 return KRB5_KRBHST_TCP;
48 else if(strcasecmp(string, "http") == 0)
49 return KRB5_KRBHST_HTTP;
50 return -1;
54 * set `res' and `count' to the result of looking up SRV RR in DNS for
55 * `proto', `proto', `realm' using `dns_type'.
56 * if `port' != 0, force that port number
59 static krb5_error_code
60 srv_find_realm(krb5_context context, krb5_krbhst_info ***res, int *count,
61 const char *realm, const char *dns_type,
62 const char *proto, const char *service, int port)
64 char domain[1024];
65 struct dns_reply *r;
66 struct resource_record *rr;
67 int num_srv;
68 int proto_num;
69 int def_port;
71 *res = NULL;
72 *count = 0;
74 proto_num = string_to_proto(proto);
75 if(proto_num < 0) {
76 krb5_set_error_string(context, "unknown protocol `%s'", proto);
77 return EINVAL;
80 if(proto_num == KRB5_KRBHST_HTTP)
81 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
82 else if(port == 0)
83 def_port = ntohs(krb5_getportbyname (context, service, proto, 88));
84 else
85 def_port = port;
87 snprintf(domain, sizeof(domain), "_%s._%s.%s.", service, proto, realm);
89 r = dns_lookup(domain, dns_type);
90 if(r == NULL)
91 return KRB5_KDC_UNREACH;
93 for(num_srv = 0, rr = r->head; rr; rr = rr->next)
94 if(rr->type == T_SRV)
95 num_srv++;
97 *res = malloc(num_srv * sizeof(**res));
98 if(*res == NULL) {
99 dns_free_data(r);
100 krb5_set_error_string(context, "malloc: out of memory");
101 return ENOMEM;
104 dns_srv_order(r);
106 for(num_srv = 0, rr = r->head; rr; rr = rr->next)
107 if(rr->type == T_SRV) {
108 krb5_krbhst_info *hi;
109 size_t len = strlen(rr->u.srv->target);
111 hi = calloc(1, sizeof(*hi) + len);
112 if(hi == NULL) {
113 dns_free_data(r);
114 while(--num_srv >= 0)
115 free((*res)[num_srv]);
116 free(*res);
117 *res = NULL;
118 return ENOMEM;
120 (*res)[num_srv++] = hi;
122 hi->proto = proto_num;
124 hi->def_port = def_port;
125 if (port != 0)
126 hi->port = port;
127 else
128 hi->port = rr->u.srv->port;
130 strlcpy(hi->hostname, rr->u.srv->target, len + 1);
133 *count = num_srv;
135 dns_free_data(r);
136 return 0;
140 struct krb5_krbhst_data {
141 char *realm;
142 unsigned int flags;
143 int def_port;
144 int port; /* hardwired port number if != 0 */
145 #define KD_CONFIG 1
146 #define KD_SRV_UDP 2
147 #define KD_SRV_TCP 4
148 #define KD_SRV_HTTP 8
149 #define KD_FALLBACK 16
150 #define KD_CONFIG_EXISTS 32
151 #define KD_LARGE_MSG 64
152 #define KD_PLUGIN 128
153 krb5_error_code (*get_next)(krb5_context, struct krb5_krbhst_data *,
154 krb5_krbhst_info**);
156 unsigned int fallback_count;
158 struct krb5_krbhst_info *hosts, **index, **end;
161 static krb5_boolean
162 krbhst_empty(const struct krb5_krbhst_data *kd)
164 return kd->index == &kd->hosts;
168 * Return the default protocol for the `kd' (either TCP or UDP)
171 static int
172 krbhst_get_default_proto(struct krb5_krbhst_data *kd)
174 if (kd->flags & KD_LARGE_MSG)
175 return KRB5_KRBHST_TCP;
176 return KRB5_KRBHST_UDP;
181 * parse `spec' into a krb5_krbhst_info, defaulting the port to `def_port'
182 * and forcing it to `port' if port != 0
185 static struct krb5_krbhst_info*
186 parse_hostspec(krb5_context context, struct krb5_krbhst_data *kd,
187 const char *spec, int def_port, int port)
189 const char *p = spec;
190 struct krb5_krbhst_info *hi;
192 hi = calloc(1, sizeof(*hi) + strlen(spec));
193 if(hi == NULL)
194 return NULL;
196 hi->proto = krbhst_get_default_proto(kd);
198 if(strncmp(p, "http://", 7) == 0){
199 hi->proto = KRB5_KRBHST_HTTP;
200 p += 7;
201 } else if(strncmp(p, "http/", 5) == 0) {
202 hi->proto = KRB5_KRBHST_HTTP;
203 p += 5;
204 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
205 }else if(strncmp(p, "tcp/", 4) == 0){
206 hi->proto = KRB5_KRBHST_TCP;
207 p += 4;
208 } else if(strncmp(p, "udp/", 4) == 0) {
209 p += 4;
212 if(strsep_copy(&p, ":", hi->hostname, strlen(spec) + 1) < 0) {
213 free(hi);
214 return NULL;
216 /* get rid of trailing /, and convert to lower case */
217 hi->hostname[strcspn(hi->hostname, "/")] = '\0';
218 strlwr(hi->hostname);
220 hi->port = hi->def_port = def_port;
221 if(p != NULL) {
222 char *end;
223 hi->port = strtol(p, &end, 0);
224 if(end == p) {
225 free(hi);
226 return NULL;
229 if (port)
230 hi->port = port;
231 return hi;
234 void
235 _krb5_free_krbhst_info(krb5_krbhst_info *hi)
237 if (hi->ai != NULL)
238 freeaddrinfo(hi->ai);
239 free(hi);
242 krb5_error_code
243 _krb5_krbhost_info_move(krb5_context context,
244 krb5_krbhst_info *from,
245 krb5_krbhst_info **to)
247 size_t hostnamelen = strlen(from->hostname);
248 /* trailing NUL is included in structure */
249 *to = calloc(1, sizeof(**to) + hostnamelen);
250 if(*to == NULL) {
251 krb5_set_error_string(context, "malloc - out of memory");
252 return ENOMEM;
255 (*to)->proto = from->proto;
256 (*to)->port = from->port;
257 (*to)->def_port = from->def_port;
258 (*to)->ai = from->ai;
259 from->ai = NULL;
260 (*to)->next = NULL;
261 memcpy((*to)->hostname, from->hostname, hostnamelen + 1);
262 return 0;
266 static void
267 append_host_hostinfo(struct krb5_krbhst_data *kd, struct krb5_krbhst_info *host)
269 struct krb5_krbhst_info *h;
271 for(h = kd->hosts; h; h = h->next)
272 if(h->proto == host->proto &&
273 h->port == host->port &&
274 strcmp(h->hostname, host->hostname) == 0) {
275 _krb5_free_krbhst_info(host);
276 return;
278 *kd->end = host;
279 kd->end = &host->next;
282 static krb5_error_code
283 append_host_string(krb5_context context, struct krb5_krbhst_data *kd,
284 const char *host, int def_port, int port)
286 struct krb5_krbhst_info *hi;
288 hi = parse_hostspec(context, kd, host, def_port, port);
289 if(hi == NULL)
290 return ENOMEM;
292 append_host_hostinfo(kd, hi);
293 return 0;
297 * return a readable representation of `host' in `hostname, hostlen'
300 krb5_error_code KRB5_LIB_FUNCTION
301 krb5_krbhst_format_string(krb5_context context, const krb5_krbhst_info *host,
302 char *hostname, size_t hostlen)
304 const char *proto = "";
305 char portstr[7] = "";
306 if(host->proto == KRB5_KRBHST_TCP)
307 proto = "tcp/";
308 else if(host->proto == KRB5_KRBHST_HTTP)
309 proto = "http://";
310 if(host->port != host->def_port)
311 snprintf(portstr, sizeof(portstr), ":%d", host->port);
312 snprintf(hostname, hostlen, "%s%s%s", proto, host->hostname, portstr);
313 return 0;
317 * create a getaddrinfo `hints' based on `proto'
320 static void
321 make_hints(struct addrinfo *hints, int proto)
323 memset(hints, 0, sizeof(*hints));
324 hints->ai_family = AF_UNSPEC;
325 switch(proto) {
326 case KRB5_KRBHST_UDP :
327 hints->ai_socktype = SOCK_DGRAM;
328 break;
329 case KRB5_KRBHST_HTTP :
330 case KRB5_KRBHST_TCP :
331 hints->ai_socktype = SOCK_STREAM;
332 break;
337 * return an `struct addrinfo *' in `ai' corresponding to the information
338 * in `host'. free:ing is handled by krb5_krbhst_free.
341 krb5_error_code KRB5_LIB_FUNCTION
342 krb5_krbhst_get_addrinfo(krb5_context context, krb5_krbhst_info *host,
343 struct addrinfo **ai)
345 struct addrinfo hints;
346 char portstr[NI_MAXSERV];
347 int ret;
349 if (host->ai == NULL) {
350 make_hints(&hints, host->proto);
351 snprintf (portstr, sizeof(portstr), "%d", host->port);
352 ret = getaddrinfo(host->hostname, portstr, &hints, &host->ai);
353 if (ret)
354 return krb5_eai_to_heim_errno(ret, errno);
356 *ai = host->ai;
357 return 0;
360 static krb5_boolean
361 get_next(struct krb5_krbhst_data *kd, krb5_krbhst_info **host)
363 struct krb5_krbhst_info *hi = *kd->index;
364 if(hi != NULL) {
365 *host = hi;
366 kd->index = &(*kd->index)->next;
367 return TRUE;
369 return FALSE;
372 static void
373 srv_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
374 const char *proto, const char *service)
376 krb5_krbhst_info **res;
377 int count, i;
379 if (srv_find_realm(context, &res, &count, kd->realm, "SRV", proto, service,
380 kd->port))
381 return;
382 for(i = 0; i < count; i++)
383 append_host_hostinfo(kd, res[i]);
384 free(res);
388 * read the configuration for `conf_string', defaulting to kd->def_port and
389 * forcing it to `kd->port' if kd->port != 0
392 static void
393 config_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
394 const char *conf_string)
396 int i;
398 char **hostlist;
399 hostlist = krb5_config_get_strings(context, NULL,
400 "realms", kd->realm, conf_string, NULL);
402 if(hostlist == NULL)
403 return;
404 kd->flags |= KD_CONFIG_EXISTS;
405 for(i = 0; hostlist && hostlist[i] != NULL; i++)
406 append_host_string(context, kd, hostlist[i], kd->def_port, kd->port);
408 krb5_config_free_strings(hostlist);
412 * as a fallback, look for `serv_string.kd->realm' (typically
413 * kerberos.REALM, kerberos-1.REALM, ...
414 * `port' is the default port for the service, and `proto' the
415 * protocol
418 static krb5_error_code
419 fallback_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
420 const char *serv_string, int port, int proto)
422 char *host;
423 int ret;
424 struct addrinfo *ai;
425 struct addrinfo hints;
426 char portstr[NI_MAXSERV];
429 * Don't try forever in case the DNS server keep returning us
430 * entries (like wildcard entries or the .nu TLD)
432 if(kd->fallback_count >= 5) {
433 kd->flags |= KD_FALLBACK;
434 return 0;
437 if(kd->fallback_count == 0)
438 asprintf(&host, "%s.%s.", serv_string, kd->realm);
439 else
440 asprintf(&host, "%s-%d.%s.",
441 serv_string, kd->fallback_count, kd->realm);
443 if (host == NULL)
444 return ENOMEM;
446 make_hints(&hints, proto);
447 snprintf(portstr, sizeof(portstr), "%d", port);
448 ret = getaddrinfo(host, portstr, &hints, &ai);
449 if (ret) {
450 /* no more hosts, so we're done here */
451 free(host);
452 kd->flags |= KD_FALLBACK;
453 } else {
454 struct krb5_krbhst_info *hi;
455 size_t hostlen = strlen(host);
457 hi = calloc(1, sizeof(*hi) + hostlen);
458 if(hi == NULL) {
459 free(host);
460 return ENOMEM;
463 hi->proto = proto;
464 hi->port = hi->def_port = port;
465 hi->ai = ai;
466 memmove(hi->hostname, host, hostlen);
467 hi->hostname[hostlen] = '\0';
468 free(host);
469 append_host_hostinfo(kd, hi);
470 kd->fallback_count++;
472 return 0;
476 * Fetch hosts from plugin
479 static krb5_error_code
480 add_locate(void *ctx, int type, struct sockaddr *addr)
482 struct krb5_krbhst_info *hi;
483 struct krb5_krbhst_data *kd = ctx;
484 char host[NI_MAXHOST], port[NI_MAXSERV];
485 struct addrinfo hints, *ai;
486 socklen_t socklen;
487 size_t hostlen;
488 int ret;
490 socklen = socket_sockaddr_size(addr);
492 ret = getnameinfo(addr, socklen, host, sizeof(host), port, sizeof(port),
493 NI_NUMERICHOST|NI_NUMERICSERV);
494 if (ret != 0)
495 return 0;
497 make_hints(&hints, krbhst_get_default_proto(kd));
498 ret = getaddrinfo(host, port, &hints, &ai);
499 if (ret)
500 return 0;
502 hostlen = strlen(host);
504 hi = calloc(1, sizeof(*hi) + hostlen);
505 if(hi == NULL)
506 return ENOMEM;
508 hi->proto = krbhst_get_default_proto(kd);
509 hi->port = hi->def_port = socket_get_port(addr);
510 hi->ai = ai;
511 memmove(hi->hostname, host, hostlen);
512 hi->hostname[hostlen] = '\0';
513 append_host_hostinfo(kd, hi);
515 return 0;
518 static void
519 plugin_get_hosts(krb5_context context,
520 struct krb5_krbhst_data *kd,
521 enum locate_service_type type)
523 struct krb5_plugin *list = NULL, *e;
524 krb5_error_code ret;
526 ret = _krb5_plugin_find(context, PLUGIN_TYPE_DATA, "resolve", &list);
527 if(ret != 0 || list == NULL)
528 return;
530 kd->flags |= KD_CONFIG_EXISTS;
532 for (e = list; e != NULL; e = _krb5_plugin_get_next(e)) {
533 krb5plugin_service_locate_ftable *service;
534 void *ctx;
536 service = _krb5_plugin_get_symbol(e);
537 if (service->minor_version != 0)
538 continue;
540 (*service->init)(context, &ctx);
541 ret = (*service->lookup)(ctx, type, kd->realm, 0, 0, add_locate, kd);
542 (*service->fini)(ctx);
543 if (ret) {
544 krb5_set_error_string(context, "Plugin failed to lookup");
545 break;
548 _krb5_plugin_free(list);
555 static krb5_error_code
556 kdc_get_next(krb5_context context,
557 struct krb5_krbhst_data *kd,
558 krb5_krbhst_info **host)
560 krb5_error_code ret;
562 if ((kd->flags & KD_PLUGIN) == 0) {
563 plugin_get_hosts(context, kd, locate_service_kdc);
564 kd->flags |= KD_PLUGIN;
565 if(get_next(kd, host))
566 return 0;
569 if((kd->flags & KD_CONFIG) == 0) {
570 config_get_hosts(context, kd, "kdc");
571 kd->flags |= KD_CONFIG;
572 if(get_next(kd, host))
573 return 0;
576 if (kd->flags & KD_CONFIG_EXISTS)
577 return KRB5_KDC_UNREACH; /* XXX */
579 if(context->srv_lookup) {
580 if((kd->flags & KD_SRV_UDP) == 0 && (kd->flags & KD_LARGE_MSG) == 0) {
581 srv_get_hosts(context, kd, "udp", "kerberos");
582 kd->flags |= KD_SRV_UDP;
583 if(get_next(kd, host))
584 return 0;
587 if((kd->flags & KD_SRV_TCP) == 0) {
588 srv_get_hosts(context, kd, "tcp", "kerberos");
589 kd->flags |= KD_SRV_TCP;
590 if(get_next(kd, host))
591 return 0;
593 if((kd->flags & KD_SRV_HTTP) == 0) {
594 srv_get_hosts(context, kd, "http", "kerberos");
595 kd->flags |= KD_SRV_HTTP;
596 if(get_next(kd, host))
597 return 0;
601 while((kd->flags & KD_FALLBACK) == 0) {
602 ret = fallback_get_hosts(context, kd, "kerberos",
603 kd->def_port,
604 krbhst_get_default_proto(kd));
605 if(ret)
606 return ret;
607 if(get_next(kd, host))
608 return 0;
611 return KRB5_KDC_UNREACH; /* XXX */
614 static krb5_error_code
615 admin_get_next(krb5_context context,
616 struct krb5_krbhst_data *kd,
617 krb5_krbhst_info **host)
619 krb5_error_code ret;
621 if ((kd->flags & KD_PLUGIN) == 0) {
622 plugin_get_hosts(context, kd, locate_service_kadmin);
623 kd->flags |= KD_PLUGIN;
624 if(get_next(kd, host))
625 return 0;
628 if((kd->flags & KD_CONFIG) == 0) {
629 config_get_hosts(context, kd, "admin_server");
630 kd->flags |= KD_CONFIG;
631 if(get_next(kd, host))
632 return 0;
635 if (kd->flags & KD_CONFIG_EXISTS)
636 return KRB5_KDC_UNREACH; /* XXX */
638 if(context->srv_lookup) {
639 if((kd->flags & KD_SRV_TCP) == 0) {
640 srv_get_hosts(context, kd, "tcp", "kerberos-adm");
641 kd->flags |= KD_SRV_TCP;
642 if(get_next(kd, host))
643 return 0;
647 if (krbhst_empty(kd)
648 && (kd->flags & KD_FALLBACK) == 0) {
649 ret = fallback_get_hosts(context, kd, "kerberos",
650 kd->def_port,
651 krbhst_get_default_proto(kd));
652 if(ret)
653 return ret;
654 kd->flags |= KD_FALLBACK;
655 if(get_next(kd, host))
656 return 0;
659 return KRB5_KDC_UNREACH; /* XXX */
662 static krb5_error_code
663 kpasswd_get_next(krb5_context context,
664 struct krb5_krbhst_data *kd,
665 krb5_krbhst_info **host)
667 krb5_error_code ret;
669 if ((kd->flags & KD_PLUGIN) == 0) {
670 plugin_get_hosts(context, kd, locate_service_kpasswd);
671 kd->flags |= KD_PLUGIN;
672 if(get_next(kd, host))
673 return 0;
676 if((kd->flags & KD_CONFIG) == 0) {
677 config_get_hosts(context, kd, "kpasswd_server");
678 kd->flags |= KD_CONFIG;
679 if(get_next(kd, host))
680 return 0;
683 if (kd->flags & KD_CONFIG_EXISTS)
684 return KRB5_KDC_UNREACH; /* XXX */
686 if(context->srv_lookup) {
687 if((kd->flags & KD_SRV_UDP) == 0) {
688 srv_get_hosts(context, kd, "udp", "kpasswd");
689 kd->flags |= KD_SRV_UDP;
690 if(get_next(kd, host))
691 return 0;
693 if((kd->flags & KD_SRV_TCP) == 0) {
694 srv_get_hosts(context, kd, "tcp", "kpasswd");
695 kd->flags |= KD_SRV_TCP;
696 if(get_next(kd, host))
697 return 0;
701 /* no matches -> try admin */
703 if (krbhst_empty(kd)) {
704 kd->flags = 0;
705 kd->port = kd->def_port;
706 kd->get_next = admin_get_next;
707 ret = (*kd->get_next)(context, kd, host);
708 if (ret == 0)
709 (*host)->proto = krbhst_get_default_proto(kd);
710 return ret;
713 return KRB5_KDC_UNREACH; /* XXX */
716 static krb5_error_code
717 krb524_get_next(krb5_context context,
718 struct krb5_krbhst_data *kd,
719 krb5_krbhst_info **host)
721 if ((kd->flags & KD_PLUGIN) == 0) {
722 plugin_get_hosts(context, kd, locate_service_krb524);
723 kd->flags |= KD_PLUGIN;
724 if(get_next(kd, host))
725 return 0;
728 if((kd->flags & KD_CONFIG) == 0) {
729 config_get_hosts(context, kd, "krb524_server");
730 if(get_next(kd, host))
731 return 0;
732 kd->flags |= KD_CONFIG;
735 if (kd->flags & KD_CONFIG_EXISTS)
736 return KRB5_KDC_UNREACH; /* XXX */
738 if(context->srv_lookup) {
739 if((kd->flags & KD_SRV_UDP) == 0) {
740 srv_get_hosts(context, kd, "udp", "krb524");
741 kd->flags |= KD_SRV_UDP;
742 if(get_next(kd, host))
743 return 0;
746 if((kd->flags & KD_SRV_TCP) == 0) {
747 srv_get_hosts(context, kd, "tcp", "krb524");
748 kd->flags |= KD_SRV_TCP;
749 if(get_next(kd, host))
750 return 0;
754 /* no matches -> try kdc */
756 if (krbhst_empty(kd)) {
757 kd->flags = 0;
758 kd->port = kd->def_port;
759 kd->get_next = kdc_get_next;
760 return (*kd->get_next)(context, kd, host);
763 return KRB5_KDC_UNREACH; /* XXX */
766 static struct krb5_krbhst_data*
767 common_init(krb5_context context,
768 const char *realm,
769 int flags)
771 struct krb5_krbhst_data *kd;
773 if((kd = calloc(1, sizeof(*kd))) == NULL)
774 return NULL;
776 if((kd->realm = strdup(realm)) == NULL) {
777 free(kd);
778 return NULL;
781 /* For 'realms' without a . do not even think of going to DNS */
782 if (!strchr(realm, '.'))
783 kd->flags |= KD_CONFIG_EXISTS;
785 if (flags & KRB5_KRBHST_FLAGS_LARGE_MSG)
786 kd->flags |= KD_LARGE_MSG;
787 kd->end = kd->index = &kd->hosts;
788 return kd;
792 * initialize `handle' to look for hosts of type `type' in realm `realm'
795 krb5_error_code KRB5_LIB_FUNCTION
796 krb5_krbhst_init(krb5_context context,
797 const char *realm,
798 unsigned int type,
799 krb5_krbhst_handle *handle)
801 return krb5_krbhst_init_flags(context, realm, type, 0, handle);
804 krb5_error_code KRB5_LIB_FUNCTION
805 krb5_krbhst_init_flags(krb5_context context,
806 const char *realm,
807 unsigned int type,
808 int flags,
809 krb5_krbhst_handle *handle)
811 struct krb5_krbhst_data *kd;
812 krb5_error_code (*next)(krb5_context, struct krb5_krbhst_data *,
813 krb5_krbhst_info **);
814 int def_port;
816 switch(type) {
817 case KRB5_KRBHST_KDC:
818 next = kdc_get_next;
819 def_port = ntohs(krb5_getportbyname (context, "kerberos", "udp", 88));
820 break;
821 case KRB5_KRBHST_ADMIN:
822 next = admin_get_next;
823 def_port = ntohs(krb5_getportbyname (context, "kerberos-adm",
824 "tcp", 749));
825 break;
826 case KRB5_KRBHST_CHANGEPW:
827 next = kpasswd_get_next;
828 def_port = ntohs(krb5_getportbyname (context, "kpasswd", "udp",
829 KPASSWD_PORT));
830 break;
831 case KRB5_KRBHST_KRB524:
832 next = krb524_get_next;
833 def_port = ntohs(krb5_getportbyname (context, "krb524", "udp", 4444));
834 break;
835 default:
836 krb5_set_error_string(context, "unknown krbhst type (%u)", type);
837 return ENOTTY;
839 if((kd = common_init(context, realm, flags)) == NULL)
840 return ENOMEM;
841 kd->get_next = next;
842 kd->def_port = def_port;
843 *handle = kd;
844 return 0;
848 * return the next host information from `handle' in `host'
851 krb5_error_code KRB5_LIB_FUNCTION
852 krb5_krbhst_next(krb5_context context,
853 krb5_krbhst_handle handle,
854 krb5_krbhst_info **host)
856 if(get_next(handle, host))
857 return 0;
859 return (*handle->get_next)(context, handle, host);
863 * return the next host information from `handle' as a host name
864 * in `hostname' (or length `hostlen)
867 krb5_error_code KRB5_LIB_FUNCTION
868 krb5_krbhst_next_as_string(krb5_context context,
869 krb5_krbhst_handle handle,
870 char *hostname,
871 size_t hostlen)
873 krb5_error_code ret;
874 krb5_krbhst_info *host;
875 ret = krb5_krbhst_next(context, handle, &host);
876 if(ret)
877 return ret;
878 return krb5_krbhst_format_string(context, host, hostname, hostlen);
882 void KRB5_LIB_FUNCTION
883 krb5_krbhst_reset(krb5_context context, krb5_krbhst_handle handle)
885 handle->index = &handle->hosts;
888 void KRB5_LIB_FUNCTION
889 krb5_krbhst_free(krb5_context context, krb5_krbhst_handle handle)
891 krb5_krbhst_info *h, *next;
893 if (handle == NULL)
894 return;
896 for (h = handle->hosts; h != NULL; h = next) {
897 next = h->next;
898 _krb5_free_krbhst_info(h);
901 free(handle->realm);
902 free(handle);
905 /* backwards compatibility ahead */
907 static krb5_error_code
908 gethostlist(krb5_context context, const char *realm,
909 unsigned int type, char ***hostlist)
911 krb5_error_code ret;
912 int nhost = 0;
913 krb5_krbhst_handle handle;
914 char host[MAXHOSTNAMELEN];
915 krb5_krbhst_info *hostinfo;
917 ret = krb5_krbhst_init(context, realm, type, &handle);
918 if (ret)
919 return ret;
921 while(krb5_krbhst_next(context, handle, &hostinfo) == 0)
922 nhost++;
923 if(nhost == 0) {
924 krb5_set_error_string(context, "No KDC found for realm %s", realm);
925 return KRB5_KDC_UNREACH;
927 *hostlist = calloc(nhost + 1, sizeof(**hostlist));
928 if(*hostlist == NULL) {
929 krb5_krbhst_free(context, handle);
930 return ENOMEM;
933 krb5_krbhst_reset(context, handle);
934 nhost = 0;
935 while(krb5_krbhst_next_as_string(context, handle,
936 host, sizeof(host)) == 0) {
937 if(((*hostlist)[nhost++] = strdup(host)) == NULL) {
938 krb5_free_krbhst(context, *hostlist);
939 krb5_krbhst_free(context, handle);
940 return ENOMEM;
943 (*hostlist)[nhost++] = NULL;
944 krb5_krbhst_free(context, handle);
945 return 0;
949 * return an malloced list of kadmin-hosts for `realm' in `hostlist'
952 krb5_error_code KRB5_LIB_FUNCTION
953 krb5_get_krb_admin_hst (krb5_context context,
954 const krb5_realm *realm,
955 char ***hostlist)
957 return gethostlist(context, *realm, KRB5_KRBHST_ADMIN, hostlist);
961 * return an malloced list of changepw-hosts for `realm' in `hostlist'
964 krb5_error_code KRB5_LIB_FUNCTION
965 krb5_get_krb_changepw_hst (krb5_context context,
966 const krb5_realm *realm,
967 char ***hostlist)
969 return gethostlist(context, *realm, KRB5_KRBHST_CHANGEPW, hostlist);
973 * return an malloced list of 524-hosts for `realm' in `hostlist'
976 krb5_error_code KRB5_LIB_FUNCTION
977 krb5_get_krb524hst (krb5_context context,
978 const krb5_realm *realm,
979 char ***hostlist)
981 return gethostlist(context, *realm, KRB5_KRBHST_KRB524, hostlist);
986 * return an malloced list of KDC's for `realm' in `hostlist'
989 krb5_error_code KRB5_LIB_FUNCTION
990 krb5_get_krbhst (krb5_context context,
991 const krb5_realm *realm,
992 char ***hostlist)
994 return gethostlist(context, *realm, KRB5_KRBHST_KDC, hostlist);
998 * free all the memory allocated in `hostlist'
1001 krb5_error_code KRB5_LIB_FUNCTION
1002 krb5_free_krbhst (krb5_context context,
1003 char **hostlist)
1005 char **p;
1007 for (p = hostlist; *p; ++p)
1008 free (*p);
1009 free (hostlist);
1010 return 0;