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 _krb5_debug(context
, 0,
91 "DNS lookup failed domain: %s", domain
);
92 return KRB5_KDC_UNREACH
;
95 for(num_srv
= 0, rr
= r
->head
; rr
; rr
= rr
->next
)
96 if(rr
->type
== rk_ns_t_srv
)
99 *res
= malloc(num_srv
* sizeof(**res
));
102 krb5_set_error_message(context
, ENOMEM
,
103 N_("malloc: out of memory", ""));
109 for(num_srv
= 0, rr
= r
->head
; rr
; rr
= rr
->next
)
110 if(rr
->type
== rk_ns_t_srv
) {
111 krb5_krbhst_info
*hi
;
112 size_t len
= strlen(rr
->u
.srv
->target
);
114 hi
= calloc(1, sizeof(*hi
) + len
);
117 while(--num_srv
>= 0)
118 free((*res
)[num_srv
]);
123 (*res
)[num_srv
++] = hi
;
125 hi
->proto
= proto_num
;
127 hi
->def_port
= def_port
;
131 hi
->port
= rr
->u
.srv
->port
;
133 strlcpy(hi
->hostname
, rr
->u
.srv
->target
, len
+ 1);
143 struct krb5_krbhst_data
{
147 int port
; /* hardwired port number if != 0 */
151 #define KD_SRV_HTTP 8
152 #define KD_FALLBACK 16
153 #define KD_CONFIG_EXISTS 32
154 #define KD_LARGE_MSG 64
155 #define KD_PLUGIN 128
156 krb5_error_code (*get_next
)(krb5_context
, struct krb5_krbhst_data
*,
159 unsigned int fallback_count
;
161 struct krb5_krbhst_info
*hosts
, **index
, **end
;
165 krbhst_empty(const struct krb5_krbhst_data
*kd
)
167 return kd
->index
== &kd
->hosts
;
171 * Return the default protocol for the `kd' (either TCP or UDP)
175 krbhst_get_default_proto(struct krb5_krbhst_data
*kd
)
177 if (kd
->flags
& KD_LARGE_MSG
)
178 return KRB5_KRBHST_TCP
;
179 return KRB5_KRBHST_UDP
;
187 _krb5_krbhst_get_realm(krb5_krbhst_handle handle
)
189 return handle
->realm
;
193 * parse `spec' into a krb5_krbhst_info, defaulting the port to `def_port'
194 * and forcing it to `port' if port != 0
197 static struct krb5_krbhst_info
*
198 parse_hostspec(krb5_context context
, struct krb5_krbhst_data
*kd
,
199 const char *spec
, int def_port
, int port
)
201 const char *p
= spec
, *q
;
202 struct krb5_krbhst_info
*hi
;
204 hi
= calloc(1, sizeof(*hi
) + strlen(spec
));
208 hi
->proto
= krbhst_get_default_proto(kd
);
210 if(strncmp(p
, "http://", 7) == 0){
211 hi
->proto
= KRB5_KRBHST_HTTP
;
213 } else if(strncmp(p
, "http/", 5) == 0) {
214 hi
->proto
= KRB5_KRBHST_HTTP
;
216 def_port
= ntohs(krb5_getportbyname (context
, "http", "tcp", 80));
217 }else if(strncmp(p
, "tcp/", 4) == 0){
218 hi
->proto
= KRB5_KRBHST_TCP
;
220 } else if(strncmp(p
, "udp/", 4) == 0) {
224 if (p
[0] == '[' && (q
= strchr(p
, ']')) != NULL
) {
225 /* if address looks like [foo:bar] or [foo:bar]: its a ipv6
226 adress, strip of [] */
227 memcpy(hi
->hostname
, &p
[1], q
- p
- 1);
228 hi
->hostname
[q
- p
- 1] = '\0';
233 } else if(strsep_copy(&p
, ":", hi
->hostname
, strlen(spec
) + 1) < 0) {
234 /* copy everything before : */
238 /* get rid of trailing /, and convert to lower case */
239 hi
->hostname
[strcspn(hi
->hostname
, "/")] = '\0';
240 strlwr(hi
->hostname
);
242 hi
->port
= hi
->def_port
= def_port
;
243 if(p
!= NULL
&& p
[0]) {
245 hi
->port
= strtol(p
, &end
, 0);
257 _krb5_free_krbhst_info(krb5_krbhst_info
*hi
)
260 freeaddrinfo(hi
->ai
);
265 _krb5_krbhost_info_move(krb5_context context
,
266 krb5_krbhst_info
*from
,
267 krb5_krbhst_info
**to
)
269 size_t hostnamelen
= strlen(from
->hostname
);
270 /* trailing NUL is included in structure */
271 *to
= calloc(1, sizeof(**to
) + hostnamelen
);
273 krb5_set_error_message(context
, ENOMEM
,
274 N_("malloc: out of memory", ""));
278 (*to
)->proto
= from
->proto
;
279 (*to
)->port
= from
->port
;
280 (*to
)->def_port
= from
->def_port
;
281 (*to
)->ai
= from
->ai
;
284 memcpy((*to
)->hostname
, from
->hostname
, hostnamelen
+ 1);
290 append_host_hostinfo(struct krb5_krbhst_data
*kd
, struct krb5_krbhst_info
*host
)
292 struct krb5_krbhst_info
*h
;
294 for(h
= kd
->hosts
; h
; h
= h
->next
)
295 if(h
->proto
== host
->proto
&&
296 h
->port
== host
->port
&&
297 strcmp(h
->hostname
, host
->hostname
) == 0) {
298 _krb5_free_krbhst_info(host
);
302 kd
->end
= &host
->next
;
305 static krb5_error_code
306 append_host_string(krb5_context context
, struct krb5_krbhst_data
*kd
,
307 const char *host
, int def_port
, int port
)
309 struct krb5_krbhst_info
*hi
;
311 hi
= parse_hostspec(context
, kd
, host
, def_port
, port
);
315 append_host_hostinfo(kd
, hi
);
320 * return a readable representation of `host' in `hostname, hostlen'
323 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
324 krb5_krbhst_format_string(krb5_context context
, const krb5_krbhst_info
*host
,
325 char *hostname
, size_t hostlen
)
327 const char *proto
= "";
328 char portstr
[7] = "";
329 if(host
->proto
== KRB5_KRBHST_TCP
)
331 else if(host
->proto
== KRB5_KRBHST_HTTP
)
333 if(host
->port
!= host
->def_port
)
334 snprintf(portstr
, sizeof(portstr
), ":%d", host
->port
);
335 snprintf(hostname
, hostlen
, "%s%s%s", proto
, host
->hostname
, portstr
);
340 * create a getaddrinfo `hints' based on `proto'
344 make_hints(struct addrinfo
*hints
, int proto
)
346 memset(hints
, 0, sizeof(*hints
));
347 hints
->ai_family
= AF_UNSPEC
;
349 case KRB5_KRBHST_UDP
:
350 hints
->ai_socktype
= SOCK_DGRAM
;
352 case KRB5_KRBHST_HTTP
:
353 case KRB5_KRBHST_TCP
:
354 hints
->ai_socktype
= SOCK_STREAM
;
360 * Return an `struct addrinfo *' for a KDC host.
362 * Returns an the struct addrinfo in in that corresponds to the
363 * information in `host'. free:ing is handled by krb5_krbhst_free, so
364 * the returned ai must not be released.
369 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
370 krb5_krbhst_get_addrinfo(krb5_context context
, krb5_krbhst_info
*host
,
371 struct addrinfo
**ai
)
375 if (host
->ai
== NULL
) {
376 struct addrinfo hints
;
377 char portstr
[NI_MAXSERV
];
378 char *hostname
= host
->hostname
;
380 snprintf (portstr
, sizeof(portstr
), "%d", host
->port
);
381 make_hints(&hints
, host
->proto
);
384 * First try this as an IP address, this allows us to add a
385 * dot at the end to stop using the search domains.
388 hints
.ai_flags
|= AI_NUMERICHOST
| AI_NUMERICSERV
;
390 ret
= getaddrinfo(host
->hostname
, portstr
, &hints
, &host
->ai
);
395 * If the hostname contains a dot, assumes it's a FQDN and
396 * don't use search domains since that might be painfully slow
397 * when machine is disconnected from that network.
400 hints
.ai_flags
&= ~(AI_NUMERICHOST
);
402 if (strchr(hostname
, '.') && hostname
[strlen(hostname
) - 1] != '.') {
403 ret
= asprintf(&hostname
, "%s.", host
->hostname
);
404 if (ret
< 0 || hostname
== NULL
)
408 ret
= getaddrinfo(hostname
, portstr
, &hints
, &host
->ai
);
409 if (hostname
!= host
->hostname
)
412 ret
= krb5_eai_to_heim_errno(ret
, errno
);
422 get_next(struct krb5_krbhst_data
*kd
, krb5_krbhst_info
**host
)
424 struct krb5_krbhst_info
*hi
= *kd
->index
;
427 kd
->index
= &(*kd
->index
)->next
;
434 srv_get_hosts(krb5_context context
, struct krb5_krbhst_data
*kd
,
435 const char *proto
, const char *service
)
438 krb5_krbhst_info
**res
;
441 ret
= srv_find_realm(context
, &res
, &count
, kd
->realm
, "SRV", proto
, service
,
443 _krb5_debug(context
, 2, "searching DNS for realm %s %s.%s -> %d",
444 kd
->realm
, proto
, service
, ret
);
447 for(i
= 0; i
< count
; i
++)
448 append_host_hostinfo(kd
, res
[i
]);
453 * read the configuration for `conf_string', defaulting to kd->def_port and
454 * forcing it to `kd->port' if kd->port != 0
458 config_get_hosts(krb5_context context
, struct krb5_krbhst_data
*kd
,
459 const char *conf_string
)
463 hostlist
= krb5_config_get_strings(context
, NULL
,
464 "realms", kd
->realm
, conf_string
, NULL
);
466 _krb5_debug(context
, 2, "configuration file for realm %s%s found",
467 kd
->realm
, hostlist
? "" : " not");
471 kd
->flags
|= KD_CONFIG_EXISTS
;
472 for(i
= 0; hostlist
&& hostlist
[i
] != NULL
; i
++)
473 append_host_string(context
, kd
, hostlist
[i
], kd
->def_port
, kd
->port
);
475 krb5_config_free_strings(hostlist
);
479 * as a fallback, look for `serv_string.kd->realm' (typically
480 * kerberos.REALM, kerberos-1.REALM, ...
481 * `port' is the default port for the service, and `proto' the
485 static krb5_error_code
486 fallback_get_hosts(krb5_context context
, struct krb5_krbhst_data
*kd
,
487 const char *serv_string
, int port
, int proto
)
492 struct addrinfo hints
;
493 char portstr
[NI_MAXSERV
];
495 _krb5_debug(context
, 2, "fallback lookup %d for realm %s (service %s)",
496 kd
->fallback_count
, kd
->realm
, serv_string
);
499 * Don't try forever in case the DNS server keep returning us
500 * entries (like wildcard entries or the .nu TLD)
502 if(kd
->fallback_count
>= 5) {
503 kd
->flags
|= KD_FALLBACK
;
507 if(kd
->fallback_count
== 0)
508 ret
= asprintf(&host
, "%s.%s.", serv_string
, kd
->realm
);
510 ret
= asprintf(&host
, "%s-%d.%s.",
511 serv_string
, kd
->fallback_count
, kd
->realm
);
513 if (ret
< 0 || host
== NULL
)
516 make_hints(&hints
, proto
);
517 snprintf(portstr
, sizeof(portstr
), "%d", port
);
518 ret
= getaddrinfo(host
, portstr
, &hints
, &ai
);
520 /* no more hosts, so we're done here */
522 kd
->flags
|= KD_FALLBACK
;
524 struct krb5_krbhst_info
*hi
;
525 size_t hostlen
= strlen(host
);
527 hi
= calloc(1, sizeof(*hi
) + hostlen
);
534 hi
->port
= hi
->def_port
= port
;
536 memmove(hi
->hostname
, host
, hostlen
);
537 hi
->hostname
[hostlen
] = '\0';
539 append_host_hostinfo(kd
, hi
);
540 kd
->fallback_count
++;
546 * Fetch hosts from plugin
549 static krb5_error_code
550 add_locate(void *ctx
, int type
, struct sockaddr
*addr
)
552 struct krb5_krbhst_info
*hi
;
553 struct krb5_krbhst_data
*kd
= ctx
;
554 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
555 struct addrinfo hints
, *ai
;
560 socklen
= socket_sockaddr_size(addr
);
562 ret
= getnameinfo(addr
, socklen
, host
, sizeof(host
), port
, sizeof(port
),
563 NI_NUMERICHOST
|NI_NUMERICSERV
);
567 make_hints(&hints
, krbhst_get_default_proto(kd
));
568 ret
= getaddrinfo(host
, port
, &hints
, &ai
);
572 hostlen
= strlen(host
);
574 hi
= calloc(1, sizeof(*hi
) + hostlen
);
578 hi
->proto
= krbhst_get_default_proto(kd
);
579 hi
->port
= hi
->def_port
= socket_get_port(addr
);
581 memmove(hi
->hostname
, host
, hostlen
);
582 hi
->hostname
[hostlen
] = '\0';
583 append_host_hostinfo(kd
, hi
);
589 plugin_get_hosts(krb5_context context
,
590 struct krb5_krbhst_data
*kd
,
591 enum locate_service_type type
)
593 struct krb5_plugin
*list
= NULL
, *e
;
596 ret
= _krb5_plugin_find(context
, PLUGIN_TYPE_DATA
,
597 KRB5_PLUGIN_LOCATE
, &list
);
598 if(ret
!= 0 || list
== NULL
)
601 for (e
= list
; e
!= NULL
; e
= _krb5_plugin_get_next(e
)) {
602 krb5plugin_service_locate_ftable
*service
;
605 service
= _krb5_plugin_get_symbol(e
);
606 if (service
->minor_version
!= 0)
609 (*service
->init
)(context
, &ctx
);
610 ret
= (*service
->lookup
)(ctx
, type
, kd
->realm
, 0, 0, add_locate
, kd
);
611 (*service
->fini
)(ctx
);
612 if (ret
&& ret
!= KRB5_PLUGIN_NO_HANDLE
) {
613 krb5_set_error_message(context
, ret
,
614 N_("Locate plugin failed to lookup realm %s: %d", ""),
617 } else if (ret
== 0) {
618 _krb5_debug(context
, 2, "plugin found result for realm %s", kd
->realm
);
619 kd
->flags
|= KD_CONFIG_EXISTS
;
623 _krb5_plugin_free(list
);
630 static krb5_error_code
631 kdc_get_next(krb5_context context
,
632 struct krb5_krbhst_data
*kd
,
633 krb5_krbhst_info
**host
)
637 if ((kd
->flags
& KD_PLUGIN
) == 0) {
638 plugin_get_hosts(context
, kd
, locate_service_kdc
);
639 kd
->flags
|= KD_PLUGIN
;
640 if(get_next(kd
, host
))
644 if((kd
->flags
& KD_CONFIG
) == 0) {
645 config_get_hosts(context
, kd
, "kdc");
646 kd
->flags
|= KD_CONFIG
;
647 if(get_next(kd
, host
))
651 if (kd
->flags
& KD_CONFIG_EXISTS
) {
652 _krb5_debug(context
, 1,
653 "Configuration exists for realm %s, wont go to DNS",
655 return KRB5_KDC_UNREACH
;
658 if(context
->srv_lookup
) {
659 if((kd
->flags
& KD_SRV_UDP
) == 0 && (kd
->flags
& KD_LARGE_MSG
) == 0) {
660 srv_get_hosts(context
, kd
, "udp", "kerberos");
661 kd
->flags
|= KD_SRV_UDP
;
662 if(get_next(kd
, host
))
666 if((kd
->flags
& KD_SRV_TCP
) == 0) {
667 srv_get_hosts(context
, kd
, "tcp", "kerberos");
668 kd
->flags
|= KD_SRV_TCP
;
669 if(get_next(kd
, host
))
672 if((kd
->flags
& KD_SRV_HTTP
) == 0) {
673 srv_get_hosts(context
, kd
, "http", "kerberos");
674 kd
->flags
|= KD_SRV_HTTP
;
675 if(get_next(kd
, host
))
680 while((kd
->flags
& KD_FALLBACK
) == 0) {
681 ret
= fallback_get_hosts(context
, kd
, "kerberos",
683 krbhst_get_default_proto(kd
));
686 if(get_next(kd
, host
))
690 _krb5_debug(context
, 0, "No KDC entries found for %s", kd
->realm
);
692 return KRB5_KDC_UNREACH
; /* XXX */
695 static krb5_error_code
696 admin_get_next(krb5_context context
,
697 struct krb5_krbhst_data
*kd
,
698 krb5_krbhst_info
**host
)
702 if ((kd
->flags
& KD_PLUGIN
) == 0) {
703 plugin_get_hosts(context
, kd
, locate_service_kadmin
);
704 kd
->flags
|= KD_PLUGIN
;
705 if(get_next(kd
, host
))
709 if((kd
->flags
& KD_CONFIG
) == 0) {
710 config_get_hosts(context
, kd
, "admin_server");
711 kd
->flags
|= KD_CONFIG
;
712 if(get_next(kd
, host
))
716 if (kd
->flags
& KD_CONFIG_EXISTS
) {
717 _krb5_debug(context
, 1,
718 "Configuration exists for realm %s, wont go to DNS",
720 return KRB5_KDC_UNREACH
;
723 if(context
->srv_lookup
) {
724 if((kd
->flags
& KD_SRV_TCP
) == 0) {
725 srv_get_hosts(context
, kd
, "tcp", "kerberos-adm");
726 kd
->flags
|= KD_SRV_TCP
;
727 if(get_next(kd
, host
))
733 && (kd
->flags
& KD_FALLBACK
) == 0) {
734 ret
= fallback_get_hosts(context
, kd
, "kerberos",
736 krbhst_get_default_proto(kd
));
739 kd
->flags
|= KD_FALLBACK
;
740 if(get_next(kd
, host
))
744 _krb5_debug(context
, 0, "No admin entries found for realm %s", kd
->realm
);
746 return KRB5_KDC_UNREACH
; /* XXX */
749 static krb5_error_code
750 kpasswd_get_next(krb5_context context
,
751 struct krb5_krbhst_data
*kd
,
752 krb5_krbhst_info
**host
)
756 if ((kd
->flags
& KD_PLUGIN
) == 0) {
757 plugin_get_hosts(context
, kd
, locate_service_kpasswd
);
758 kd
->flags
|= KD_PLUGIN
;
759 if(get_next(kd
, host
))
763 if((kd
->flags
& KD_CONFIG
) == 0) {
764 config_get_hosts(context
, kd
, "kpasswd_server");
765 kd
->flags
|= KD_CONFIG
;
766 if(get_next(kd
, host
))
770 if (kd
->flags
& KD_CONFIG_EXISTS
) {
771 _krb5_debug(context
, 1,
772 "Configuration exists for realm %s, wont go to DNS",
774 return KRB5_KDC_UNREACH
;
777 if(context
->srv_lookup
) {
778 if((kd
->flags
& KD_SRV_UDP
) == 0) {
779 srv_get_hosts(context
, kd
, "udp", "kpasswd");
780 kd
->flags
|= KD_SRV_UDP
;
781 if(get_next(kd
, host
))
784 if((kd
->flags
& KD_SRV_TCP
) == 0) {
785 srv_get_hosts(context
, kd
, "tcp", "kpasswd");
786 kd
->flags
|= KD_SRV_TCP
;
787 if(get_next(kd
, host
))
792 /* no matches -> try admin */
794 if (krbhst_empty(kd
)) {
796 kd
->port
= kd
->def_port
;
797 kd
->get_next
= admin_get_next
;
798 ret
= (*kd
->get_next
)(context
, kd
, host
);
800 (*host
)->proto
= krbhst_get_default_proto(kd
);
804 _krb5_debug(context
, 0, "No kpasswd entries found for realm %s", kd
->realm
);
806 return KRB5_KDC_UNREACH
;
809 static krb5_error_code
810 krb524_get_next(krb5_context context
,
811 struct krb5_krbhst_data
*kd
,
812 krb5_krbhst_info
**host
)
814 if ((kd
->flags
& KD_PLUGIN
) == 0) {
815 plugin_get_hosts(context
, kd
, locate_service_krb524
);
816 kd
->flags
|= KD_PLUGIN
;
817 if(get_next(kd
, host
))
821 if((kd
->flags
& KD_CONFIG
) == 0) {
822 config_get_hosts(context
, kd
, "krb524_server");
823 if(get_next(kd
, host
))
825 kd
->flags
|= KD_CONFIG
;
828 if (kd
->flags
& KD_CONFIG_EXISTS
) {
829 _krb5_debug(context
, 1,
830 "Configuration exists for realm %s, wont go to DNS",
832 return KRB5_KDC_UNREACH
;
835 if(context
->srv_lookup
) {
836 if((kd
->flags
& KD_SRV_UDP
) == 0) {
837 srv_get_hosts(context
, kd
, "udp", "krb524");
838 kd
->flags
|= KD_SRV_UDP
;
839 if(get_next(kd
, host
))
843 if((kd
->flags
& KD_SRV_TCP
) == 0) {
844 srv_get_hosts(context
, kd
, "tcp", "krb524");
845 kd
->flags
|= KD_SRV_TCP
;
846 if(get_next(kd
, host
))
851 /* no matches -> try kdc */
853 if (krbhst_empty(kd
)) {
855 kd
->port
= kd
->def_port
;
856 kd
->get_next
= kdc_get_next
;
857 return (*kd
->get_next
)(context
, kd
, host
);
860 _krb5_debug(context
, 0, "No kpasswd entries found for realm %s", kd
->realm
);
862 return KRB5_KDC_UNREACH
;
865 static struct krb5_krbhst_data
*
866 common_init(krb5_context context
,
871 struct krb5_krbhst_data
*kd
;
873 if((kd
= calloc(1, sizeof(*kd
))) == NULL
)
876 if((kd
->realm
= strdup(realm
)) == NULL
) {
881 _krb5_debug(context
, 2, "Trying to find service %s for realm %s flags %x",
882 service
, realm
, flags
);
884 /* For 'realms' without a . do not even think of going to DNS */
885 if (!strchr(realm
, '.'))
886 kd
->flags
|= KD_CONFIG_EXISTS
;
888 if (flags
& KRB5_KRBHST_FLAGS_LARGE_MSG
)
889 kd
->flags
|= KD_LARGE_MSG
;
890 kd
->end
= kd
->index
= &kd
->hosts
;
895 * initialize `handle' to look for hosts of type `type' in realm `realm'
898 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
899 krb5_krbhst_init(krb5_context context
,
902 krb5_krbhst_handle
*handle
)
904 return krb5_krbhst_init_flags(context
, realm
, type
, 0, handle
);
907 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
908 krb5_krbhst_init_flags(krb5_context context
,
912 krb5_krbhst_handle
*handle
)
914 struct krb5_krbhst_data
*kd
;
915 krb5_error_code (*next
)(krb5_context
, struct krb5_krbhst_data
*,
916 krb5_krbhst_info
**);
921 case KRB5_KRBHST_KDC
:
923 def_port
= ntohs(krb5_getportbyname (context
, "kerberos", "udp", 88));
926 case KRB5_KRBHST_ADMIN
:
927 next
= admin_get_next
;
928 def_port
= ntohs(krb5_getportbyname (context
, "kerberos-adm",
932 case KRB5_KRBHST_CHANGEPW
:
933 next
= kpasswd_get_next
;
934 def_port
= ntohs(krb5_getportbyname (context
, "kpasswd", "udp",
936 service
= "change_password";
938 case KRB5_KRBHST_KRB524
:
939 next
= krb524_get_next
;
940 def_port
= ntohs(krb5_getportbyname (context
, "krb524", "udp", 4444));
944 krb5_set_error_message(context
, ENOTTY
,
945 N_("unknown krbhst type (%u)", ""), type
);
948 if((kd
= common_init(context
, service
, realm
, flags
)) == NULL
)
951 kd
->def_port
= def_port
;
957 * return the next host information from `handle' in `host'
960 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
961 krb5_krbhst_next(krb5_context context
,
962 krb5_krbhst_handle handle
,
963 krb5_krbhst_info
**host
)
965 if(get_next(handle
, host
))
968 return (*handle
->get_next
)(context
, handle
, host
);
972 * return the next host information from `handle' as a host name
973 * in `hostname' (or length `hostlen)
976 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
977 krb5_krbhst_next_as_string(krb5_context context
,
978 krb5_krbhst_handle handle
,
983 krb5_krbhst_info
*host
;
984 ret
= krb5_krbhst_next(context
, handle
, &host
);
987 return krb5_krbhst_format_string(context
, host
, hostname
, hostlen
);
991 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
992 krb5_krbhst_reset(krb5_context context
, krb5_krbhst_handle handle
)
994 handle
->index
= &handle
->hosts
;
997 KRB5_LIB_FUNCTION
void KRB5_LIB_CALL
998 krb5_krbhst_free(krb5_context context
, krb5_krbhst_handle handle
)
1000 krb5_krbhst_info
*h
, *next
;
1005 for (h
= handle
->hosts
; h
!= NULL
; h
= next
) {
1007 _krb5_free_krbhst_info(h
);
1010 free(handle
->realm
);
1014 /* backwards compatibility ahead */
1016 static krb5_error_code
1017 gethostlist(krb5_context context
, const char *realm
,
1018 unsigned int type
, char ***hostlist
)
1020 krb5_error_code ret
;
1022 krb5_krbhst_handle handle
;
1023 char host
[MAXHOSTNAMELEN
];
1024 krb5_krbhst_info
*hostinfo
;
1026 ret
= krb5_krbhst_init(context
, realm
, type
, &handle
);
1030 while(krb5_krbhst_next(context
, handle
, &hostinfo
) == 0)
1033 krb5_set_error_message(context
, KRB5_KDC_UNREACH
,
1034 N_("No KDC found for realm %s", ""), realm
);
1035 return KRB5_KDC_UNREACH
;
1037 *hostlist
= calloc(nhost
+ 1, sizeof(**hostlist
));
1038 if(*hostlist
== NULL
) {
1039 krb5_krbhst_free(context
, handle
);
1043 krb5_krbhst_reset(context
, handle
);
1045 while(krb5_krbhst_next_as_string(context
, handle
,
1046 host
, sizeof(host
)) == 0) {
1047 if(((*hostlist
)[nhost
++] = strdup(host
)) == NULL
) {
1048 krb5_free_krbhst(context
, *hostlist
);
1049 krb5_krbhst_free(context
, handle
);
1053 (*hostlist
)[nhost
] = NULL
;
1054 krb5_krbhst_free(context
, handle
);
1059 * return an malloced list of kadmin-hosts for `realm' in `hostlist'
1062 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1063 krb5_get_krb_admin_hst (krb5_context context
,
1064 const krb5_realm
*realm
,
1067 return gethostlist(context
, *realm
, KRB5_KRBHST_ADMIN
, hostlist
);
1071 * return an malloced list of changepw-hosts for `realm' in `hostlist'
1074 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1075 krb5_get_krb_changepw_hst (krb5_context context
,
1076 const krb5_realm
*realm
,
1079 return gethostlist(context
, *realm
, KRB5_KRBHST_CHANGEPW
, hostlist
);
1083 * return an malloced list of 524-hosts for `realm' in `hostlist'
1086 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1087 krb5_get_krb524hst (krb5_context context
,
1088 const krb5_realm
*realm
,
1091 return gethostlist(context
, *realm
, KRB5_KRBHST_KRB524
, hostlist
);
1096 * return an malloced list of KDC's for `realm' in `hostlist'
1099 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1100 krb5_get_krbhst (krb5_context context
,
1101 const krb5_realm
*realm
,
1104 return gethostlist(context
, *realm
, KRB5_KRBHST_KDC
, hostlist
);
1108 * free all the memory allocated in `hostlist'
1111 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1112 krb5_free_krbhst (krb5_context context
,
1117 for (p
= hostlist
; *p
; ++p
)