source4/heimdal/lib/krb5/krbhst.c

   1 /*
   2  * Copyright (c) 2001 - 2003 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  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.
  16  *
  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.
  20  *
  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.
  32  */
  33
  34 #include "krb5_locl.h"
  35 #include <resolve.h>
  36 #include "locate_plugin.h"
  37
  38 static int
  39 string_to_proto(const char *string)
  40 {
  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;
  47     return -1;
  48 }
  49
  50 /*
  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
  54  */
  55
  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)
  60 {
  61     char domain[1024];
  62     struct rk_dns_reply *r;
  63     struct rk_resource_record *rr;
  64     int num_srv;
  65     int proto_num;
  66     int def_port;
  67
  68     *res = NULL;
  69     *count = 0;
  70
  71     proto_num = string_to_proto(proto);
  72     if(proto_num < 0) {
  73         krb5_set_error_message(context, EINVAL,
  74                                N_("unknown protocol `%s' to lookup", ""),
  75                                proto);
  76         return EINVAL;
  77     }
  78
  79     if(proto_num == KRB5_KRBHST_HTTP)
  80         def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
  81     else if(port == 0)
  82         def_port = ntohs(krb5_getportbyname (context, service, proto, 88));
  83     else
  84         def_port = port;
  85
  86     snprintf(domain, sizeof(domain), "_%s._%s.%s.", service, proto, realm);
  87
  88     r = rk_dns_lookup(domain, dns_type);
  89     if(r == NULL) {
  90         _krb5_debug(context, 0,
  91                     "DNS lookup failed domain: %s", domain);
  92         return KRB5_KDC_UNREACH;
  93     }
  94
  95     for(num_srv = 0, rr = r->head; rr; rr = rr->next)
  96         if(rr->type == rk_ns_t_srv)
  97             num_srv++;
  98
  99     *res = malloc(num_srv * sizeof(**res));
 100     if(*res == NULL) {
 101         rk_dns_free_data(r);
 102         krb5_set_error_message(context, ENOMEM,
 103                                N_("malloc: out of memory", ""));
 104         return ENOMEM;
 105     }
 106
 107     rk_dns_srv_order(r);
 108
 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);
 113
 114             hi = calloc(1, sizeof(*hi) + len);
 115             if(hi == NULL) {
 116                 rk_dns_free_data(r);
 117                 while(--num_srv >= 0)
 118                     free((*res)[num_srv]);
 119                 free(*res);
 120                 *res = NULL;
 121                 return ENOMEM;
 122             }
 123             (*res)[num_srv++] = hi;
 124
 125             hi->proto = proto_num;
 126
 127             hi->def_port = def_port;
 128             if (port != 0)
 129                 hi->port = port;
 130             else
 131                 hi->port = rr->u.srv->port;
 132
 133             strlcpy(hi->hostname, rr->u.srv->target, len + 1);
 134         }
 135
 136     *count = num_srv;
 137
 138     rk_dns_free_data(r);
 139     return 0;
 140 }
 141
 142
 143 struct krb5_krbhst_data {
 144     char *realm;
 145     unsigned int flags;
 146     int def_port;
 147     int port;                   /* hardwired port number if != 0 */
 148 #define KD_CONFIG                1
 149 #define KD_SRV_UDP               2
 150 #define KD_SRV_TCP               4
 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 *,
 157                                 krb5_krbhst_info**);
 158
 159     unsigned int fallback_count;
 160
 161     struct krb5_krbhst_info *hosts, **index, **end;
 162 };
 163
 164 static krb5_boolean
 165 krbhst_empty(const struct krb5_krbhst_data *kd)
 166 {
 167     return kd->index == &kd->hosts;
 168 }
 169
 170 /*
 171  * Return the default protocol for the `kd' (either TCP or UDP)
 172  */
 173
 174 static int
 175 krbhst_get_default_proto(struct krb5_krbhst_data *kd)
 176 {
 177     if (kd->flags & KD_LARGE_MSG)
 178         return KRB5_KRBHST_TCP;
 179     return KRB5_KRBHST_UDP;
 180 }
 181
 182 /*
 183  *
 184  */
 185
 186 const char *
 187 _krb5_krbhst_get_realm(krb5_krbhst_handle handle)
 188 {
 189     return handle->realm;
 190 }
 191
 192 /*
 193  * parse `spec' into a krb5_krbhst_info, defaulting the port to `def_port'
 194  * and forcing it to `port' if port != 0
 195  */
 196
 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)
 200 {
 201     const char *p = spec, *q;
 202     struct krb5_krbhst_info *hi;
 203
 204     hi = calloc(1, sizeof(*hi) + strlen(spec));
 205     if(hi == NULL)
 206         return NULL;
 207
 208     hi->proto = krbhst_get_default_proto(kd);
 209
 210     if(strncmp(p, "http://", 7) == 0){
 211         hi->proto = KRB5_KRBHST_HTTP;
 212         p += 7;
 213     } else if(strncmp(p, "http/", 5) == 0) {
 214         hi->proto = KRB5_KRBHST_HTTP;
 215         p += 5;
 216         def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80));
 217     }else if(strncmp(p, "tcp/", 4) == 0){
 218         hi->proto = KRB5_KRBHST_TCP;
 219         p += 4;
 220     } else if(strncmp(p, "udp/", 4) == 0) {
 221         p += 4;
 222     }
 223
 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';
 229         p = q + 1;
 230         /* get trailing : */
 231         if (p[0] == ':')
 232             p++;
 233     } else if(strsep_copy(&p, ":", hi->hostname, strlen(spec) + 1) < 0) {
 234         /* copy everything before : */
 235         free(hi);
 236         return NULL;
 237     }
 238     /* get rid of trailing /, and convert to lower case */
 239     hi->hostname[strcspn(hi->hostname, "/")] = '\0';
 240     strlwr(hi->hostname);
 241
 242     hi->port = hi->def_port = def_port;
 243     if(p != NULL && p[0]) {
 244         char *end;
 245         hi->port = strtol(p, &end, 0);
 246         if(end == p) {
 247             free(hi);
 248             return NULL;
 249         }
 250     }
 251     if (port)
 252         hi->port = port;
 253     return hi;
 254 }
 255
 256 void
 257 _krb5_free_krbhst_info(krb5_krbhst_info *hi)
 258 {
 259     if (hi->ai != NULL)
 260         freeaddrinfo(hi->ai);
 261     free(hi);
 262 }
 263
 264 krb5_error_code
 265 _krb5_krbhost_info_move(krb5_context context,
 266                         krb5_krbhst_info *from,
 267                         krb5_krbhst_info **to)
 268 {
 269     size_t hostnamelen = strlen(from->hostname);
 270     /* trailing NUL is included in structure */
 271     *to = calloc(1, sizeof(**to) + hostnamelen);
 272     if(*to == NULL) {
 273         krb5_set_error_message(context, ENOMEM,
 274                                N_("malloc: out of memory", ""));
 275         return ENOMEM;
 276     }
 277
 278     (*to)->proto = from->proto;
 279     (*to)->port = from->port;
 280     (*to)->def_port = from->def_port;
 281     (*to)->ai = from->ai;
 282     from->ai = NULL;
 283     (*to)->next = NULL;
 284     memcpy((*to)->hostname, from->hostname, hostnamelen + 1);
 285     return 0;
 286 }
 287
 288
 289 static void
 290 append_host_hostinfo(struct krb5_krbhst_data *kd, struct krb5_krbhst_info *host)
 291 {
 292     struct krb5_krbhst_info *h;
 293
 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);
 299             return;
 300         }
 301     *kd->end = host;
 302     kd->end = &host->next;
 303 }
 304
 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)
 308 {
 309     struct krb5_krbhst_info *hi;
 310
 311     hi = parse_hostspec(context, kd, host, def_port, port);
 312     if(hi == NULL)
 313         return ENOMEM;
 314
 315     append_host_hostinfo(kd, hi);
 316     return 0;
 317 }
 318
 319 /*
 320  * return a readable representation of `host' in `hostname, hostlen'
 321  */
 322
 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)
 326 {
 327     const char *proto = "";
 328     char portstr[7] = "";
 329     if(host->proto == KRB5_KRBHST_TCP)
 330         proto = "tcp/";
 331     else if(host->proto == KRB5_KRBHST_HTTP)
 332         proto = "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);
 336     return 0;
 337 }
 338
 339 /*
 340  * create a getaddrinfo `hints' based on `proto'
 341  */
 342
 343 static void
 344 make_hints(struct addrinfo *hints, int proto)
 345 {
 346     memset(hints, 0, sizeof(*hints));
 347     hints->ai_family = AF_UNSPEC;
 348     switch(proto) {
 349     case KRB5_KRBHST_UDP :
 350         hints->ai_socktype = SOCK_DGRAM;
 351         break;
 352     case KRB5_KRBHST_HTTP :
 353     case KRB5_KRBHST_TCP :
 354         hints->ai_socktype = SOCK_STREAM;
 355         break;
 356     }
 357 }
 358
 359 /*
 360  * return an `struct addrinfo *' in `ai' corresponding to the information
 361  * in `host'.  free:ing is handled by krb5_krbhst_free.
 362  */
 363
 364 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
 365 krb5_krbhst_get_addrinfo(krb5_context context, krb5_krbhst_info *host,
 366                          struct addrinfo **ai)
 367 {
 368     struct addrinfo hints;
 369     char portstr[NI_MAXSERV];
 370     int ret;
 371
 372     if (host->ai == NULL) {
 373         char *hostname_dot = NULL;
 374         make_hints(&hints, host->proto);
 375         snprintf (portstr, sizeof(portstr), "%d", host->port);
 376         if (strchr(host->hostname, '.') &&
 377             host->hostname[strlen(host->hostname)-1] != '.') {
 378                 /* avoid expansion of search domains from resolv.conf
 379                    - these can be very slow if the DNS server is not up
 380                    for the searched domain */
 381                 hostname_dot = malloc(strlen(host->hostname)+2);
 382                 if (hostname_dot) {
 383                         strcpy(hostname_dot, host->hostname);
 384                         hostname_dot[strlen(host->hostname)] = '.';
 385                         hostname_dot[strlen(host->hostname)+1] = 0;
 386                 }
 387         }
 388         ret = getaddrinfo(hostname_dot?hostname_dot:host->hostname, portstr, &hints, &host->ai);
 389         if (hostname_dot)
 390                 free(hostname_dot);
 391         if (ret)
 392             return krb5_eai_to_heim_errno(ret, errno);
 393     }
 394     *ai = host->ai;
 395     return 0;
 396 }
 397
 398 static krb5_boolean
 399 get_next(struct krb5_krbhst_data *kd, krb5_krbhst_info **host)
 400 {
 401     struct krb5_krbhst_info *hi = *kd->index;
 402     if(hi != NULL) {
 403         *host = hi;
 404         kd->index = &(*kd->index)->next;
 405         return TRUE;
 406     }
 407     return FALSE;
 408 }
 409
 410 static void
 411 srv_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
 412               const char *proto, const char *service)
 413 {
 414     krb5_error_code ret;
 415     krb5_krbhst_info **res;
 416     int count, i;
 417
 418     ret = srv_find_realm(context, &res, &count, kd->realm, "SRV", proto, service,
 419                          kd->port);
 420     _krb5_debug(context, 2, "searching DNS for realm %s %s.%s -> %d",
 421                 kd->realm, proto, service, ret);
 422     if (ret)
 423         return;
 424     for(i = 0; i < count; i++)
 425         append_host_hostinfo(kd, res[i]);
 426     free(res);
 427 }
 428
 429 /*
 430  * read the configuration for `conf_string', defaulting to kd->def_port and
 431  * forcing it to `kd->port' if kd->port != 0
 432  */
 433
 434 static void
 435 config_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
 436                  const char *conf_string)
 437 {
 438     int i;
 439     char **hostlist;
 440     hostlist = krb5_config_get_strings(context, NULL,
 441                                        "realms", kd->realm, conf_string, NULL);
 442
 443     _krb5_debug(context, 2, "configuration file for realm %s%s found",
 444                 kd->realm, hostlist ? "" : " not");
 445
 446     if(hostlist == NULL)
 447         return;
 448     kd->flags |= KD_CONFIG_EXISTS;
 449     for(i = 0; hostlist && hostlist[i] != NULL; i++)
 450         append_host_string(context, kd, hostlist[i], kd->def_port, kd->port);
 451
 452     krb5_config_free_strings(hostlist);
 453 }
 454
 455 /*
 456  * as a fallback, look for `serv_string.kd->realm' (typically
 457  * kerberos.REALM, kerberos-1.REALM, ...
 458  * `port' is the default port for the service, and `proto' the
 459  * protocol
 460  */
 461
 462 static krb5_error_code
 463 fallback_get_hosts(krb5_context context, struct krb5_krbhst_data *kd,
 464                    const char *serv_string, int port, int proto)
 465 {
 466     char *host;
 467     int ret;
 468     struct addrinfo *ai;
 469     struct addrinfo hints;
 470     char portstr[NI_MAXSERV];
 471
 472     _krb5_debug(context, 2, "fallback lookup %d for realm %s (service %s)",
 473                 kd->fallback_count, kd->realm, serv_string);
 474
 475     /*
 476      * Don't try forever in case the DNS server keep returning us
 477      * entries (like wildcard entries or the .nu TLD)
 478      */
 479     if(kd->fallback_count >= 5) {
 480         kd->flags |= KD_FALLBACK;
 481         return 0;
 482     }
 483
 484     if(kd->fallback_count == 0)
 485         asprintf(&host, "%s.%s.", serv_string, kd->realm);
 486     else
 487         asprintf(&host, "%s-%d.%s.",
 488                  serv_string, kd->fallback_count, kd->realm);
 489
 490     if (host == NULL)
 491         return ENOMEM;
 492
 493     make_hints(&hints, proto);
 494     snprintf(portstr, sizeof(portstr), "%d", port);
 495     ret = getaddrinfo(host, portstr, &hints, &ai);
 496     if (ret) {
 497         /* no more hosts, so we're done here */
 498         free(host);
 499         kd->flags |= KD_FALLBACK;
 500     } else {
 501         struct krb5_krbhst_info *hi;
 502         size_t hostlen = strlen(host);
 503
 504         hi = calloc(1, sizeof(*hi) + hostlen);
 505         if(hi == NULL) {
 506             free(host);
 507             return ENOMEM;
 508         }
 509
 510         hi->proto = proto;
 511         hi->port  = hi->def_port = port;
 512         hi->ai    = ai;
 513         memmove(hi->hostname, host, hostlen);
 514         hi->hostname[hostlen] = '\0';
 515         free(host);
 516         append_host_hostinfo(kd, hi);
 517         kd->fallback_count++;
 518     }
 519     return 0;
 520 }
 521
 522 /*
 523  * Fetch hosts from plugin
 524  */
 525
 526 static krb5_error_code
 527 add_locate(void *ctx, int type, struct sockaddr *addr)
 528 {
 529     struct krb5_krbhst_info *hi;
 530     struct krb5_krbhst_data *kd = ctx;
 531     char host[NI_MAXHOST], port[NI_MAXSERV];
 532     struct addrinfo hints, *ai;
 533     socklen_t socklen;
 534     size_t hostlen;
 535     int ret;
 536
 537     socklen = socket_sockaddr_size(addr);
 538
 539     ret = getnameinfo(addr, socklen, host, sizeof(host), port, sizeof(port),
 540                       NI_NUMERICHOST|NI_NUMERICSERV);
 541     if (ret != 0)
 542         return 0;
 543
 544     make_hints(&hints, krbhst_get_default_proto(kd));
 545     ret = getaddrinfo(host, port, &hints, &ai);
 546     if (ret)
 547         return 0;
 548
 549     hostlen = strlen(host);
 550
 551     hi = calloc(1, sizeof(*hi) + hostlen);
 552     if(hi == NULL)
 553         return ENOMEM;
 554
 555     hi->proto = krbhst_get_default_proto(kd);
 556     hi->port  = hi->def_port = socket_get_port(addr);
 557     hi->ai    = ai;
 558     memmove(hi->hostname, host, hostlen);
 559     hi->hostname[hostlen] = '\0';
 560     append_host_hostinfo(kd, hi);
 561
 562     return 0;
 563 }
 564
 565 static void
 566 plugin_get_hosts(krb5_context context,
 567                  struct krb5_krbhst_data *kd,
 568                  enum locate_service_type type)
 569 {
 570     struct krb5_plugin *list = NULL, *e;
 571     krb5_error_code ret;
 572
 573     ret = _krb5_plugin_find(context, PLUGIN_TYPE_DATA,
 574                             KRB5_PLUGIN_LOCATE, &list);
 575     if(ret != 0 || list == NULL)
 576         return;
 577
 578     for (e = list; e != NULL; e = _krb5_plugin_get_next(e)) {
 579         krb5plugin_service_locate_ftable *service;
 580         void *ctx;
 581
 582         service = _krb5_plugin_get_symbol(e);
 583         if (service->minor_version != 0)
 584             continue;
 585
 586         (*service->init)(context, &ctx);
 587         ret = (*service->lookup)(ctx, type, kd->realm, 0, 0, add_locate, kd);
 588         (*service->fini)(ctx);
 589         if (ret && ret != KRB5_PLUGIN_NO_HANDLE) {
 590             krb5_set_error_message(context, ret,
 591                                    N_("Locate plugin failed to lookup realm %s: %d", ""),
 592                                    kd->realm, ret);
 593             break;
 594         } else if (ret == 0) {
 595             _krb5_debug(context, 2, "plugin found result for realm %s", kd->realm);
 596             kd->flags |= KD_CONFIG_EXISTS;
 597         }
 598
 599     }
 600     _krb5_plugin_free(list);
 601 }
 602
 603 /*
 604  *
 605  */
 606
 607 static krb5_error_code
 608 kdc_get_next(krb5_context context,
 609              struct krb5_krbhst_data *kd,
 610              krb5_krbhst_info **host)
 611 {
 612     krb5_error_code ret;
 613
 614     if ((kd->flags & KD_PLUGIN) == 0) {
 615         plugin_get_hosts(context, kd, locate_service_kdc);
 616         kd->flags |= KD_PLUGIN;
 617         if(get_next(kd, host))
 618             return 0;
 619     }
 620
 621     if((kd->flags & KD_CONFIG) == 0) {
 622         config_get_hosts(context, kd, "kdc");
 623         kd->flags |= KD_CONFIG;
 624         if(get_next(kd, host))
 625             return 0;
 626     }
 627
 628     if (kd->flags & KD_CONFIG_EXISTS) {
 629         _krb5_debug(context, 1,
 630                     "Configuration exists for realm %s, wont go to DNS",
 631                     kd->realm);
 632         return KRB5_KDC_UNREACH;
 633     }
 634
 635     if(context->srv_lookup) {
 636         if((kd->flags & KD_SRV_UDP) == 0 && (kd->flags & KD_LARGE_MSG) == 0) {
 637             srv_get_hosts(context, kd, "udp", "kerberos");
 638             kd->flags |= KD_SRV_UDP;
 639             if(get_next(kd, host))
 640                 return 0;
 641         }
 642
 643         if((kd->flags & KD_SRV_TCP) == 0) {
 644             srv_get_hosts(context, kd, "tcp", "kerberos");
 645             kd->flags |= KD_SRV_TCP;
 646             if(get_next(kd, host))
 647                 return 0;
 648         }
 649         if((kd->flags & KD_SRV_HTTP) == 0) {
 650             srv_get_hosts(context, kd, "http", "kerberos");
 651             kd->flags |= KD_SRV_HTTP;
 652             if(get_next(kd, host))
 653                 return 0;
 654         }
 655     }
 656
 657     while((kd->flags & KD_FALLBACK) == 0) {
 658         ret = fallback_get_hosts(context, kd, "kerberos",
 659                                  kd->def_port,
 660                                  krbhst_get_default_proto(kd));
 661         if(ret)
 662             return ret;
 663         if(get_next(kd, host))
 664             return 0;
 665     }
 666
 667     _krb5_debug(context, 0, "No KDC entries found for %s", kd->realm);
 668
 669     return KRB5_KDC_UNREACH; /* XXX */
 670 }
 671
 672 static krb5_error_code
 673 admin_get_next(krb5_context context,
 674                struct krb5_krbhst_data *kd,
 675                krb5_krbhst_info **host)
 676 {
 677     krb5_error_code ret;
 678
 679     if ((kd->flags & KD_PLUGIN) == 0) {
 680         plugin_get_hosts(context, kd, locate_service_kadmin);
 681         kd->flags |= KD_PLUGIN;
 682         if(get_next(kd, host))
 683             return 0;
 684     }
 685
 686     if((kd->flags & KD_CONFIG) == 0) {
 687         config_get_hosts(context, kd, "admin_server");
 688         kd->flags |= KD_CONFIG;
 689         if(get_next(kd, host))
 690             return 0;
 691     }
 692
 693     if (kd->flags & KD_CONFIG_EXISTS) {
 694         _krb5_debug(context, 1,
 695                     "Configuration exists for realm %s, wont go to DNS",
 696                     kd->realm);
 697         return KRB5_KDC_UNREACH;
 698     }
 699
 700     if(context->srv_lookup) {
 701         if((kd->flags & KD_SRV_TCP) == 0) {
 702             srv_get_hosts(context, kd, "tcp", "kerberos-adm");
 703             kd->flags |= KD_SRV_TCP;
 704             if(get_next(kd, host))
 705                 return 0;
 706         }
 707     }
 708
 709     if (krbhst_empty(kd)
 710         && (kd->flags & KD_FALLBACK) == 0) {
 711         ret = fallback_get_hosts(context, kd, "kerberos",
 712                                  kd->def_port,
 713                                  krbhst_get_default_proto(kd));
 714         if(ret)
 715             return ret;
 716         kd->flags |= KD_FALLBACK;
 717         if(get_next(kd, host))
 718             return 0;
 719     }
 720
 721     _krb5_debug(context, 0, "No admin entries found for realm %s", kd->realm);
 722
 723     return KRB5_KDC_UNREACH;    /* XXX */
 724 }
 725
 726 static krb5_error_code
 727 kpasswd_get_next(krb5_context context,
 728                  struct krb5_krbhst_data *kd,
 729                  krb5_krbhst_info **host)
 730 {
 731     krb5_error_code ret;
 732
 733     if ((kd->flags & KD_PLUGIN) == 0) {
 734         plugin_get_hosts(context, kd, locate_service_kpasswd);
 735         kd->flags |= KD_PLUGIN;
 736         if(get_next(kd, host))
 737             return 0;
 738     }
 739
 740     if((kd->flags & KD_CONFIG) == 0) {
 741         config_get_hosts(context, kd, "kpasswd_server");
 742         kd->flags |= KD_CONFIG;
 743         if(get_next(kd, host))
 744             return 0;
 745     }
 746
 747     if (kd->flags & KD_CONFIG_EXISTS) {
 748         _krb5_debug(context, 1,
 749                     "Configuration exists for realm %s, wont go to DNS",
 750                     kd->realm);
 751         return KRB5_KDC_UNREACH;
 752     }
 753
 754     if(context->srv_lookup) {
 755         if((kd->flags & KD_SRV_UDP) == 0) {
 756             srv_get_hosts(context, kd, "udp", "kpasswd");
 757             kd->flags |= KD_SRV_UDP;
 758             if(get_next(kd, host))
 759                 return 0;
 760         }
 761         if((kd->flags & KD_SRV_TCP) == 0) {
 762             srv_get_hosts(context, kd, "tcp", "kpasswd");
 763             kd->flags |= KD_SRV_TCP;
 764             if(get_next(kd, host))
 765                 return 0;
 766         }
 767     }
 768
 769     /* no matches -> try admin */
 770
 771     if (krbhst_empty(kd)) {
 772         kd->flags = 0;
 773         kd->port  = kd->def_port;
 774         kd->get_next = admin_get_next;
 775         ret = (*kd->get_next)(context, kd, host);
 776         if (ret == 0)
 777             (*host)->proto = krbhst_get_default_proto(kd);
 778         return ret;
 779     }
 780
 781     _krb5_debug(context, 0, "No kpasswd entries found for realm %s", kd->realm);
 782
 783     return KRB5_KDC_UNREACH;
 784 }
 785
 786 static krb5_error_code
 787 krb524_get_next(krb5_context context,
 788                 struct krb5_krbhst_data *kd,
 789                 krb5_krbhst_info **host)
 790 {
 791     if ((kd->flags & KD_PLUGIN) == 0) {
 792         plugin_get_hosts(context, kd, locate_service_krb524);
 793         kd->flags |= KD_PLUGIN;
 794         if(get_next(kd, host))
 795             return 0;
 796     }
 797
 798     if((kd->flags & KD_CONFIG) == 0) {
 799         config_get_hosts(context, kd, "krb524_server");
 800         if(get_next(kd, host))
 801             return 0;
 802         kd->flags |= KD_CONFIG;
 803     }
 804
 805     if (kd->flags & KD_CONFIG_EXISTS) {
 806         _krb5_debug(context, 1,
 807                     "Configuration exists for realm %s, wont go to DNS",
 808                     kd->realm);
 809         return KRB5_KDC_UNREACH;
 810     }
 811
 812     if(context->srv_lookup) {
 813         if((kd->flags & KD_SRV_UDP) == 0) {
 814             srv_get_hosts(context, kd, "udp", "krb524");
 815             kd->flags |= KD_SRV_UDP;
 816             if(get_next(kd, host))
 817                 return 0;
 818         }
 819
 820         if((kd->flags & KD_SRV_TCP) == 0) {
 821             srv_get_hosts(context, kd, "tcp", "krb524");
 822             kd->flags |= KD_SRV_TCP;
 823             if(get_next(kd, host))
 824                 return 0;
 825         }
 826     }
 827
 828     /* no matches -> try kdc */
 829
 830     if (krbhst_empty(kd)) {
 831         kd->flags = 0;
 832         kd->port  = kd->def_port;
 833         kd->get_next = kdc_get_next;
 834         return (*kd->get_next)(context, kd, host);
 835     }
 836
 837     _krb5_debug(context, 0, "No kpasswd entries found for realm %s", kd->realm);
 838
 839     return KRB5_KDC_UNREACH;
 840 }
 841
 842 static struct krb5_krbhst_data*
 843 common_init(krb5_context context,
 844             const char *service,
 845             const char *realm,
 846             int flags)
 847 {
 848     struct krb5_krbhst_data *kd;
 849
 850     if((kd = calloc(1, sizeof(*kd))) == NULL)
 851         return NULL;
 852
 853     if((kd->realm = strdup(realm)) == NULL) {
 854         free(kd);
 855         return NULL;
 856     }
 857
 858     _krb5_debug(context, 2, "Trying to find service %s for realm %s flags %x",
 859                 service, realm, flags);
 860
 861     /* For 'realms' without a . do not even think of going to DNS */
 862     if (!strchr(realm, '.'))
 863         kd->flags |= KD_CONFIG_EXISTS;
 864
 865     if (flags & KRB5_KRBHST_FLAGS_LARGE_MSG)
 866         kd->flags |= KD_LARGE_MSG;
 867     kd->end = kd->index = &kd->hosts;
 868     return kd;
 869 }
 870
 871 /*
 872  * initialize `handle' to look for hosts of type `type' in realm `realm'
 873  */
 874
 875 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
 876 krb5_krbhst_init(krb5_context context,
 877                  const char *realm,
 878                  unsigned int type,
 879                  krb5_krbhst_handle *handle)
 880 {
 881     return krb5_krbhst_init_flags(context, realm, type, 0, handle);
 882 }
 883
 884 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
 885 krb5_krbhst_init_flags(krb5_context context,
 886                        const char *realm,
 887                        unsigned int type,
 888                        int flags,
 889                        krb5_krbhst_handle *handle)
 890 {
 891     struct krb5_krbhst_data *kd;
 892     krb5_error_code (*next)(krb5_context, struct krb5_krbhst_data *,
 893                             krb5_krbhst_info **);
 894     int def_port;
 895     const char *service;
 896
 897     switch(type) {
 898     case KRB5_KRBHST_KDC:
 899         next = kdc_get_next;
 900         def_port = ntohs(krb5_getportbyname (context, "kerberos", "udp", 88));
 901         service = "kdc";
 902         break;
 903     case KRB5_KRBHST_ADMIN:
 904         next = admin_get_next;
 905         def_port = ntohs(krb5_getportbyname (context, "kerberos-adm",
 906                                              "tcp", 749));
 907         service = "admin";
 908         break;
 909     case KRB5_KRBHST_CHANGEPW:
 910         next = kpasswd_get_next;
 911         def_port = ntohs(krb5_getportbyname (context, "kpasswd", "udp",
 912                                              KPASSWD_PORT));
 913         service = "change_password";
 914         break;
 915     case KRB5_KRBHST_KRB524:
 916         next = krb524_get_next;
 917         def_port = ntohs(krb5_getportbyname (context, "krb524", "udp", 4444));
 918         service = "524";
 919         break;
 920     default:
 921         krb5_set_error_message(context, ENOTTY,
 922                                N_("unknown krbhst type (%u)", ""), type);
 923         return ENOTTY;
 924     }
 925     if((kd = common_init(context, service, realm, flags)) == NULL)
 926         return ENOMEM;
 927     kd->get_next = next;
 928     kd->def_port = def_port;
 929     *handle = kd;
 930     return 0;
 931 }
 932
 933 /*
 934  * return the next host information from `handle' in `host'
 935  */
 936
 937 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
 938 krb5_krbhst_next(krb5_context context,
 939                  krb5_krbhst_handle handle,
 940                  krb5_krbhst_info **host)
 941 {
 942     if(get_next(handle, host))
 943         return 0;
 944
 945     return (*handle->get_next)(context, handle, host);
 946 }
 947
 948 /*
 949  * return the next host information from `handle' as a host name
 950  * in `hostname' (or length `hostlen)
 951  */
 952
 953 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
 954 krb5_krbhst_next_as_string(krb5_context context,
 955                            krb5_krbhst_handle handle,
 956                            char *hostname,
 957                            size_t hostlen)
 958 {
 959     krb5_error_code ret;
 960     krb5_krbhst_info *host;
 961     ret = krb5_krbhst_next(context, handle, &host);
 962     if(ret)
 963         return ret;
 964     return krb5_krbhst_format_string(context, host, hostname, hostlen);
 965 }
 966
 967
 968 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
 969 krb5_krbhst_reset(krb5_context context, krb5_krbhst_handle handle)
 970 {
 971     handle->index = &handle->hosts;
 972 }
 973
 974 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
 975 krb5_krbhst_free(krb5_context context, krb5_krbhst_handle handle)
 976 {
 977     krb5_krbhst_info *h, *next;
 978
 979     if (handle == NULL)
 980         return;
 981
 982     for (h = handle->hosts; h != NULL; h = next) {
 983         next = h->next;
 984         _krb5_free_krbhst_info(h);
 985     }
 986
 987     free(handle->realm);
 988     free(handle);
 989 }
 990
 991 /* backwards compatibility ahead */
 992
 993 static krb5_error_code
 994 gethostlist(krb5_context context, const char *realm,
 995             unsigned int type, char ***hostlist)
 996 {
 997     krb5_error_code ret;
 998     int nhost = 0;
 999     krb5_krbhst_handle handle;
1000     char host[MAXHOSTNAMELEN];
1001     krb5_krbhst_info *hostinfo;
1002
1003     ret = krb5_krbhst_init(context, realm, type, &handle);
1004     if (ret)
1005         return ret;
1006
1007     while(krb5_krbhst_next(context, handle, &hostinfo) == 0)
1008         nhost++;
1009     if(nhost == 0) {
1010         krb5_set_error_message(context, KRB5_KDC_UNREACH,
1011                                N_("No KDC found for realm %s", ""), realm);
1012         return KRB5_KDC_UNREACH;
1013     }
1014     *hostlist = calloc(nhost + 1, sizeof(**hostlist));
1015     if(*hostlist == NULL) {
1016         krb5_krbhst_free(context, handle);
1017         return ENOMEM;
1018     }
1019
1020     krb5_krbhst_reset(context, handle);
1021     nhost = 0;
1022     while(krb5_krbhst_next_as_string(context, handle,
1023                                      host, sizeof(host)) == 0) {
1024         if(((*hostlist)[nhost++] = strdup(host)) == NULL) {
1025             krb5_free_krbhst(context, *hostlist);
1026             krb5_krbhst_free(context, handle);
1027             return ENOMEM;
1028         }
1029     }
1030     (*hostlist)[nhost] = NULL;
1031     krb5_krbhst_free(context, handle);
1032     return 0;
1033 }
1034
1035 /*
1036  * return an malloced list of kadmin-hosts for `realm' in `hostlist'
1037  */
1038
1039 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1040 krb5_get_krb_admin_hst (krb5_context context,
1041                         const krb5_realm *realm,
1042                         char ***hostlist)
1043 {
1044     return gethostlist(context, *realm, KRB5_KRBHST_ADMIN, hostlist);
1045 }
1046
1047 /*
1048  * return an malloced list of changepw-hosts for `realm' in `hostlist'
1049  */
1050
1051 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1052 krb5_get_krb_changepw_hst (krb5_context context,
1053                            const krb5_realm *realm,
1054                            char ***hostlist)
1055 {
1056     return gethostlist(context, *realm, KRB5_KRBHST_CHANGEPW, hostlist);
1057 }
1058
1059 /*
1060  * return an malloced list of 524-hosts for `realm' in `hostlist'
1061  */
1062
1063 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1064 krb5_get_krb524hst (krb5_context context,
1065                     const krb5_realm *realm,
1066                     char ***hostlist)
1067 {
1068     return gethostlist(context, *realm, KRB5_KRBHST_KRB524, hostlist);
1069 }
1070
1071
1072 /*
1073  * return an malloced list of KDC's for `realm' in `hostlist'
1074  */
1075
1076 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1077 krb5_get_krbhst (krb5_context context,
1078                  const krb5_realm *realm,
1079                  char ***hostlist)
1080 {
1081     return gethostlist(context, *realm, KRB5_KRBHST_KDC, hostlist);
1082 }
1083
1084 /*
1085  * free all the memory allocated in `hostlist'
1086  */
1087
1088 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1089 krb5_free_krbhst (krb5_context context,
1090                   char **hostlist)
1091 {
1092     char **p;
1093
1094     for (p = hostlist; *p; ++p)
1095         free (*p);
1096     free (hostlist);
1097     return 0;
1098 }