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