1 /* 2 * Copyright (c) 1997, 1998, 1999 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 RCSID("$Id: config_file.c,v 1.38 1999/12/02 17:05:08 joda Exp $"); 36 37 #ifndef HAVE_NETINFO 38 39 static int parse_section(char *p, krb5_config_section **s, 40 krb5_config_section **res, 41 char **error_message); 42 static int parse_binding(FILE *f, unsigned *lineno, char *p, 43 krb5_config_binding **b, 44 krb5_config_binding **parent, 45 char **error_message); 46 static int parse_list(FILE *f, unsigned *lineno, krb5_config_binding **parent, 47 char **error_message); 48 49 /* 50 * Parse a section: 51 * 52 * [section] 53 * foo = bar 54 * b = { 55 * a 56 * } 57 * ... 58 * 59 * starting at the line in `p', storing the resulting structure in 60 * `s' and hooking it into `parent'. 61 * Store the error message in `error_message'. 62 */ 63 64 static int 65 parse_section(char *p, krb5_config_section **s, krb5_config_section **parent, 66 char **error_message) 67 { 68 char *p1; 69 krb5_config_section *tmp; 70 71 p1 = strchr (p + 1, ']'); 72 if (p1 == NULL) { 73 *error_message = "missing ]"; 74 return -1; 75 } 76 *p1 = '\0'; 77 tmp = malloc(sizeof(*tmp)); 78 if (tmp == NULL) { 79 *error_message = "out of memory"; 80 return -1; 81 } 82 tmp->name = strdup(p+1); 83 if (tmp->name == NULL) { 84 *error_message = "out of memory"; 85 return -1; 86 } 87 tmp->type = krb5_config_list; 88 tmp->u.list = NULL; 89 tmp->next = NULL; 90 if (*s) 91 (*s)->next = tmp; 92 else 93 *parent = tmp; 94 *s = tmp; 95 return 0; 96 } 97 98 /* 99 * Parse a brace-enclosed list from `f', hooking in the structure at 100 * `parent'. 101 * Store the error message in `error_message'. 102 */ 103 104 static int 105 parse_list(FILE *f, unsigned *lineno, krb5_config_binding **parent, 106 char **error_message) 107 { 108 char buf[BUFSIZ]; 109 int ret; 110 krb5_config_binding *b = NULL; 111 unsigned beg_lineno = *lineno; 112 113 while(fgets(buf, sizeof(buf), f) != NULL) { 114 char *p; 115 116 ++*lineno; 117 if (buf[strlen(buf) - 1] == '\n') 118 buf[strlen(buf) - 1] = '\0'; 119 p = buf; 120 while(isspace((unsigned char)*p)) 121 ++p; 122 if (*p == '#' || *p == ';' || *p == '\0') 123 continue; 124 while(isspace((unsigned char)*p)) 125 ++p; 126 if (*p == '}') 127 return 0; 128 if (*p == '\0') 129 continue; 130 ret = parse_binding (f, lineno, p, &b, parent, error_message); 131 if (ret) 132 return ret; 133 } 134 *lineno = beg_lineno; 135 *error_message = "unclosed {"; 136 return -1; 137 } 138 139 /* 140 * 141 */ 142 143 static int 144 parse_binding(FILE *f, unsigned *lineno, char *p, 145 krb5_config_binding **b, krb5_config_binding **parent, 146 char **error_message) 147 { 148 krb5_config_binding *tmp; 149 char *p1, *p2; 150 int ret = 0; 151 152 p1 = p; 153 while (*p && *p != '=' && !isspace((unsigned char)*p)) 154 ++p; 155 if (*p == '\0') { 156 *error_message = "no ="; 157 return -1; 158 } 159 p2 = p; 160 while (isspace((unsigned char)*p)) 161 ++p; 162 if (*p != '=') { 163 *error_message = "no ="; 164 return -1; 165 } 166 ++p; 167 while(isspace((unsigned char)*p)) 168 ++p; 169 tmp = malloc(sizeof(*tmp)); 170 if (tmp == NULL) { 171 *error_message = "out of memory"; 172 return -1; 173 } 174 *p2 = '\0'; 175 tmp->name = strdup(p1); 176 tmp->next = NULL; 177 if (*p == '{') { 178 tmp->type = krb5_config_list; 179 tmp->u.list = NULL; 180 ret = parse_list (f, lineno, &tmp->u.list, error_message); 181 } else { 182 p1 = p; 183 p = p1 + strlen(p1); 184 while(p > p1 && isspace((unsigned char)*(p-1))) 185 --p; 186 *p = '\0'; 187 tmp->type = krb5_config_string; 188 tmp->u.string = strdup(p1); 189 } 190 if (*b) 191 (*b)->next = tmp; 192 else 193 *parent = tmp; 194 *b = tmp; 195 return ret; 196 } 197 198 /* 199 * Parse the config file `fname', generating the structures into `res' 200 * returning error messages in `error_message' 201 */ 202 203 krb5_error_code 204 krb5_config_parse_file_debug (const char *fname, 205 krb5_config_section **res, 206 unsigned *lineno, 207 char **error_message) 208 { 209 FILE *f; 210 krb5_config_section *s; 211 krb5_config_binding *b; 212 char buf[BUFSIZ]; 213 int ret; 214 215 s = NULL; 216 b = NULL; 217 *lineno = 0; 218 f = fopen (fname, "r"); 219 if (f == NULL) { 220 *error_message = "cannot open file"; 221 return -1; 222 } 223 *res = NULL; 224 while (fgets(buf, sizeof(buf), f) != NULL) { 225 char *p; 226 227 ++*lineno; 228 if(buf[strlen(buf) - 1] == '\n') 229 buf[strlen(buf) - 1] = '\0'; 230 p = buf; 231 while(isspace((unsigned char)*p)) 232 ++p; 233 if (*p == '#' || *p == ';') 234 continue; 235 if (*p == '[') { 236 ret = parse_section(p, &s, res, error_message); 237 if (ret) 238 return ret; 239 b = NULL; 240 } else if (*p == '}') { 241 *error_message = "unmatched }"; 242 return -1; 243 } else if(*p != '\0') { 244 ret = parse_binding(f, lineno, p, &b, &s->u.list, error_message); 245 if (ret) 246 return ret; 247 } 248 } 249 fclose (f); 250 return 0; 251 } 252 253 krb5_error_code 254 krb5_config_parse_file (const char *fname, krb5_config_section **res) 255 { 256 char *foo; 257 unsigned lineno; 258 259 return krb5_config_parse_file_debug (fname, res, &lineno, &foo); 260 } 261 262 #endif /* !HAVE_NETINFO */ 263 264 static void 265 free_binding (krb5_context context, krb5_config_binding *b) 266 { 267 krb5_config_binding *next_b; 268 269 while (b) { 270 free (b->name); 271 if (b->type == krb5_config_string) 272 free (b->u.string); 273 else if (b->type == krb5_config_list) 274 free_binding (context, b->u.list); 275 else 276 krb5_abortx(context, "unknown binding type (%d) in free_binding", 277 b->type); 278 next_b = b->next; 279 free (b); 280 b = next_b; 281 } 282 } 283 284 krb5_error_code 285 krb5_config_file_free (krb5_context context, krb5_config_section *s) 286 { 287 free_binding (context, s); 288 return 0; 289 } 290 291 const void * 292 krb5_config_get_next (krb5_context context, 293 krb5_config_section *c, 294 krb5_config_binding **pointer, 295 int type, 296 ...) 297 { 298 const char *ret; 299 va_list args; 300 301 va_start(args, type); 302 ret = krb5_config_vget_next (context, c, pointer, type, args); 303 va_end(args); 304 return ret; 305 } 306 307 const void * 308 krb5_config_vget_next (krb5_context context, 309 krb5_config_section *c, 310 krb5_config_binding **pointer, 311 int type, 312 va_list args) 313 { 314 krb5_config_binding *b; 315 const char *p; 316 317 if(c == NULL) 318 c = context->cf; 319 320 if (c == NULL) 321 return NULL; 322 323 if (*pointer == NULL) { 324 b = (c != NULL) ? c : context->cf; 325 p = va_arg(args, const char *); 326 if (p == NULL) 327 return NULL; 328 } else { 329 b = *pointer; 330 p = b->name; 331 b = b->next; 332 } 333 334 while (b) { 335 if (strcmp (b->name, p) == 0) { 336 if (*pointer == NULL) 337 p = va_arg(args, const char *); 338 else 339 p = NULL; 340 if (type == b->type && p == NULL) { 341 *pointer = b; 342 return b->u.generic; 343 } else if(b->type == krb5_config_list && p != NULL) { 344 b = b->u.list; 345 } else { 346 return NULL; 347 } 348 } else { 349 b = b->next; 350 } 351 } 352 return NULL; 353 } 354 355 const void * 356 krb5_config_get (krb5_context context, 357 krb5_config_section *c, 358 int type, 359 ...) 360 { 361 const void *ret; 362 va_list args; 363 364 va_start(args, type); 365 ret = krb5_config_vget (context, c, type, args); 366 va_end(args); 367 return ret; 368 } 369 370 const void * 371 krb5_config_vget (krb5_context context, 372 krb5_config_section *c, 373 int type, 374 va_list args) 375 { 376 krb5_config_binding *foo = NULL; 377 378 return krb5_config_vget_next (context, c, &foo, type, args); 379 } 380 381 const krb5_config_binding * 382 krb5_config_get_list (krb5_context context, 383 krb5_config_section *c, 384 ...) 385 { 386 const krb5_config_binding *ret; 387 va_list args; 388 389 va_start(args, c); 390 ret = krb5_config_vget_list (context, c, args); 391 va_end(args); 392 return ret; 393 } 394 395 const krb5_config_binding * 396 krb5_config_vget_list (krb5_context context, 397 krb5_config_section *c, 398 va_list args) 399 { 400 return krb5_config_vget (context, c, krb5_config_list, args); 401 } 402 403 const char * 404 krb5_config_get_string (krb5_context context, 405 krb5_config_section *c, 406 ...) 407 { 408 const char *ret; 409 va_list args; 410 411 va_start(args, c); 412 ret = krb5_config_vget_string (context, c, args); 413 va_end(args); 414 return ret; 415 } 416 417 const char * 418 krb5_config_vget_string (krb5_context context, 419 krb5_config_section *c, 420 va_list args) 421 { 422 return krb5_config_vget (context, c, krb5_config_string, args); 423 } 424 425 char ** 426 krb5_config_vget_strings(krb5_context context, 427 krb5_config_section *c, 428 va_list args) 429 { 430 char **strings = NULL; 431 int nstr = 0; 432 krb5_config_binding *b = NULL; 433 const char *p; 434 435 while((p = krb5_config_vget_next(context, c, &b, 436 krb5_config_string, args))) { 437 char *tmp = strdup(p); 438 char *pos = NULL; 439 char *s; 440 if(tmp == NULL) 441 goto cleanup; 442 s = strtok_r(tmp, " \t", &pos); 443 while(s){ 444 char **tmp = realloc(strings, (nstr + 1) * sizeof(*strings)); 445 if(tmp == NULL) 446 goto cleanup; 447 strings = tmp; 448 strings[nstr] = strdup(s); 449 nstr++; 450 if(strings[nstr-1] == NULL) 451 goto cleanup; 452 s = strtok_r(NULL, " \t", &pos); 453 } 454 free(tmp); 455 } 456 if(nstr){ 457 char **tmp = realloc(strings, (nstr + 1) * sizeof(*strings)); 458 if(strings == NULL) 459 goto cleanup; 460 strings = tmp; 461 strings[nstr] = NULL; 462 } 463 return strings; 464 cleanup: 465 while(nstr--) 466 free(strings[nstr]); 467 free(strings); 468 return NULL; 469 470 } 471 472 char** 473 krb5_config_get_strings(krb5_context context, 474 krb5_config_section *c, 475 ...) 476 { 477 va_list ap; 478 char **ret; 479 va_start(ap, c); 480 ret = krb5_config_vget_strings(context, c, ap); 481 va_end(ap); 482 return ret; 483 } 484 485 void 486 krb5_config_free_strings(char **strings) 487 { 488 char **s = strings; 489 while(s && *s){ 490 free(*s); 491 s++; 492 } 493 free(strings); 494 } 495 496 krb5_boolean 497 krb5_config_vget_bool_default (krb5_context context, 498 krb5_config_section *c, 499 krb5_boolean def_value, 500 va_list args) 501 { 502 const char *str; 503 str = krb5_config_vget_string (context, c, args); 504 if(str == NULL) 505 return def_value; 506 if(strcasecmp(str, "yes") == 0 || 507 strcasecmp(str, "true") == 0 || 508 atoi(str)) return TRUE; 509 return FALSE; 510 } 511 512 krb5_boolean 513 krb5_config_vget_bool (krb5_context context, 514 krb5_config_section *c, 515 va_list args) 516 { 517 return krb5_config_vget_bool_default (context, c, FALSE, args); 518 } 519 520 krb5_boolean 521 krb5_config_get_bool_default (krb5_context context, 522 krb5_config_section *c, 523 krb5_boolean def_value, 524 ...) 525 { 526 va_list ap; 527 krb5_boolean ret; 528 va_start(ap, def_value); 529 ret = krb5_config_vget_bool_default(context, c, def_value, ap); 530 va_end(ap); 531 return ret; 532 } 533 534 krb5_boolean 535 krb5_config_get_bool (krb5_context context, 536 krb5_config_section *c, 537 ...) 538 { 539 va_list ap; 540 krb5_boolean ret; 541 va_start(ap, c); 542 ret = krb5_config_vget_bool (context, c, ap); 543 va_end(ap); 544 return ret; 545 } 546 547 int 548 krb5_config_vget_time_default (krb5_context context, 549 krb5_config_section *c, 550 int def_value, 551 va_list args) 552 { 553 const char *str; 554 str = krb5_config_vget_string (context, c, args); 555 if(str == NULL) 556 return def_value; 557 return parse_time (str, NULL); 558 } 559 560 int 561 krb5_config_vget_time (krb5_context context, 562 krb5_config_section *c, 563 va_list args) 564 { 565 return krb5_config_vget_time_default (context, c, -1, args); 566 } 567 568 int 569 krb5_config_get_time_default (krb5_context context, 570 krb5_config_section *c, 571 int def_value, 572 ...) 573 { 574 va_list ap; 575 int ret; 576 va_start(ap, def_value); 577 ret = krb5_config_vget_time_default(context, c, def_value, ap); 578 va_end(ap); 579 return ret; 580 } 581 582 int 583 krb5_config_get_time (krb5_context context, 584 krb5_config_section *c, 585 ...) 586 { 587 va_list ap; 588 int ret; 589 va_start(ap, c); 590 ret = krb5_config_vget_time (context, c, ap); 591 va_end(ap); 592 return ret; 593 } 594 595 596 int 597 krb5_config_vget_int_default (krb5_context context, 598 krb5_config_section *c, 599 int def_value, 600 va_list args) 601 { 602 const char *str; 603 str = krb5_config_vget_string (context, c, args); 604 if(str == NULL) 605 return def_value; 606 else { 607 char *endptr; 608 long l; 609 l = strtol(str, &endptr, 0); 610 if (endptr == str) 611 return def_value; 612 else 613 return l; 614 } 615 } 616 617 int 618 krb5_config_vget_int (krb5_context context, 619 krb5_config_section *c, 620 va_list args) 621 { 622 return krb5_config_vget_int_default (context, c, -1, args); 623 } 624 625 int 626 krb5_config_get_int_default (krb5_context context, 627 krb5_config_section *c, 628 int def_value, 629 ...) 630 { 631 va_list ap; 632 int ret; 633 va_start(ap, def_value); 634 ret = krb5_config_vget_int_default(context, c, def_value, ap); 635 va_end(ap); 636 return ret; 637 } 638 639 int 640 krb5_config_get_int (krb5_context context, 641 krb5_config_section *c, 642 ...) 643 { 644 va_list ap; 645 int ret; 646 va_start(ap, c); 647 ret = krb5_config_vget_int (context, c, ap); 648 va_end(ap); 649 return ret; 650 } 651 652 #ifdef TEST 653 654 static int print_list (krb5_context context, FILE *f, 655 krb5_config_binding *l, unsigned level); 656 static int print_binding (krb5_context context, FILE *f, 657 krb5_config_binding *b, unsigned level); 658 static int print_section (krb5_context context, FILE *f, 659 krb5_config_section *s, unsigned level); 660 static int print_config (krb5_context context, FILE *f, 661 krb5_config_section *c); 662 663 static void 664 tab (FILE *f, unsigned count) 665 { 666 while(count--) 667 fprintf (f, "\t"); 668 } 669 670 static int 671 print_list (krb5_context context, 672 FILE *f, 673 krb5_config_binding *l, 674 unsigned level) 675 { 676 while(l) { 677 print_binding (context, f, l, level); 678 l = l->next; 679 } 680 return 0; 681 } 682 683 static int 684 print_binding (krb5_context context, 685 FILE *f, 686 krb5_config_binding *b, 687 unsigned level) 688 { 689 tab (f, level); 690 fprintf (f, "%s = ", b->name); 691 if (b->type == krb5_config_string) 692 fprintf (f, "%s\n", b->u.string); 693 else if (b->type == krb5_config_list) { 694 fprintf (f, "{\n"); 695 print_list (f, b->u.list, level + 1); 696 tab (f, level); 697 fprintf (f, "}\n"); 698 } else 699 krb5_abortx(context, "unknown binding type (%d) in print_binding", 700 b->type); 701 return 0; 702 } 703 704 static int 705 print_section (FILE *f, krb5_config_section *s, unsigned level) 706 { 707 fprintf (f, "[%s]\n", s->name); 708 print_list (f, s->u.list, level + 1); 709 return 0; 710 } 711 712 static int 713 print_config (FILE *f, krb5_config_section *c) 714 { 715 while (c) { 716 print_section (f, c, 0); 717 c = c->next; 718 } 719 return 0; 720 } 721 722 723 int 724 main(void) 725 { 726 krb5_config_section *c; 727 728 printf ("%d\n", krb5_config_parse_file ("/etc/krb5.conf", &c)); 729 print_config (stdout, c); 730 printf ("[libdefaults]ticket_lifetime = %s\n", 731 krb5_config_get_string (context, c, 732 "libdefaults", 733 "ticket_lifetime", 734 NULL)); 735 printf ("[realms]foo = %s\n", 736 krb5_config_get_string (context, c, 737 "realms", 738 "foo", 739 NULL)); 740 printf ("[realms]ATHENA.MIT.EDU/v4_instance_convert/lithium = %s\n", 741 krb5_config_get_string (context, c, 742 "realms", 743 "ATHENA.MIT.EDU", 744 "v4_instance_convert", 745 "lithium", 746 NULL)); 747 return 0; 748 } 749 750 #endif /* TEST */ 751