1 /* 2 * Copyright (c) 2001 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 37 RCSID("$Id: krbhst.c,v 1.41 2002/08/16 18:48:19 nectar Exp $"); 38 39 static int 40 string_to_proto(const char *string) 41 { 42 if(strcasecmp(string, "udp") == 0) 43 return KRB5_KRBHST_UDP; 44 else if(strcasecmp(string, "tcp") == 0) 45 return KRB5_KRBHST_TCP; 46 else if(strcasecmp(string, "http") == 0) 47 return KRB5_KRBHST_HTTP; 48 return -1; 49 } 50 51 /* 52 * set `res' and `count' to the result of looking up SRV RR in DNS for 53 * `proto', `proto', `realm' using `dns_type'. 54 * if `port' != 0, force that port number 55 */ 56 57 static krb5_error_code 58 srv_find_realm(krb5_context context, krb5_krbhst_info ***res, int *count, 59 const char *realm, const char *dns_type, 60 const char *proto, const char *service, int port) 61 { 62 char domain[1024]; 63 struct dns_reply *r; 64 struct resource_record *rr; 65 int num_srv; 66 int proto_num; 67 int def_port; 68 69 proto_num = string_to_proto(proto); 70 if(proto_num < 0) { 71 krb5_set_error_string(context, "unknown protocol `%s'", proto); 72 return EINVAL; 73 } 74 75 if(proto_num == KRB5_KRBHST_HTTP) 76 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80)); 77 else if(port == 0) 78 def_port = ntohs(krb5_getportbyname (context, service, proto, 88)); 79 else 80 def_port = port; 81 82 snprintf(domain, sizeof(domain), "_%s._%s.%s.", service, proto, realm); 83 84 r = dns_lookup(domain, dns_type); 85 if(r == NULL) { 86 *res = NULL; 87 *count = 0; 88 return KRB5_KDC_UNREACH; 89 } 90 91 for(num_srv = 0, rr = r->head; rr; rr = rr->next) 92 if(rr->type == T_SRV) 93 num_srv++; 94 95 *res = malloc(num_srv * sizeof(**res)); 96 if(*res == NULL) { 97 dns_free_data(r); 98 krb5_set_error_string(context, "malloc: out of memory"); 99 return ENOMEM; 100 } 101 102 dns_srv_order(r); 103 104 for(num_srv = 0, rr = r->head; rr; rr = rr->next) 105 if(rr->type == T_SRV) { 106 krb5_krbhst_info *hi; 107 hi = calloc(1, sizeof(*hi) + strlen(rr->u.srv->target)); 108 if(hi == NULL) { 109 dns_free_data(r); 110 while(--num_srv >= 0) 111 free((*res)[num_srv]); 112 free(*res); 113 return ENOMEM; 114 } 115 (*res)[num_srv++] = hi; 116 117 hi->proto = proto_num; 118 119 hi->def_port = def_port; 120 if (port != 0) 121 hi->port = port; 122 else 123 hi->port = rr->u.srv->port; 124 125 strcpy(hi->hostname, rr->u.srv->target); 126 } 127 128 *count = num_srv; 129 130 dns_free_data(r); 131 return 0; 132 } 133 134 135 struct krb5_krbhst_data { 136 char *realm; 137 unsigned int flags; 138 int def_port; 139 int port; /* hardwired port number if != 0 */ 140 #define KD_CONFIG 1 141 #define KD_SRV_UDP 2 142 #define KD_SRV_TCP 4 143 #define KD_SRV_HTTP 8 144 #define KD_FALLBACK 16 145 #define KD_CONFIG_EXISTS 32 146 147 krb5_error_code (*get_next)(krb5_context, struct krb5_krbhst_data *, 148 krb5_krbhst_info**); 149 150 unsigned int fallback_count; 151 152 struct krb5_krbhst_info *hosts, **index, **end; 153 }; 154 155 static krb5_boolean 156 krbhst_empty(const struct krb5_krbhst_data *kd) 157 { 158 return kd->index == &kd->hosts; 159 } 160 161 /* 162 * parse `spec' into a krb5_krbhst_info, defaulting the port to `def_port' 163 * and forcing it to `port' if port != 0 164 */ 165 166 static struct krb5_krbhst_info* 167 parse_hostspec(krb5_context context, const char *spec, int def_port, int port) 168 { 169 const char *p = spec; 170 struct krb5_krbhst_info *hi; 171 172 hi = calloc(1, sizeof(*hi) + strlen(spec)); 173 if(hi == NULL) 174 return NULL; 175 176 hi->proto = KRB5_KRBHST_UDP; 177 178 if(strncmp(p, "http://", 7) == 0){ 179 hi->proto = KRB5_KRBHST_HTTP; 180 p += 7; 181 } else if(strncmp(p, "http/", 5) == 0) { 182 hi->proto = KRB5_KRBHST_HTTP; 183 p += 5; 184 def_port = ntohs(krb5_getportbyname (context, "http", "tcp", 80)); 185 }else if(strncmp(p, "tcp/", 4) == 0){ 186 hi->proto = KRB5_KRBHST_TCP; 187 p += 4; 188 } else if(strncmp(p, "udp/", 4) == 0) { 189 p += 4; 190 } 191 192 if(strsep_copy(&p, ":", hi->hostname, strlen(spec) + 1) < 0) { 193 free(hi); 194 return NULL; 195 } 196 /* get rid of trailing /, and convert to lower case */ 197 hi->hostname[strcspn(hi->hostname, "/")] = '\0'; 198 strlwr(hi->hostname); 199 200 hi->port = hi->def_port = def_port; 201 if(p != NULL) { 202 char *end; 203 hi->port = strtol(p, &end, 0); 204 if(end == p) { 205 free(hi); 206 return NULL; 207 } 208 } 209 if (port) 210 hi->port = port; 211 return hi; 212 } 213 214 static void 215 free_krbhst_info(krb5_krbhst_info *hi) 216 { 217 if (hi->ai != NULL) 218 freeaddrinfo(hi->ai); 219 free(hi); 220 } 221 222 static void 223 append_host_hostinfo(struct krb5_krbhst_data *kd, struct krb5_krbhst_info *host) 224 { 225 struct krb5_krbhst_info *h; 226 227 for(h = kd->hosts; h; h = h->next) 228 if(h->proto == host->proto && 229 h->port == host->port && 230 strcmp(h->hostname, host->hostname) == 0) { 231 free_krbhst_info(host); 232 return; 233 } 234 *kd->end = host; 235 kd->end = &host->next; 236 } 237 238 static krb5_error_code 239 append_host_string(krb5_context context, struct krb5_krbhst_data *kd, 240 const char *host, int def_port, int port) 241 { 242 struct krb5_krbhst_info *hi; 243 244 hi = parse_hostspec(context, host, def_port, port); 245 if(hi == NULL) 246 return ENOMEM; 247 248 append_host_hostinfo(kd, hi); 249 return 0; 250 } 251 252 /* 253 * return a readable representation of `host' in `hostname, hostlen' 254 */ 255 256 krb5_error_code 257 krb5_krbhst_format_string(krb5_context context, const krb5_krbhst_info *host, 258 char *hostname, size_t hostlen) 259 { 260 const char *proto = ""; 261 char portstr[7] = ""; 262 if(host->proto == KRB5_KRBHST_TCP) 263 proto = "tcp/"; 264 else if(host->proto == KRB5_KRBHST_HTTP) 265 proto = "http://"; 266 if(host->port != host->def_port) 267 snprintf(portstr, sizeof(portstr), ":%d", host->port); 268 snprintf(hostname, hostlen, "%s%s%s", proto, host->hostname, portstr); 269 return 0; 270 } 271 272 /* 273 * create a getaddrinfo `hints' based on `proto' 274 */ 275 276 static void 277 make_hints(struct addrinfo *hints, int proto) 278 { 279 memset(hints, 0, sizeof(*hints)); 280 hints->ai_family = AF_UNSPEC; 281 switch(proto) { 282 case KRB5_KRBHST_UDP : 283 hints->ai_socktype = SOCK_DGRAM; 284 break; 285 case KRB5_KRBHST_HTTP : 286 case KRB5_KRBHST_TCP : 287 hints->ai_socktype = SOCK_STREAM; 288 break; 289 } 290 } 291 292 /* 293 * return an `struct addrinfo *' in `ai' corresponding to the information 294 * in `host'. free:ing is handled by krb5_krbhst_free. 295 */ 296 297 krb5_error_code 298 krb5_krbhst_get_addrinfo(krb5_context context, krb5_krbhst_info *host, 299 struct addrinfo **ai) 300 { 301 struct addrinfo hints; 302 char portstr[NI_MAXSERV]; 303 int ret; 304 305 if (host->ai == NULL) { 306 make_hints(&hints, host->proto); 307 snprintf (portstr, sizeof(portstr), "%d", host->port); 308 ret = getaddrinfo(host->hostname, portstr, &hints, &host->ai); 309 if (ret) 310 return krb5_eai_to_heim_errno(ret, errno); 311 } 312 *ai = host->ai; 313 return 0; 314 } 315 316 static krb5_boolean 317 get_next(struct krb5_krbhst_data *kd, krb5_krbhst_info **host) 318 { 319 struct krb5_krbhst_info *hi = *kd->index; 320 if(hi != NULL) { 321 *host = hi; 322 kd->index = &(*kd->index)->next; 323 return TRUE; 324 } 325 return FALSE; 326 } 327 328 static void 329 srv_get_hosts(krb5_context context, struct krb5_krbhst_data *kd, 330 const char *proto, const char *service) 331 { 332 krb5_krbhst_info **res; 333 int count, i; 334 335 srv_find_realm(context, &res, &count, kd->realm, "SRV", proto, service, 336 kd->port); 337 for(i = 0; i < count; i++) 338 append_host_hostinfo(kd, res[i]); 339 free(res); 340 } 341 342 /* 343 * read the configuration for `conf_string', defaulting to kd->def_port and 344 * forcing it to `kd->port' if kd->port != 0 345 */ 346 347 static void 348 config_get_hosts(krb5_context context, struct krb5_krbhst_data *kd, 349 const char *conf_string) 350 { 351 int i; 352 353 char **hostlist; 354 hostlist = krb5_config_get_strings(context, NULL, 355 "realms", kd->realm, conf_string, NULL); 356 357 if(hostlist == NULL) 358 return; 359 kd->flags |= KD_CONFIG_EXISTS; 360 for(i = 0; hostlist && hostlist[i] != NULL; i++) 361 append_host_string(context, kd, hostlist[i], kd->def_port, kd->port); 362 363 krb5_config_free_strings(hostlist); 364 } 365 366 /* 367 * as a fallback, look for `serv_string.kd->realm' (typically 368 * kerberos.REALM, kerberos-1.REALM, ... 369 * `port' is the default port for the service, and `proto' the 370 * protocol 371 */ 372 373 static krb5_error_code 374 fallback_get_hosts(krb5_context context, struct krb5_krbhst_data *kd, 375 const char *serv_string, int port, int proto) 376 { 377 char *host; 378 int ret; 379 struct addrinfo *ai; 380 struct addrinfo hints; 381 char portstr[NI_MAXSERV]; 382 383 if(kd->fallback_count == 0) 384 asprintf(&host, "%s.%s.", serv_string, kd->realm); 385 else 386 asprintf(&host, "%s-%d.%s.", 387 serv_string, kd->fallback_count, kd->realm); 388 389 if (host == NULL) 390 return ENOMEM; 391 392 make_hints(&hints, proto); 393 snprintf(portstr, sizeof(portstr), "%d", port); 394 ret = getaddrinfo(host, portstr, &hints, &ai); 395 if (ret) { 396 /* no more hosts, so we're done here */ 397 free(host); 398 kd->flags |= KD_FALLBACK; 399 } else { 400 struct krb5_krbhst_info *hi; 401 size_t hostlen = strlen(host); 402 403 hi = calloc(1, sizeof(*hi) + hostlen); 404 if(hi == NULL) { 405 free(host); 406 return ENOMEM; 407 } 408 409 hi->proto = proto; 410 hi->port = hi->def_port = port; 411 hi->ai = ai; 412 memmove(hi->hostname, host, hostlen - 1); 413 hi->hostname[hostlen - 1] = '\0'; 414 free(host); 415 append_host_hostinfo(kd, hi); 416 kd->fallback_count++; 417 } 418 return 0; 419 } 420 421 static krb5_error_code 422 kdc_get_next(krb5_context context, 423 struct krb5_krbhst_data *kd, 424 krb5_krbhst_info **host) 425 { 426 krb5_error_code ret; 427 428 if((kd->flags & KD_CONFIG) == 0) { 429 config_get_hosts(context, kd, "kdc"); 430 kd->flags |= KD_CONFIG; 431 if(get_next(kd, host)) 432 return 0; 433 } 434 435 if (kd->flags & KD_CONFIG_EXISTS) 436 return KRB5_KDC_UNREACH; /* XXX */ 437 438 if(context->srv_lookup) { 439 if((kd->flags & KD_SRV_UDP) == 0) { 440 srv_get_hosts(context, kd, "udp", "kerberos"); 441 kd->flags |= KD_SRV_UDP; 442 if(get_next(kd, host)) 443 return 0; 444 } 445 446 if((kd->flags & KD_SRV_TCP) == 0) { 447 srv_get_hosts(context, kd, "tcp", "kerberos"); 448 kd->flags |= KD_SRV_TCP; 449 if(get_next(kd, host)) 450 return 0; 451 } 452 if((kd->flags & KD_SRV_HTTP) == 0) { 453 srv_get_hosts(context, kd, "http", "kerberos"); 454 kd->flags |= KD_SRV_HTTP; 455 if(get_next(kd, host)) 456 return 0; 457 } 458 } 459 460 while((kd->flags & KD_FALLBACK) == 0) { 461 ret = fallback_get_hosts(context, kd, "kerberos", 462 kd->def_port, KRB5_KRBHST_UDP); 463 if(ret) 464 return ret; 465 if(get_next(kd, host)) 466 return 0; 467 } 468 469 return KRB5_KDC_UNREACH; /* XXX */ 470 } 471 472 static krb5_error_code 473 admin_get_next(krb5_context context, 474 struct krb5_krbhst_data *kd, 475 krb5_krbhst_info **host) 476 { 477 krb5_error_code ret; 478 479 if((kd->flags & KD_CONFIG) == 0) { 480 config_get_hosts(context, kd, "admin_server"); 481 kd->flags |= KD_CONFIG; 482 if(get_next(kd, host)) 483 return 0; 484 } 485 486 if (kd->flags & KD_CONFIG_EXISTS) 487 return KRB5_KDC_UNREACH; /* XXX */ 488 489 if(context->srv_lookup) { 490 if((kd->flags & KD_SRV_TCP) == 0) { 491 srv_get_hosts(context, kd, "tcp", "kerberos-adm"); 492 kd->flags |= KD_SRV_TCP; 493 if(get_next(kd, host)) 494 return 0; 495 } 496 } 497 498 if (krbhst_empty(kd) 499 && (kd->flags & KD_FALLBACK) == 0) { 500 ret = fallback_get_hosts(context, kd, "kerberos", 501 kd->def_port, KRB5_KRBHST_UDP); 502 if(ret) 503 return ret; 504 kd->flags |= KD_FALLBACK; 505 if(get_next(kd, host)) 506 return 0; 507 } 508 509 return KRB5_KDC_UNREACH; /* XXX */ 510 } 511 512 static krb5_error_code 513 kpasswd_get_next(krb5_context context, 514 struct krb5_krbhst_data *kd, 515 krb5_krbhst_info **host) 516 { 517 krb5_error_code ret; 518 519 if((kd->flags & KD_CONFIG) == 0) { 520 config_get_hosts(context, kd, "kpasswd_server"); 521 if(get_next(kd, host)) 522 return 0; 523 } 524 525 if (kd->flags & KD_CONFIG_EXISTS) 526 return KRB5_KDC_UNREACH; /* XXX */ 527 528 if(context->srv_lookup) { 529 if((kd->flags & KD_SRV_UDP) == 0) { 530 srv_get_hosts(context, kd, "udp", "kpasswd"); 531 kd->flags |= KD_SRV_UDP; 532 if(get_next(kd, host)) 533 return 0; 534 } 535 } 536 537 /* no matches -> try admin */ 538 539 if (krbhst_empty(kd)) { 540 kd->flags = 0; 541 kd->port = kd->def_port; 542 kd->get_next = admin_get_next; 543 ret = (*kd->get_next)(context, kd, host); 544 if (ret == 0) 545 (*host)->proto = KRB5_KRBHST_UDP; 546 return ret; 547 } 548 549 return KRB5_KDC_UNREACH; /* XXX */ 550 } 551 552 static krb5_error_code 553 krb524_get_next(krb5_context context, 554 struct krb5_krbhst_data *kd, 555 krb5_krbhst_info **host) 556 { 557 if((kd->flags & KD_CONFIG) == 0) { 558 config_get_hosts(context, kd, "krb524_server"); 559 if(get_next(kd, host)) 560 return 0; 561 kd->flags |= KD_CONFIG; 562 } 563 564 if (kd->flags & KD_CONFIG_EXISTS) 565 return KRB5_KDC_UNREACH; /* XXX */ 566 567 if(context->srv_lookup) { 568 if((kd->flags & KD_SRV_UDP) == 0) { 569 srv_get_hosts(context, kd, "udp", "krb524"); 570 kd->flags |= KD_SRV_UDP; 571 if(get_next(kd, host)) 572 return 0; 573 } 574 575 if((kd->flags & KD_SRV_TCP) == 0) { 576 srv_get_hosts(context, kd, "tcp", "krb524"); 577 kd->flags |= KD_SRV_TCP; 578 if(get_next(kd, host)) 579 return 0; 580 } 581 } 582 583 /* no matches -> try kdc */ 584 585 if (krbhst_empty(kd)) { 586 kd->flags = 0; 587 kd->port = kd->def_port; 588 kd->get_next = kdc_get_next; 589 return (*kd->get_next)(context, kd, host); 590 } 591 592 return KRB5_KDC_UNREACH; /* XXX */ 593 } 594 595 static struct krb5_krbhst_data* 596 common_init(krb5_context context, 597 const char *realm) 598 { 599 struct krb5_krbhst_data *kd; 600 601 if((kd = calloc(1, sizeof(*kd))) == NULL) 602 return NULL; 603 604 if((kd->realm = strdup(realm)) == NULL) { 605 free(kd); 606 return NULL; 607 } 608 609 kd->end = kd->index = &kd->hosts; 610 return kd; 611 } 612 613 /* 614 * initialize `handle' to look for hosts of type `type' in realm `realm' 615 */ 616 617 krb5_error_code 618 krb5_krbhst_init(krb5_context context, 619 const char *realm, 620 unsigned int type, 621 krb5_krbhst_handle *handle) 622 { 623 struct krb5_krbhst_data *kd; 624 krb5_error_code (*get_next)(krb5_context, struct krb5_krbhst_data *, 625 krb5_krbhst_info **); 626 int def_port; 627 628 switch(type) { 629 case KRB5_KRBHST_KDC: 630 get_next = kdc_get_next; 631 def_port = ntohs(krb5_getportbyname (context, "kerberos", "udp", 88)); 632 break; 633 case KRB5_KRBHST_ADMIN: 634 get_next = admin_get_next; 635 def_port = ntohs(krb5_getportbyname (context, "kerberos-adm", 636 "tcp", 749)); 637 break; 638 case KRB5_KRBHST_CHANGEPW: 639 get_next = kpasswd_get_next; 640 def_port = ntohs(krb5_getportbyname (context, "kpasswd", "udp", 641 KPASSWD_PORT)); 642 break; 643 case KRB5_KRBHST_KRB524: 644 get_next = krb524_get_next; 645 def_port = ntohs(krb5_getportbyname (context, "krb524", "udp", 4444)); 646 break; 647 default: 648 krb5_set_error_string(context, "unknown krbhst type (%u)", type); 649 return ENOTTY; 650 } 651 if((kd = common_init(context, realm)) == NULL) 652 return ENOMEM; 653 kd->get_next = get_next; 654 kd->def_port = def_port; 655 *handle = kd; 656 return 0; 657 } 658 659 /* 660 * return the next host information from `handle' in `host' 661 */ 662 663 krb5_error_code 664 krb5_krbhst_next(krb5_context context, 665 krb5_krbhst_handle handle, 666 krb5_krbhst_info **host) 667 { 668 if(get_next(handle, host)) 669 return 0; 670 671 return (*handle->get_next)(context, handle, host); 672 } 673 674 /* 675 * return the next host information from `handle' as a host name 676 * in `hostname' (or length `hostlen) 677 */ 678 679 krb5_error_code 680 krb5_krbhst_next_as_string(krb5_context context, 681 krb5_krbhst_handle handle, 682 char *hostname, 683 size_t hostlen) 684 { 685 krb5_error_code ret; 686 krb5_krbhst_info *host; 687 ret = krb5_krbhst_next(context, handle, &host); 688 if(ret) 689 return ret; 690 return krb5_krbhst_format_string(context, host, hostname, hostlen); 691 } 692 693 694 void 695 krb5_krbhst_reset(krb5_context context, krb5_krbhst_handle handle) 696 { 697 handle->index = &handle->hosts; 698 } 699 700 void 701 krb5_krbhst_free(krb5_context context, krb5_krbhst_handle handle) 702 { 703 krb5_krbhst_info *h, *next; 704 705 if (handle == NULL) 706 return; 707 708 for (h = handle->hosts; h != NULL; h = next) { 709 next = h->next; 710 free_krbhst_info(h); 711 } 712 713 free(handle->realm); 714 free(handle); 715 } 716 717 /* backwards compatibility ahead */ 718 719 static krb5_error_code 720 gethostlist(krb5_context context, const char *realm, 721 unsigned int type, char ***hostlist) 722 { 723 krb5_error_code ret; 724 int nhost = 0; 725 krb5_krbhst_handle handle; 726 char host[MAXHOSTNAMELEN]; 727 krb5_krbhst_info *hostinfo; 728 729 ret = krb5_krbhst_init(context, realm, type, &handle); 730 if (ret) 731 return ret; 732 733 while(krb5_krbhst_next(context, handle, &hostinfo) == 0) 734 nhost++; 735 if(nhost == 0) 736 return KRB5_KDC_UNREACH; 737 *hostlist = calloc(nhost + 1, sizeof(**hostlist)); 738 if(*hostlist == NULL) { 739 krb5_krbhst_free(context, handle); 740 return ENOMEM; 741 } 742 743 krb5_krbhst_reset(context, handle); 744 nhost = 0; 745 while(krb5_krbhst_next_as_string(context, handle, 746 host, sizeof(host)) == 0) { 747 if(((*hostlist)[nhost++] = strdup(host)) == NULL) { 748 krb5_free_krbhst(context, *hostlist); 749 krb5_krbhst_free(context, handle); 750 return ENOMEM; 751 } 752 } 753 (*hostlist)[nhost++] = NULL; 754 krb5_krbhst_free(context, handle); 755 return 0; 756 } 757 758 /* 759 * return an malloced list of kadmin-hosts for `realm' in `hostlist' 760 */ 761 762 krb5_error_code 763 krb5_get_krb_admin_hst (krb5_context context, 764 const krb5_realm *realm, 765 char ***hostlist) 766 { 767 return gethostlist(context, *realm, KRB5_KRBHST_ADMIN, hostlist); 768 } 769 770 /* 771 * return an malloced list of changepw-hosts for `realm' in `hostlist' 772 */ 773 774 krb5_error_code 775 krb5_get_krb_changepw_hst (krb5_context context, 776 const krb5_realm *realm, 777 char ***hostlist) 778 { 779 return gethostlist(context, *realm, KRB5_KRBHST_CHANGEPW, hostlist); 780 } 781 782 /* 783 * return an malloced list of 524-hosts for `realm' in `hostlist' 784 */ 785 786 krb5_error_code 787 krb5_get_krb524hst (krb5_context context, 788 const krb5_realm *realm, 789 char ***hostlist) 790 { 791 return gethostlist(context, *realm, KRB5_KRBHST_KRB524, hostlist); 792 } 793 794 795 /* 796 * return an malloced list of KDC's for `realm' in `hostlist' 797 */ 798 799 krb5_error_code 800 krb5_get_krbhst (krb5_context context, 801 const krb5_realm *realm, 802 char ***hostlist) 803 { 804 return gethostlist(context, *realm, KRB5_KRBHST_KDC, hostlist); 805 } 806 807 /* 808 * free all the memory allocated in `hostlist' 809 */ 810 811 krb5_error_code 812 krb5_free_krbhst (krb5_context context, 813 char **hostlist) 814 { 815 char **p; 816 817 for (p = hostlist; *p; ++p) 818 free (*p); 819 free (hostlist); 820 return 0; 821 } 822