2 * Copyright (c) 2001 - 2003 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
34 #include "krb5_locl.h"
36 #include "locate_plugin.h"
39 string_to_proto(const char *string)
41 if(strcasecmp(string, "udp") == 0)
42 return KRB5_KRBHST_UDP;
43 else if(strcasecmp(string, "tcp") == 0)
44 return KRB5_KRBHST_TCP;
45 else if(strcasecmp(string, "http") == 0)
46 return KRB5_KRBHST_HTTP;
51 * set `res' and `count' to the result of looking up SRV RR in DNS for
52 * `proto', `proto', `realm' using `dns_type'.
53 * if `port' != 0, force that port number
56 static krb5_error_code
57 srv_find_realm(krb5_context context, krb5_krbhst_info ***res, int *count,
58 const char *realm, const char *dns_type,
59 const char *proto, const char *service, int port)
62 struct rk_dns_reply *r;
63 struct rk_resource_record *rr;
71 proto_num = string_to_proto(proto);
73 krb5_set_error_message(context, EINVAL,
74 N_("unknown protocol `%s' to lookup", ""),
79 if(proto_num == KRB5_KRBHST_HTTP)
80 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
82 def_port = ntohs(krb5_getportbyname (context, service, proto, 88));
86 snprintf(domain, sizeof(domain), "_%s._%s.%s.", service, proto, realm);
88 r = rk_dns_lookup(domain, dns_type);
90 return KRB5_KDC_UNREACH;
92 for(num_srv = 0, rr = r->head; rr; rr = rr->next)
93 if(rr->type == rk_ns_t_srv)
96 *res = malloc(num_srv * sizeof(**res));
99 krb5_set_error_message(context, ENOMEM,
100 N_("malloc: out of memory", ""));
106 for(num_srv = 0, rr = r->head; rr; rr = rr->next)
107 if(rr->type == rk_ns_t_srv) {
108 krb5_krbhst_info *hi;
109 size_t len = strlen(rr->u.srv->target);
111 hi = calloc(1, sizeof(*hi) + len);
114 while(--num_srv >= 0)
115 free((*res)[num_srv]);
120 (*res)[num_srv++] = hi;
122 hi->proto = proto_num;
124 hi->def_port = def_port;
128 hi->port = rr->u.srv->port;
130 strlcpy(hi->hostname, rr->u.srv->target, len + 1);
140 struct krb5_krbhst_data {
144 int port; /* hardwired port number if != 0 */
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 *,
156 unsigned int fallback_count;
158 struct krb5_krbhst_info *hosts, **index, **end;
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)
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));
196 hi->proto = krbhst_get_default_proto(kd);
198 if(strncmp(p, "http://", 7) == 0){
199 hi->proto = KRB5_KRBHST_HTTP;
201 } else if(strncmp(p, "http/", 5) == 0) {
202 hi->proto = KRB5_KRBHST_HTTP;
204 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
205 }else if(strncmp(p, "tcp/", 4) == 0){
206 hi->proto = KRB5_KRBHST_TCP;
208 } else if(strncmp(p, "udp/", 4) == 0) {
212 if(strsep_copy(&p, ":", hi->hostname, strlen(spec) + 1) < 0) {
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;
223 hi->port = strtol(p, &end, 0);
235 _krb5_free_krbhst_info(krb5_krbhst_info *hi)
238 freeaddrinfo(hi->ai);
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);
251 krb5_set_error_message(context, ENOMEM,
252 N_("malloc: out of memory", ""));
256 (*to)->proto = from->proto;
257 (*to)->port = from->port;
258 (*to)->def_port = from->def_port;
259 (*to)->ai = from->ai;
262 memcpy((*to)->hostname, from->hostname, hostnamelen + 1);
268 append_host_hostinfo(struct krb5_krbhst_data *kd, struct krb5_krbhst_info *host)
270 struct krb5_krbhst_info *h;
272 for(h = kd->hosts; h; h = h->next)
273 if(h->proto == host->proto &&
274 h->port == host->port &&
275 strcmp(h->hostname, host->hostname) == 0) {
276 _krb5_free_krbhst_info(host);
280 kd->end = &host->next;
283 static krb5_error_code
284 append_host_string(krb5_context context, struct krb5_krbhst_data *kd,
285 const char *host, int def_port, int port)
287 struct krb5_krbhst_info *hi;
289 hi = parse_hostspec(context, kd, host, def_port, port);
293 append_host_hostinfo(kd, hi);
298 * return a readable representation of `host' in `hostname, hostlen'
301 krb5_error_code KRB5_LIB_FUNCTION
302 krb5_krbhst_format_string(krb5_context context, const krb5_krbhst_info *host,
303 char *hostname, size_t hostlen)
305 const char *proto = "";
306 char portstr[7] = "";
307 if(host->proto == KRB5_KRBHST_TCP)
309 else if(host->proto == KRB5_KRBHST_HTTP)
311 if(host->port != host->def_port)
312 snprintf(portstr, sizeof(portstr), ":%d", host->port);
313 snprintf(hostname, hostlen, "%s%s%s", proto, host->hostname, portstr);
318 * create a getaddrinfo `hints' based on `proto'
322 make_hints(struct addrinfo *hints, int proto)
324 memset(hints, 0, sizeof(*hints));
325 hints->ai_family = AF_UNSPEC;
327 case KRB5_KRBHST_UDP :
328 hints->ai_socktype = SOCK_DGRAM;
330 case KRB5_KRBHST_HTTP :
331 case KRB5_KRBHST_TCP :
332 hints->ai_socktype = SOCK_STREAM;
338 * return an `struct addrinfo *' in `ai' corresponding to the information
339 * in `host'. free:ing is handled by krb5_krbhst_free.
342 krb5_error_code KRB5_LIB_FUNCTION
343 krb5_krbhst_get_addrinfo(krb5_context context, krb5_krbhst_info *host,
344 struct addrinfo **ai)
346 struct addrinfo hints;
347 char portstr[NI_MAXSERV];
350 if (host->ai == NULL) {
351 make_hints(&hints, host->proto);
352 snprintf (portstr, sizeof(portstr), "%d", host->port);
353 ret = getaddrinfo(host->hostname, portstr, &hints, &host->ai);
355 return krb5_eai_to_heim_errno(ret, errno);
362 get_next(struct krb5_krbhst_data *kd, krb5_krbhst_info **host)
364 struct krb5_krbhst_info *hi = *kd->index;
367 kd->index = &(*kd->index)->next;
374 srv_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
375 const char *proto, const char *service)
377 krb5_krbhst_info **res;
380 if (srv_find_realm(context, &res, &count, kd->realm, "SRV", proto, service,
383 for(i = 0; i < count; i++)
384 append_host_hostinfo(kd, res[i]);
389 * read the configuration for `conf_string', defaulting to kd->def_port and
390 * forcing it to `kd->port' if kd->port != 0
394 config_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
395 const char *conf_string)
400 hostlist = krb5_config_get_strings(context, NULL,
401 "realms", kd->realm, conf_string, NULL);
405 kd->flags |= KD_CONFIG_EXISTS;
406 for(i = 0; hostlist && hostlist[i] != NULL; i++)
407 append_host_string(context, kd, hostlist[i], kd->def_port, kd->port);
409 krb5_config_free_strings(hostlist);
413 * as a fallback, look for `serv_string.kd->realm' (typically
414 * kerberos.REALM, kerberos-1.REALM, ...
415 * `port' is the default port for the service, and `proto' the
419 static krb5_error_code
420 fallback_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
421 const char *serv_string, int port, int proto)
426 struct addrinfo hints;
427 char portstr[NI_MAXSERV];
430 * Don't try forever in case the DNS server keep returning us
431 * entries (like wildcard entries or the .nu TLD)
433 if(kd->fallback_count >= 5) {
434 kd->flags |= KD_FALLBACK;
438 if(kd->fallback_count == 0)
439 asprintf(&host, "%s.%s.", serv_string, kd->realm);
441 asprintf(&host, "%s-%d.%s.",
442 serv_string, kd->fallback_count, kd->realm);
447 make_hints(&hints, proto);
448 snprintf(portstr, sizeof(portstr), "%d", port);
449 ret = getaddrinfo(host, portstr, &hints, &ai);
451 /* no more hosts, so we're done here */
453 kd->flags |= KD_FALLBACK;
455 struct krb5_krbhst_info *hi;
456 size_t hostlen = strlen(host);
458 hi = calloc(1, sizeof(*hi) + hostlen);
465 hi->port = hi->def_port = port;
467 memmove(hi->hostname, host, hostlen);
468 hi->hostname[hostlen] = '\0';
470 append_host_hostinfo(kd, hi);
471 kd->fallback_count++;
477 * Fetch hosts from plugin
480 static krb5_error_code
481 add_locate(void *ctx, int type, struct sockaddr *addr)
483 struct krb5_krbhst_info *hi;
484 struct krb5_krbhst_data *kd = ctx;
485 char host[NI_MAXHOST], port[NI_MAXSERV];
486 struct addrinfo hints, *ai;
491 socklen = socket_sockaddr_size(addr);
493 ret = getnameinfo(addr, socklen, host, sizeof(host), port, sizeof(port),
494 NI_NUMERICHOST|NI_NUMERICSERV);
498 make_hints(&hints, krbhst_get_default_proto(kd));
499 ret = getaddrinfo(host, port, &hints, &ai);
503 hostlen = strlen(host);
505 hi = calloc(1, sizeof(*hi) + hostlen);
509 hi->proto = krbhst_get_default_proto(kd);
510 hi->port = hi->def_port = socket_get_port(addr);
512 memmove(hi->hostname, host, hostlen);
513 hi->hostname[hostlen] = '\0';
514 append_host_hostinfo(kd, hi);
520 plugin_get_hosts(krb5_context context,
521 struct krb5_krbhst_data *kd,
522 enum locate_service_type type)
524 struct krb5_plugin *list = NULL, *e;
527 ret = _krb5_plugin_find(context, PLUGIN_TYPE_DATA,
528 KRB5_PLUGIN_LOCATE, &list);
529 if(ret != 0 || list == NULL)
532 for (e = list; e != NULL; e = _krb5_plugin_get_next(e)) {
533 krb5plugin_service_locate_ftable *service;
536 service = _krb5_plugin_get_symbol(e);
537 if (service->minor_version != 0)
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 && ret != KRB5_PLUGIN_NO_HANDLE) {
544 krb5_set_error_message(context, ret,
545 N_("Locate plugin failed to lookup realm %s: %d", ""),
549 kd->flags |= KD_CONFIG_EXISTS;
552 _krb5_plugin_free(list);
559 static krb5_error_code
560 kdc_get_next(krb5_context context,
561 struct krb5_krbhst_data *kd,
562 krb5_krbhst_info **host)
566 if ((kd->flags & KD_PLUGIN) == 0) {
567 plugin_get_hosts(context, kd, locate_service_kdc);
568 kd->flags |= KD_PLUGIN;
569 if(get_next(kd, host))
573 if((kd->flags & KD_CONFIG) == 0) {
574 config_get_hosts(context, kd, "kdc");
575 kd->flags |= KD_CONFIG;
576 if(get_next(kd, host))
580 if (kd->flags & KD_CONFIG_EXISTS)
581 return KRB5_KDC_UNREACH; /* XXX */
583 if(context->srv_lookup) {
584 if((kd->flags & KD_SRV_UDP) == 0 && (kd->flags & KD_LARGE_MSG) == 0) {
585 srv_get_hosts(context, kd, "udp", "kerberos");
586 kd->flags |= KD_SRV_UDP;
587 if(get_next(kd, host))
591 if((kd->flags & KD_SRV_TCP) == 0) {
592 srv_get_hosts(context, kd, "tcp", "kerberos");
593 kd->flags |= KD_SRV_TCP;
594 if(get_next(kd, host))
597 if((kd->flags & KD_SRV_HTTP) == 0) {
598 srv_get_hosts(context, kd, "http", "kerberos");
599 kd->flags |= KD_SRV_HTTP;
600 if(get_next(kd, host))
605 while((kd->flags & KD_FALLBACK) == 0) {
606 ret = fallback_get_hosts(context, kd, "kerberos",
608 krbhst_get_default_proto(kd));
611 if(get_next(kd, host))
615 return KRB5_KDC_UNREACH; /* XXX */
618 static krb5_error_code
619 admin_get_next(krb5_context context,
620 struct krb5_krbhst_data *kd,
621 krb5_krbhst_info **host)
625 if ((kd->flags & KD_PLUGIN) == 0) {
626 plugin_get_hosts(context, kd, locate_service_kadmin);
627 kd->flags |= KD_PLUGIN;
628 if(get_next(kd, host))
632 if((kd->flags & KD_CONFIG) == 0) {
633 config_get_hosts(context, kd, "admin_server");
634 kd->flags |= KD_CONFIG;
635 if(get_next(kd, host))
639 if (kd->flags & KD_CONFIG_EXISTS)
640 return KRB5_KDC_UNREACH; /* XXX */
642 if(context->srv_lookup) {
643 if((kd->flags & KD_SRV_TCP) == 0) {
644 srv_get_hosts(context, kd, "tcp", "kerberos-adm");
645 kd->flags |= KD_SRV_TCP;
646 if(get_next(kd, host))
652 && (kd->flags & KD_FALLBACK) == 0) {
653 ret = fallback_get_hosts(context, kd, "kerberos",
655 krbhst_get_default_proto(kd));
658 kd->flags |= KD_FALLBACK;
659 if(get_next(kd, host))
663 return KRB5_KDC_UNREACH; /* XXX */
666 static krb5_error_code
667 kpasswd_get_next(krb5_context context,
668 struct krb5_krbhst_data *kd,
669 krb5_krbhst_info **host)
673 if ((kd->flags & KD_PLUGIN) == 0) {
674 plugin_get_hosts(context, kd, locate_service_kpasswd);
675 kd->flags |= KD_PLUGIN;
676 if(get_next(kd, host))
680 if((kd->flags & KD_CONFIG) == 0) {
681 config_get_hosts(context, kd, "kpasswd_server");
682 kd->flags |= KD_CONFIG;
683 if(get_next(kd, host))
687 if (kd->flags & KD_CONFIG_EXISTS)
688 return KRB5_KDC_UNREACH; /* XXX */
690 if(context->srv_lookup) {
691 if((kd->flags & KD_SRV_UDP) == 0) {
692 srv_get_hosts(context, kd, "udp", "kpasswd");
693 kd->flags |= KD_SRV_UDP;
694 if(get_next(kd, host))
697 if((kd->flags & KD_SRV_TCP) == 0) {
698 srv_get_hosts(context, kd, "tcp", "kpasswd");
699 kd->flags |= KD_SRV_TCP;
700 if(get_next(kd, host))
705 /* no matches -> try admin */
707 if (krbhst_empty(kd)) {
709 kd->port = kd->def_port;
710 kd->get_next = admin_get_next;
711 ret = (*kd->get_next)(context, kd, host);
713 (*host)->proto = krbhst_get_default_proto(kd);
717 return KRB5_KDC_UNREACH; /* XXX */
720 static krb5_error_code
721 krb524_get_next(krb5_context context,
722 struct krb5_krbhst_data *kd,
723 krb5_krbhst_info **host)
725 if ((kd->flags & KD_PLUGIN) == 0) {
726 plugin_get_hosts(context, kd, locate_service_krb524);
727 kd->flags |= KD_PLUGIN;
728 if(get_next(kd, host))
732 if((kd->flags & KD_CONFIG) == 0) {
733 config_get_hosts(context, kd, "krb524_server");
734 if(get_next(kd, host))
736 kd->flags |= KD_CONFIG;
739 if (kd->flags & KD_CONFIG_EXISTS)
740 return KRB5_KDC_UNREACH; /* XXX */
742 if(context->srv_lookup) {
743 if((kd->flags & KD_SRV_UDP) == 0) {
744 srv_get_hosts(context, kd, "udp", "krb524");
745 kd->flags |= KD_SRV_UDP;
746 if(get_next(kd, host))
750 if((kd->flags & KD_SRV_TCP) == 0) {
751 srv_get_hosts(context, kd, "tcp", "krb524");
752 kd->flags |= KD_SRV_TCP;
753 if(get_next(kd, host))
758 /* no matches -> try kdc */
760 if (krbhst_empty(kd)) {
762 kd->port = kd->def_port;
763 kd->get_next = kdc_get_next;
764 return (*kd->get_next)(context, kd, host);
767 return KRB5_KDC_UNREACH; /* XXX */
770 static struct krb5_krbhst_data*
771 common_init(krb5_context context,
775 struct krb5_krbhst_data *kd;
777 if((kd = calloc(1, sizeof(*kd))) == NULL)
780 if((kd->realm = strdup(realm)) == NULL) {
785 /* For 'realms' without a . do not even think of going to DNS */
786 if (!strchr(realm, '.'))
787 kd->flags |= KD_CONFIG_EXISTS;
789 if (flags & KRB5_KRBHST_FLAGS_LARGE_MSG)
790 kd->flags |= KD_LARGE_MSG;
791 kd->end = kd->index = &kd->hosts;
796 * initialize `handle' to look for hosts of type `type' in realm `realm'
799 krb5_error_code KRB5_LIB_FUNCTION
800 krb5_krbhst_init(krb5_context context,
803 krb5_krbhst_handle *handle)
805 return krb5_krbhst_init_flags(context, realm, type, 0, handle);
808 krb5_error_code KRB5_LIB_FUNCTION
809 krb5_krbhst_init_flags(krb5_context context,
813 krb5_krbhst_handle *handle)
815 struct krb5_krbhst_data *kd;
816 krb5_error_code (*next)(krb5_context, struct krb5_krbhst_data *,
817 krb5_krbhst_info **);
821 case KRB5_KRBHST_KDC:
823 def_port = ntohs(krb5_getportbyname (context, "kerberos", "udp", 88));
825 case KRB5_KRBHST_ADMIN:
826 next = admin_get_next;
827 def_port = ntohs(krb5_getportbyname (context, "kerberos-adm",
830 case KRB5_KRBHST_CHANGEPW:
831 next = kpasswd_get_next;
832 def_port = ntohs(krb5_getportbyname (context, "kpasswd", "udp",
835 case KRB5_KRBHST_KRB524:
836 next = krb524_get_next;
837 def_port = ntohs(krb5_getportbyname (context, "krb524", "udp", 4444));
840 krb5_set_error_message(context, ENOTTY,
841 N_("unknown krbhst type (%u)", ""), type);
844 if((kd = common_init(context, realm, flags)) == NULL)
847 kd->def_port = def_port;
853 * return the next host information from `handle' in `host'
856 krb5_error_code KRB5_LIB_FUNCTION
857 krb5_krbhst_next(krb5_context context,
858 krb5_krbhst_handle handle,
859 krb5_krbhst_info **host)
861 if(get_next(handle, host))
864 return (*handle->get_next)(context, handle, host);
868 * return the next host information from `handle' as a host name
869 * in `hostname' (or length `hostlen)
872 krb5_error_code KRB5_LIB_FUNCTION
873 krb5_krbhst_next_as_string(krb5_context context,
874 krb5_krbhst_handle handle,
879 krb5_krbhst_info *host;
880 ret = krb5_krbhst_next(context, handle, &host);
883 return krb5_krbhst_format_string(context, host, hostname, hostlen);
887 void KRB5_LIB_FUNCTION
888 krb5_krbhst_reset(krb5_context context, krb5_krbhst_handle handle)
890 handle->index = &handle->hosts;
893 void KRB5_LIB_FUNCTION
894 krb5_krbhst_free(krb5_context context, krb5_krbhst_handle handle)
896 krb5_krbhst_info *h, *next;
901 for (h = handle->hosts; h != NULL; h = next) {
903 _krb5_free_krbhst_info(h);
910 /* backwards compatibility ahead */
912 static krb5_error_code
913 gethostlist(krb5_context context, const char *realm,
914 unsigned int type, char ***hostlist)
918 krb5_krbhst_handle handle;
919 char host[MAXHOSTNAMELEN];
920 krb5_krbhst_info *hostinfo;
922 ret = krb5_krbhst_init(context, realm, type, &handle);
926 while(krb5_krbhst_next(context, handle, &hostinfo) == 0)
929 krb5_set_error_message(context, KRB5_KDC_UNREACH,
930 N_("No KDC found for realm %s", ""), realm);
931 return KRB5_KDC_UNREACH;
933 *hostlist = calloc(nhost + 1, sizeof(**hostlist));
934 if(*hostlist == NULL) {
935 krb5_krbhst_free(context, handle);
939 krb5_krbhst_reset(context, handle);
941 while(krb5_krbhst_next_as_string(context, handle,
942 host, sizeof(host)) == 0) {
943 if(((*hostlist)[nhost++] = strdup(host)) == NULL) {
944 krb5_free_krbhst(context, *hostlist);
945 krb5_krbhst_free(context, handle);
949 (*hostlist)[nhost] = NULL;
950 krb5_krbhst_free(context, handle);
955 * return an malloced list of kadmin-hosts for `realm' in `hostlist'
958 krb5_error_code KRB5_LIB_FUNCTION
959 krb5_get_krb_admin_hst (krb5_context context,
960 const krb5_realm *realm,
963 return gethostlist(context, *realm, KRB5_KRBHST_ADMIN, hostlist);
967 * return an malloced list of changepw-hosts for `realm' in `hostlist'
970 krb5_error_code KRB5_LIB_FUNCTION
971 krb5_get_krb_changepw_hst (krb5_context context,
972 const krb5_realm *realm,
975 return gethostlist(context, *realm, KRB5_KRBHST_CHANGEPW, hostlist);
979 * return an malloced list of 524-hosts for `realm' in `hostlist'
982 krb5_error_code KRB5_LIB_FUNCTION
983 krb5_get_krb524hst (krb5_context context,
984 const krb5_realm *realm,
987 return gethostlist(context, *realm, KRB5_KRBHST_KRB524, hostlist);
992 * return an malloced list of KDC's for `realm' in `hostlist'
995 krb5_error_code KRB5_LIB_FUNCTION
996 krb5_get_krbhst (krb5_context context,
997 const krb5_realm *realm,
1000 return gethostlist(context, *realm, KRB5_KRBHST_KDC, hostlist);
1004 * free all the memory allocated in `hostlist'
1007 krb5_error_code KRB5_LIB_FUNCTION
1008 krb5_free_krbhst (krb5_context context,
1013 for (p = hostlist; *p; ++p)