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
)