e2fsck/profile.c

   1 /*
   2  * profile.c -- A simple configuration file parsing "library in a file"
   3  *
   4  * The profile library was originally written by Theodore Ts'o in 1995
   5  * for use in the MIT Kerberos v5 library.  It has been
   6  * modified/enhanced/bug-fixed over time by other members of the MIT
   7  * Kerberos team.  This version was originally taken from the Kerberos
   8  * v5 distribution, version 1.4.2, and radically simplified for use in
   9  * e2fsprogs.  (Support for locking for multi-threaded operations,
  10  * being able to modify and update the configuration file
  11  * programmatically, and Mac/Windows portability have been removed.
  12  * It has been folded into a single C source file to make it easier to
  13  * fold into an application program.)
  14  *
  15  * Copyright (C) 2005, 2006 by Theodore Ts'o.
  16  *
  17  * %Begin-Header%
  18  * This file may be redistributed under the terms of the GNU Public
  19  * License.
  20  * %End-Header%
  21  *
  22  * Copyright (C) 1985-2005 by the Massachusetts Institute of Technology.
  23  *
  24  * All rights reserved.
  25  *
  26  * Export of this software from the United States of America may require
  27  * a specific license from the United States Government.  It is the
  28  * responsibility of any person or organization contemplating export to
  29  * obtain such a license before exporting.
  30  *
  31  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  32  * distribute this software and its documentation for any purpose and
  33  * without fee is hereby granted, provided that the above copyright
  34  * notice appear in all copies and that both that copyright notice and
  35  * this permission notice appear in supporting documentation, and that
  36  * the name of M.I.T. not be used in advertising or publicity pertaining
  37  * to distribution of the software without specific, written prior
  38  * permission.  Furthermore if you modify this software you must label
  39  * your software as modified software and not distribute it in such a
  40  * fashion that it might be confused with the original MIT software.
  41  * M.I.T. makes no representations about the suitability of this software
  42  * for any purpose.  It is provided "as is" without express or implied
  43  * warranty.
  44  *
  45  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  46  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  47  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  48  *
  49  */
  50
  51 #ifdef HAVE_UNISTD_H
  52 #include <unistd.h>
  53 #endif
  54 #include <stdio.h>
  55 #ifdef HAVE_STDLIB_H
  56 #include <stdlib.h>
  57 #endif
  58 #include <time.h>
  59 #include <string.h>
  60 #include <errno.h>
  61 #include <ctype.h>
  62 #include <limits.h>
  63 #include <stddef.h>
  64 #include <sys/types.h>
  65 #include <sys/stat.h>
  66 #include <dirent.h>
  67 #ifdef HAVE_PWD_H
  68 #include <pwd.h>
  69 #endif
  70
  71 #include <et/com_err.h>
  72 #include "profile.h"
  73 #include "prof_err.h"
  74
  75 #undef STAT_ONCE_PER_SECOND
  76 #undef HAVE_STAT
  77
  78 /*
  79  * prof_int.h
  80  */
  81
  82 typedef long prf_magic_t;
  83
  84 /*
  85  * This is the structure which stores the profile information for a
  86  * particular configuration file.
  87  */
  88 struct _prf_file_t {
  89         prf_magic_t     magic;
  90         char            *filespec;
  91 #ifdef STAT_ONCE_PER_SECOND
  92         time_t          last_stat;
  93 #endif
  94         time_t          timestamp; /* time tree was last updated from file */
  95         int             flags;  /* r/w, dirty */
  96         int             upd_serial; /* incremented when data changes */
  97         struct profile_node *root;
  98         struct _prf_file_t *next;
  99 };
 100
 101 typedef struct _prf_file_t *prf_file_t;
 102
 103 /*
 104  * The profile flags
 105  */
 106 #define PROFILE_FILE_RW         0x0001
 107 #define PROFILE_FILE_DIRTY      0x0002
 108 #define PROFILE_FILE_NO_RELOAD  0x0004
 109
 110 /*
 111  * This structure defines the high-level, user visible profile_t
 112  * object, which is used as a handle by users who need to query some
 113  * configuration file(s)
 114  */
 115 struct _profile_t {
 116         prf_magic_t     magic;
 117         prf_file_t      first_file;
 118 };
 119
 120 /*
 121  * Used by the profile iterator in prof_get.c
 122  */
 123 #define PROFILE_ITER_LIST_SECTION       0x0001
 124 #define PROFILE_ITER_SECTIONS_ONLY      0x0002
 125 #define PROFILE_ITER_RELATIONS_ONLY     0x0004
 126
 127 #define PROFILE_ITER_FINAL_SEEN         0x0100
 128
 129 /*
 130  * Check if a filespec is last in a list (NULL on UNIX, invalid FSSpec on MacOS
 131  */
 132
 133 #define PROFILE_LAST_FILESPEC(x) (((x) == NULL) || ((x)[0] == '\0'))
 134
 135 struct profile_node {
 136         errcode_t       magic;
 137         char *name;
 138         char *value;
 139         int group_level;
 140         unsigned int final:1;           /* Indicate don't search next file */
 141         unsigned int deleted:1;
 142         struct profile_node *first_child;
 143         struct profile_node *parent;
 144         struct profile_node *next, *prev;
 145 };
 146
 147 #define CHECK_MAGIC(node) \
 148           if ((node)->magic != PROF_MAGIC_NODE) \
 149                   return PROF_MAGIC_NODE;
 150
 151 /* profile parser declarations */
 152 struct parse_state {
 153         int     state;
 154         int     group_level;
 155         int     line_num;
 156         struct profile_node *root_section;
 157         struct profile_node *current_section;
 158 };
 159
 160 static const char *default_filename = "<default>";
 161
 162 static profile_syntax_err_cb_t  syntax_err_cb;
 163
 164 static errcode_t parse_line(char *line, struct parse_state *state);
 165
 166 #ifdef DEBUG_PROGRAM
 167 static errcode_t profile_write_tree_file
 168         (struct profile_node *root, FILE *dstfile);
 169
 170 static errcode_t profile_write_tree_to_buffer
 171         (struct profile_node *root, char **buf);
 172 #endif
 173
 174
 175 static void profile_free_node
 176         (struct profile_node *relation);
 177
 178 static errcode_t profile_create_node
 179         (const char *name, const char *value,
 180                    struct profile_node **ret_node);
 181
 182 #ifdef DEBUG_PROGRAM
 183 static errcode_t profile_verify_node
 184         (struct profile_node *node);
 185 #endif
 186
 187 static errcode_t profile_add_node
 188         (struct profile_node *section,
 189                     const char *name, const char *value,
 190                     struct profile_node **ret_node);
 191
 192 static errcode_t profile_find_node
 193         (struct profile_node *section,
 194                     const char *name, const char *value,
 195                     int section_flag, void **state,
 196                     struct profile_node **node);
 197
 198 static errcode_t profile_node_iterator
 199         (void   **iter_p, struct profile_node **ret_node,
 200                    char **ret_name, char **ret_value);
 201
 202 static errcode_t profile_open_file
 203         (const char * file, prf_file_t *ret_prof);
 204
 205 static errcode_t profile_update_file
 206         (prf_file_t prf);
 207
 208 static void profile_free_file
 209         (prf_file_t profile);
 210
 211 static errcode_t profile_get_value(profile_t profile, const char *name,
 212                                    const char *subname, const char *subsubname,
 213                                    const char **ret_value);
 214
 215
 216 /*
 217  * prof_init.c --- routines that manipulate the user-visible profile_t
 218  *      object.
 219  */
 220
 221 static int compstr(const void *m1, const void *m2)
 222 {
 223         const char *s1 = *((const char * const *) m1);
 224         const char *s2 = *((const char * const *) m2);
 225
 226         return strcmp(s1, s2);
 227 }
 228
 229 static void free_list(char **list)
 230 {
 231     char        **cp;
 232
 233     if (list == 0)
 234             return;
 235
 236     for (cp = list; *cp; cp++)
 237         free(*cp);
 238     free(list);
 239 }
 240
 241 static errcode_t get_dirlist(const char *dirname, char***ret_array)
 242 {
 243         DIR *dir;
 244         struct dirent *de;
 245         struct stat st;
 246         errcode_t retval;
 247         char *fn, *cp;
 248         char **array = 0, **new_array;
 249         int max = 0, num = 0;
 250
 251         dir = opendir(dirname);
 252         if (!dir)
 253                 return errno;
 254
 255         while ((de = readdir(dir)) != NULL) {
 256                 for (cp = de->d_name; *cp; cp++) {
 257                         if (!isalnum(*cp) &&
 258                             (*cp != '-') &&
 259                             (*cp != '_'))
 260                                 break;
 261                 }
 262                 if (*cp)
 263                         continue;
 264                 fn = malloc(strlen(dirname) + strlen(de->d_name) + 2);
 265                 if (!fn) {
 266                         retval = ENOMEM;
 267                         goto errout;
 268                 }
 269                 sprintf(fn, "%s/%s", dirname, de->d_name);
 270                 if ((stat(fn, &st) < 0) || !S_ISREG(st.st_mode)) {
 271                         free(fn);
 272                         continue;
 273                 }
 274                 if (num >= max) {
 275                         max += 10;
 276                         new_array = realloc(array, sizeof(char *) * (max+1));
 277                         if (!new_array) {
 278                                 retval = ENOMEM;
 279                                 goto errout;
 280                         }
 281                         array = new_array;
 282                 }
 283                 array[num++] = fn;
 284         }
 285         if (array) {
 286                 qsort(array, num, sizeof(char *), compstr);
 287                 array[num++] = 0;
 288         }
 289         *ret_array = array;
 290         closedir(dir);
 291         return 0;
 292 errout:
 293         closedir(dir);
 294         free_list(array);
 295         return retval;
 296 }
 297
 298 errcode_t
 299 profile_init(const char **files, profile_t *ret_profile)
 300 {
 301         const char **fs;
 302         profile_t profile;
 303         prf_file_t  new_file, *last;
 304         errcode_t retval = 0;
 305         char **cpp, *cp, **array = 0;
 306
 307         profile = malloc(sizeof(struct _profile_t));
 308         if (!profile)
 309                 return ENOMEM;
 310         memset(profile, 0, sizeof(struct _profile_t));
 311         profile->magic = PROF_MAGIC_PROFILE;
 312         last = &profile->first_file;
 313
 314         /* if the filenames list is not specified return an empty profile */
 315         if ( files ) {
 316             for (fs = files; !PROFILE_LAST_FILESPEC(*fs); fs++) {
 317                 retval = get_dirlist(*fs, &array);
 318                 if (retval == 0) {
 319                         if (!array)
 320                                 continue;
 321                         for (cpp = array; (cp = *cpp); cpp++) {
 322                                 retval = profile_open_file(cp, &new_file);
 323                                 if (retval == EACCES)
 324                                         continue;
 325                                 if (retval)
 326                                         goto errout;
 327                                 *last = new_file;
 328                                 last = &new_file->next;
 329                         }
 330                 } else if ((retval != ENOTDIR) &&
 331                            strcmp(*fs, default_filename))
 332                         goto errout;
 333
 334                 retval = profile_open_file(*fs, &new_file);
 335                 /* if this file is missing, skip to the next */
 336                 if (retval == ENOENT || retval == EACCES) {
 337                         continue;
 338                 }
 339                 if (retval)
 340                         goto errout;
 341                 *last = new_file;
 342                 last = &new_file->next;
 343             }
 344             /*
 345              * If all the files were not found, return the appropriate error.
 346              */
 347             if (!profile->first_file) {
 348                 profile_release(profile);
 349                 return ENOENT;
 350             }
 351         }
 352
 353         free_list(array);
 354         *ret_profile = profile;
 355         return 0;
 356 errout:
 357         free_list(array);
 358         profile_release(profile);
 359         return retval;
 360 }
 361
 362 void
 363 profile_release(profile_t profile)
 364 {
 365         prf_file_t      p, next;
 366
 367         if (!profile || profile->magic != PROF_MAGIC_PROFILE)
 368                 return;
 369
 370         for (p = profile->first_file; p; p = next) {
 371                 next = p->next;
 372                 profile_free_file(p);
 373         }
 374         profile->magic = 0;
 375         free(profile);
 376 }
 377
 378 /*
 379  * This function sets the value of the pseudo file "<default>".  If
 380  * the file "<default>" had previously been passed to profile_init(),
 381  * then def_string parameter will be parsed and used as the profile
 382  * information for the "<default>" file.
 383  */
 384 errcode_t profile_set_default(profile_t profile, const char *def_string)
 385 {
 386         struct parse_state      state;
 387         prf_file_t              prf;
 388         errcode_t               retval;
 389         const char              *in;
 390         char                    *line, *p, *end;
 391         int                     line_size, len;
 392
 393         if (!def_string || !profile || profile->magic != PROF_MAGIC_PROFILE)
 394                 return PROF_MAGIC_PROFILE;
 395
 396         for (prf = profile->first_file; prf; prf = prf->next) {
 397                 if (strcmp(prf->filespec, default_filename) == 0)
 398                         break;
 399         }
 400         if (!prf)
 401                 return 0;
 402
 403         if (prf->root) {
 404                 profile_free_node(prf->root);
 405                 prf->root = 0;
 406         }
 407
 408         memset(&state, 0, sizeof(struct parse_state));
 409         retval = profile_create_node("(root)", 0, &state.root_section);
 410         if (retval)
 411                 return retval;
 412
 413         line = 0;
 414         line_size = 0;
 415         in = def_string;
 416         while (*in) {
 417                 end = strchr(in, '\n');
 418                 len = end ? (end - in) : (int) strlen(in);
 419                 if (len >= line_size) {
 420                         line_size = len+1;
 421                         p = realloc(line, line_size);
 422                         if (!p) {
 423                                 retval = ENOMEM;
 424                                 goto errout;
 425                         }
 426                         line = p;
 427                 }
 428                 memcpy(line, in, len);
 429                 line[len] = 0;
 430                 retval = parse_line(line, &state);
 431                 if (retval) {
 432                 errout:
 433                         if (syntax_err_cb)
 434                                 (syntax_err_cb)(prf->filespec, retval,
 435                                                 state.line_num);
 436                         free(line);
 437                         if (prf->root)
 438                                 profile_free_node(prf->root);
 439                         return retval;
 440                 }
 441                 if (!end)
 442                         break;
 443                 in = end+1;
 444         }
 445         prf->root = state.root_section;
 446         free(line);
 447
 448         return 0;
 449 }
 450
 451 /*
 452  * prof_file.c ---- routines that manipulate an individual profile file.
 453  */
 454
 455 errcode_t profile_open_file(const char * filespec,
 456                             prf_file_t *ret_prof)
 457 {
 458         prf_file_t      prf;
 459         errcode_t       retval;
 460         char            *home_env = 0;
 461         unsigned int    len;
 462         char            *expanded_filename;
 463
 464         prf = malloc(sizeof(struct _prf_file_t));
 465         if (!prf)
 466                 return ENOMEM;
 467         memset(prf, 0, sizeof(struct _prf_file_t));
 468         prf->magic = PROF_MAGIC_FILE;
 469
 470         len = strlen(filespec)+1;
 471         if (filespec[0] == '~' && filespec[1] == '/') {
 472                 home_env = getenv("HOME");
 473 #ifdef HAVE_PWD_H
 474                 if (home_env == NULL) {
 475 #ifdef HAVE_GETWUID_R
 476                     struct passwd *pw, pwx;
 477                     uid_t uid;
 478                     char pwbuf[BUFSIZ];
 479
 480                     uid = getuid();
 481                     if (!getpwuid_r(uid, &pwx, pwbuf, sizeof(pwbuf), &pw)
 482                         && pw != NULL && pw->pw_dir[0] != 0)
 483                         home_env = pw->pw_dir;
 484 #else
 485                     struct passwd *pw;
 486
 487                     pw = getpwuid(getuid());
 488                     home_env = pw->pw_dir;
 489 #endif
 490                 }
 491 #endif
 492                 if (home_env)
 493                         len += strlen(home_env);
 494         }
 495         expanded_filename = malloc(len);
 496         if (expanded_filename == 0) {
 497             profile_free_file(prf);
 498             return errno;
 499         }
 500         if (home_env) {
 501             strcpy(expanded_filename, home_env);
 502             strcat(expanded_filename, filespec+1);
 503         } else
 504             memcpy(expanded_filename, filespec, len);
 505
 506         prf->filespec = expanded_filename;
 507
 508         if (strcmp(prf->filespec, default_filename) != 0) {
 509                 retval = profile_update_file(prf);
 510                 if (retval) {
 511                         profile_free_file(prf);
 512                         return retval;
 513                 }
 514         }
 515
 516         *ret_prof = prf;
 517         return 0;
 518 }
 519
 520 errcode_t profile_update_file(prf_file_t prf)
 521 {
 522         errcode_t retval;
 523 #ifdef HAVE_STAT
 524         struct stat st;
 525 #ifdef STAT_ONCE_PER_SECOND
 526         time_t now;
 527 #endif
 528 #endif
 529         FILE *f;
 530         char buf[2048];
 531         struct parse_state state;
 532
 533         if (prf->flags & PROFILE_FILE_NO_RELOAD)
 534                 return 0;
 535
 536 #ifdef HAVE_STAT
 537 #ifdef STAT_ONCE_PER_SECOND
 538         now = time(0);
 539         if (now == prf->last_stat && prf->root != NULL) {
 540             return 0;
 541         }
 542 #endif
 543         if (stat(prf->filespec, &st)) {
 544             retval = errno;
 545             return retval;
 546         }
 547 #ifdef STAT_ONCE_PER_SECOND
 548         prf->last_stat = now;
 549 #endif
 550         if (st.st_mtime == prf->timestamp && prf->root != NULL) {
 551             return 0;
 552         }
 553         if (prf->root) {
 554                 profile_free_node(prf->root);
 555                 prf->root = 0;
 556         }
 557 #else
 558         /*
 559          * If we don't have the stat() call, assume that our in-core
 560          * memory image is correct.  That is, we won't reread the
 561          * profile file if it changes.
 562          */
 563         if (prf->root) {
 564             return 0;
 565         }
 566 #endif
 567         memset(&state, 0, sizeof(struct parse_state));
 568         retval = profile_create_node("(root)", 0, &state.root_section);
 569         if (retval)
 570                 return retval;
 571         errno = 0;
 572         f = fopen(prf->filespec, "r");
 573         if (f == NULL) {
 574                 retval = errno;
 575                 if (retval == 0)
 576                         retval = ENOENT;
 577                 return retval;
 578         }
 579         prf->upd_serial++;
 580         while (!feof(f)) {
 581                 if (fgets(buf, sizeof(buf), f) == NULL)
 582                         break;
 583                 retval = parse_line(buf, &state);
 584                 if (retval) {
 585                         if (syntax_err_cb)
 586                                 (syntax_err_cb)(prf->filespec, retval,
 587                                                 state.line_num);
 588                         fclose(f);
 589                         return retval;
 590                 }
 591         }
 592         prf->root = state.root_section;
 593
 594         fclose(f);
 595
 596 #ifdef HAVE_STAT
 597         prf->timestamp = st.st_mtime;
 598 #endif
 599         return 0;
 600 }
 601
 602 void profile_free_file(prf_file_t prf)
 603 {
 604     if (prf->root)
 605         profile_free_node(prf->root);
 606     free(prf->filespec);
 607     free(prf);
 608 }
 609
 610 /* Begin the profile parser */
 611
 612 profile_syntax_err_cb_t profile_set_syntax_err_cb(profile_syntax_err_cb_t hook)
 613 {
 614         profile_syntax_err_cb_t old;
 615
 616         old = syntax_err_cb;
 617         syntax_err_cb = hook;
 618         return(old);
 619 }
 620
 621 #define STATE_INIT_COMMENT      0
 622 #define STATE_STD_LINE          1
 623 #define STATE_GET_OBRACE        2
 624
 625 static char *skip_over_blanks(char *cp)
 626 {
 627         while (*cp && isspace((int) (*cp)))
 628                 cp++;
 629         return cp;
 630 }
 631
 632 static int end_or_comment(char ch)
 633 {
 634         return (ch == 0 || ch == '#' || ch == ';');
 635 }
 636
 637 static char *skip_over_nonblanks(char *cp)
 638 {
 639         while (!end_or_comment(*cp) && !isspace(*cp))
 640                 cp++;
 641         return cp;
 642 }
 643
 644 static void strip_line(char *line)
 645 {
 646         char *p = line + strlen(line);
 647         while (p > line && (p[-1] == '\n' || p[-1] == '\r'))
 648             *p-- = 0;
 649 }
 650
 651 static void parse_quoted_string(char *str)
 652 {
 653         char *to, *from;
 654
 655         to = from = str;
 656
 657         for (to = from = str; *from && *from != '"'; to++, from++) {
 658                 if (*from == '\\') {
 659                         from++;
 660                         switch (*from) {
 661                         case 'n':
 662                                 *to = '\n';
 663                                 break;
 664                         case 't':
 665                                 *to = '\t';
 666                                 break;
 667                         case 'b':
 668                                 *to = '\b';
 669                                 break;
 670                         default:
 671                                 *to = *from;
 672                         }
 673                         continue;
 674                 }
 675                 *to = *from;
 676         }
 677         *to = '\0';
 678 }
 679
 680 static errcode_t parse_line(char *line, struct parse_state *state)
 681 {
 682         char    *cp, ch, *tag, *value;
 683         char    *p;
 684         errcode_t retval;
 685         struct profile_node     *node;
 686         int do_subsection = 0;
 687         void *iter = 0;
 688
 689         state->line_num++;
 690         if (state->state == STATE_GET_OBRACE) {
 691                 cp = skip_over_blanks(line);
 692                 if (*cp != '{')
 693                         return PROF_MISSING_OBRACE;
 694                 state->state = STATE_STD_LINE;
 695                 return 0;
 696         }
 697         if (state->state == STATE_INIT_COMMENT) {
 698                 if (line[0] != '[')
 699                         return 0;
 700                 state->state = STATE_STD_LINE;
 701         }
 702
 703         if (*line == 0)
 704                 return 0;
 705         strip_line(line);
 706         cp = skip_over_blanks(line);
 707         ch = *cp;
 708         if (end_or_comment(ch))
 709                 return 0;
 710         if (ch == '[') {
 711                 if (state->group_level > 0)
 712                         return PROF_SECTION_NOTOP;
 713                 cp++;
 714                 cp = skip_over_blanks(cp);
 715                 p = strchr(cp, ']');
 716                 if (p == NULL)
 717                         return PROF_SECTION_SYNTAX;
 718                 if (*cp == '"') {
 719                         cp++;
 720                         parse_quoted_string(cp);
 721                 } else {
 722                         *p-- = '\0';
 723                         while (isspace(*p) && (p > cp))
 724                                 *p-- = '\0';
 725                         if (*cp == 0)
 726                                 return PROF_SECTION_SYNTAX;
 727                 }
 728                 retval = profile_find_node(state->root_section, cp, 0, 1,
 729                                            &iter, &state->current_section);
 730                 if (retval == PROF_NO_SECTION) {
 731                         retval = profile_add_node(state->root_section,
 732                                                   cp, 0,
 733                                                   &state->current_section);
 734                         if (retval)
 735                                 return retval;
 736                 } else if (retval)
 737                         return retval;
 738
 739                 /*
 740                  * Finish off the rest of the line.
 741                  */
 742                 cp = p+1;
 743                 if (*cp == '*') {
 744                         state->current_section->final = 1;
 745                         cp++;
 746                 }
 747                 /*
 748                  * Spaces or comments after ']' should not be fatal
 749                  */
 750                 cp = skip_over_blanks(cp);
 751                 if (!end_or_comment(*cp))
 752                         return PROF_SECTION_SYNTAX;
 753                 return 0;
 754         }
 755         if (ch == '}') {
 756                 if (state->group_level == 0)
 757                         return PROF_EXTRA_CBRACE;
 758                 if (*(cp+1) == '*')
 759                         state->current_section->final = 1;
 760                 state->current_section = state->current_section->parent;
 761                 state->group_level--;
 762                 return 0;
 763         }
 764         /*
 765          * Parse the relations
 766          */
 767         tag = cp;
 768         cp = strchr(cp, '=');
 769         if (!cp)
 770                 return PROF_RELATION_SYNTAX;
 771         if (cp == tag)
 772             return PROF_RELATION_SYNTAX;
 773         *cp = '\0';
 774         if (*tag == '"') {
 775                 tag++;
 776                 parse_quoted_string(tag);
 777         } else {
 778                 /* Look for whitespace on left-hand side.  */
 779                 p = skip_over_nonblanks(tag);
 780                 if (*p)
 781                         *p++ = 0;
 782                 p = skip_over_blanks(p);
 783                 /* If we have more non-whitespace, it's an error.  */
 784                 if (*p)
 785                         return PROF_RELATION_SYNTAX;
 786         }
 787
 788         cp = skip_over_blanks(cp+1);
 789         value = cp;
 790         ch = value[0];
 791         if (ch == '"') {
 792                 value++;
 793                 parse_quoted_string(value);
 794         } else if (end_or_comment(ch)) {
 795                 do_subsection++;
 796                 state->state = STATE_GET_OBRACE;
 797         } else if (value[0] == '{') {
 798                 cp = skip_over_blanks(value+1);
 799                 ch = *cp;
 800                 if (end_or_comment(ch))
 801                         do_subsection++;
 802                 else
 803                         return PROF_RELATION_SYNTAX;
 804         } else {
 805                 cp = skip_over_nonblanks(value);
 806                 p = skip_over_blanks(cp);
 807                 ch = *p;
 808                 *cp = 0;
 809                 if (!end_or_comment(ch))
 810                         return PROF_RELATION_SYNTAX;
 811         }
 812         if (do_subsection) {
 813                 p = strchr(tag, '*');
 814                 if (p)
 815                         *p = '\0';
 816                 retval = profile_add_node(state->current_section,
 817                                           tag, 0, &state->current_section);
 818                 if (retval)
 819                         return retval;
 820                 if (p)
 821                         state->current_section->final = 1;
 822                 state->group_level++;
 823                 return 0;
 824         }
 825         p = strchr(tag, '*');
 826         if (p)
 827                 *p = '\0';
 828         profile_add_node(state->current_section, tag, value, &node);
 829         if (p)
 830                 node->final = 1;
 831         return 0;
 832 }
 833
 834 #ifdef DEBUG_PROGRAM
 835 /*
 836  * Return TRUE if the string begins or ends with whitespace
 837  */
 838 static int need_double_quotes(char *str)
 839 {
 840         if (!str || !*str)
 841                 return 0;
 842         if (isspace((int) (*str)) ||isspace((int) (*(str + strlen(str) - 1))))
 843                 return 1;
 844         if (strchr(str, '\n') || strchr(str, '\t') || strchr(str, '\b') ||
 845             strchr(str, ' ') || strchr(str, '#') || strchr(str, ';'))
 846                 return 1;
 847         return 0;
 848 }
 849
 850 /*
 851  * Output a string with double quotes, doing appropriate backquoting
 852  * of characters as necessary.
 853  */
 854 static void output_quoted_string(char *str, void (*cb)(const char *,void *),
 855                                  void *data)
 856 {
 857         char    ch;
 858         char buf[2];
 859
 860         cb("\"", data);
 861         if (!str) {
 862                 cb("\"", data);
 863                 return;
 864         }
 865         buf[1] = 0;
 866         while ((ch = *str++)) {
 867                 switch (ch) {
 868                 case '\\':
 869                         cb("\\\\", data);
 870                         break;
 871                 case '\n':
 872                         cb("\\n", data);
 873                         break;
 874                 case '\t':
 875                         cb("\\t", data);
 876                         break;
 877                 case '\b':
 878                         cb("\\b", data);
 879                         break;
 880                 default:
 881                         /* This would be a lot faster if we scanned
 882                            forward for the next "interesting"
 883                            character.  */
 884                         buf[0] = ch;
 885                         cb(buf, data);
 886                         break;
 887                 }
 888         }
 889         cb("\"", data);
 890 }
 891
 892 #ifndef EOL
 893 #define EOL "\n"
 894 #endif
 895
 896 /* Errors should be returned, not ignored!  */
 897 static void dump_profile(struct profile_node *root, int level,
 898                          void (*cb)(const char *, void *), void *data)
 899 {
 900         int i;
 901         struct profile_node *p;
 902         void *iter;
 903         long retval;
 904
 905         iter = 0;
 906         do {
 907                 retval = profile_find_node(root, 0, 0, 0, &iter, &p);
 908                 if (retval)
 909                         break;
 910                 for (i=0; i < level; i++)
 911                         cb("\t", data);
 912                 if (need_double_quotes(p->name))
 913                         output_quoted_string(p->name, cb, data);
 914                 else
 915                         cb(p->name, data);
 916                 cb(" = ", data);
 917                 if (need_double_quotes(p->value))
 918                         output_quoted_string(p->value, cb, data);
 919                 else
 920                         cb(p->value, data);
 921                 cb(EOL, data);
 922         } while (iter != 0);
 923
 924         iter = 0;
 925         do {
 926                 retval = profile_find_node(root, 0, 0, 1, &iter, &p);
 927                 if (retval)
 928                         break;
 929                 if (level == 0) { /* [xxx] */
 930                         cb("[", data);
 931                         if (need_double_quotes(p->name))
 932                                 output_quoted_string(p->name, cb, data);
 933                         else
 934                                 cb(p->name, data);
 935                         cb("]", data);
 936                         cb(p->final ? "*" : "", data);
 937                         cb(EOL, data);
 938                         dump_profile(p, level+1, cb, data);
 939                         cb(EOL, data);
 940                 } else {        /* xxx = { ... } */
 941                         for (i=0; i < level; i++)
 942                                 cb("\t", data);
 943                         if (need_double_quotes(p->name))
 944                                 output_quoted_string(p->name, cb, data);
 945                         else
 946                                 cb(p->name, data);
 947                         cb(" = {", data);
 948                         cb(EOL, data);
 949                         dump_profile(p, level+1, cb, data);
 950                         for (i=0; i < level; i++)
 951                                 cb("\t", data);
 952                         cb("}", data);
 953                         cb(p->final ? "*" : "", data);
 954                         cb(EOL, data);
 955                 }
 956         } while (iter != 0);
 957 }
 958
 959 static void dump_profile_to_file_cb(const char *str, void *data)
 960 {
 961         fputs(str, data);
 962 }
 963
 964 errcode_t profile_write_tree_file(struct profile_node *root, FILE *dstfile)
 965 {
 966         dump_profile(root, 0, dump_profile_to_file_cb, dstfile);
 967         return 0;
 968 }
 969
 970 struct prof_buf {
 971         char *base;
 972         size_t cur, max;
 973         int err;
 974 };
 975
 976 static void add_data_to_buffer(struct prof_buf *b, const void *d, size_t len)
 977 {
 978         if (b->err)
 979                 return;
 980         if (b->max - b->cur < len) {
 981                 size_t newsize;
 982                 char *newptr;
 983
 984                 newsize = b->max + (b->max >> 1) + len + 1024;
 985                 newptr = realloc(b->base, newsize);
 986                 if (newptr == NULL) {
 987                         b->err = 1;
 988                         return;
 989                 }
 990                 b->base = newptr;
 991                 b->max = newsize;
 992         }
 993         memcpy(b->base + b->cur, d, len);
 994         b->cur += len;          /* ignore overflow */
 995 }
 996
 997 static void dump_profile_to_buffer_cb(const char *str, void *data)
 998 {
 999         add_data_to_buffer((struct prof_buf *)data, str, strlen(str));
1000 }
1001
1002 errcode_t profile_write_tree_to_buffer(struct profile_node *root,
1003                                        char **buf)
1004 {
1005         struct prof_buf prof_buf = { 0, 0, 0, 0 };
1006
1007         dump_profile(root, 0, dump_profile_to_buffer_cb, &prof_buf);
1008         if (prof_buf.err) {
1009                 *buf = NULL;
1010                 return ENOMEM;
1011         }
1012         add_data_to_buffer(&prof_buf, "", 1); /* append nul */
1013         if (prof_buf.max - prof_buf.cur > (prof_buf.max >> 3)) {
1014                 char *newptr = realloc(prof_buf.base, prof_buf.cur);
1015                 if (newptr)
1016                         prof_buf.base = newptr;
1017         }
1018         *buf = prof_buf.base;
1019         return 0;
1020 }
1021 #endif
1022
1023 /*
1024  * prof_tree.c --- these routines maintain the parse tree of the
1025  *      config file.
1026  *
1027  * All of the details of how the tree is stored is abstracted away in
1028  * this file; all of the other profile routines build, access, and
1029  * modify the tree via the accessor functions found in this file.
1030  *
1031  * Each node may represent either a relation or a section header.
1032  *
1033  * A section header must have its value field set to 0, and may a one
1034  * or more child nodes, pointed to by first_child.
1035  *
1036  * A relation has as its value a pointer to allocated memory
1037  * containing a string.  Its first_child pointer must be null.
1038  *
1039  */
1040
1041 /*
1042  * Free a node, and any children
1043  */
1044 void profile_free_node(struct profile_node *node)
1045 {
1046         struct profile_node *child, *next;
1047
1048         if (node->magic != PROF_MAGIC_NODE)
1049                 return;
1050
1051         free(node->name);
1052         free(node->value);
1053
1054         for (child=node->first_child; child; child = next) {
1055                 next = child->next;
1056                 profile_free_node(child);
1057         }
1058         node->magic = 0;
1059
1060         free(node);
1061 }
1062
1063 #ifndef HAVE_STRDUP
1064 #undef strdup
1065 #define strdup MYstrdup
1066 static char *MYstrdup (const char *s)
1067 {
1068     size_t sz = strlen(s) + 1;
1069     char *p = malloc(sz);
1070     if (p != 0)
1071         memcpy(p, s, sz);
1072     return p;
1073 }
1074 #endif
1075
1076 /*
1077  * Create a node
1078  */
1079 errcode_t profile_create_node(const char *name, const char *value,
1080                               struct profile_node **ret_node)
1081 {
1082         struct profile_node *new;
1083
1084         new = malloc(sizeof(struct profile_node));
1085         if (!new)
1086                 return ENOMEM;
1087         memset(new, 0, sizeof(struct profile_node));
1088         new->name = strdup(name);
1089         if (new->name == 0) {
1090             profile_free_node(new);
1091             return ENOMEM;
1092         }
1093         if (value) {
1094                 new->value = strdup(value);
1095                 if (new->value == 0) {
1096                     profile_free_node(new);
1097                     return ENOMEM;
1098                 }
1099         }
1100         new->magic = PROF_MAGIC_NODE;
1101
1102         *ret_node = new;
1103         return 0;
1104 }
1105
1106 /*
1107  * This function verifies that all of the representation invarients of
1108  * the profile are true.  If not, we have a programming bug somewhere,
1109  * probably in this file.
1110  */
1111 #ifdef DEBUG_PROGRAM
1112 errcode_t profile_verify_node(struct profile_node *node)
1113 {
1114         struct profile_node *p, *last;
1115         errcode_t       retval;
1116
1117         CHECK_MAGIC(node);
1118
1119         if (node->value && node->first_child)
1120                 return PROF_SECTION_WITH_VALUE;
1121
1122         last = 0;
1123         for (p = node->first_child; p; last = p, p = p->next) {
1124                 if (p->prev != last)
1125                         return PROF_BAD_LINK_LIST;
1126                 if (last && (last->next != p))
1127                         return PROF_BAD_LINK_LIST;
1128                 if (node->group_level+1 != p->group_level)
1129                         return PROF_BAD_GROUP_LVL;
1130                 if (p->parent != node)
1131                         return PROF_BAD_PARENT_PTR;
1132                 retval = profile_verify_node(p);
1133                 if (retval)
1134                         return retval;
1135         }
1136         return 0;
1137 }
1138 #endif
1139
1140 /*
1141  * Add a node to a particular section
1142  */
1143 errcode_t profile_add_node(struct profile_node *section, const char *name,
1144                            const char *value, struct profile_node **ret_node)
1145 {
1146         errcode_t retval;
1147         struct profile_node *p, *last, *new;
1148
1149         CHECK_MAGIC(section);
1150
1151         if (section->value)
1152                 return PROF_ADD_NOT_SECTION;
1153
1154         /*
1155          * Find the place to insert the new node.  We look for the
1156          * place *after* the last match of the node name, since
1157          * order matters.
1158          */
1159         for (p=section->first_child, last = 0; p; last = p, p = p->next) {
1160                 int cmp;
1161                 cmp = strcmp(p->name, name);
1162                 if (cmp > 0)
1163                         break;
1164         }
1165         retval = profile_create_node(name, value, &new);
1166         if (retval)
1167                 return retval;
1168         new->group_level = section->group_level+1;
1169         new->deleted = 0;
1170         new->parent = section;
1171         new->prev = last;
1172         new->next = p;
1173         if (p)
1174                 p->prev = new;
1175         if (last)
1176                 last->next = new;
1177         else
1178                 section->first_child = new;
1179         if (ret_node)
1180                 *ret_node = new;
1181         return 0;
1182 }
1183
1184 /*
1185  * Iterate through the section, returning the nodes which match
1186  * the given name.  If name is NULL, then interate through all the
1187  * nodes in the section.  If section_flag is non-zero, only return the
1188  * section which matches the name; don't return relations.  If value
1189  * is non-NULL, then only return relations which match the requested
1190  * value.  (The value argument is ignored if section_flag is non-zero.)
1191  *
1192  * The first time this routine is called, the state pointer must be
1193  * null.  When this profile_find_node_relation() returns, if the state
1194  * pointer is non-NULL, then this routine should be called again.
1195  * (This won't happen if section_flag is non-zero, obviously.)
1196  *
1197  */
1198 errcode_t profile_find_node(struct profile_node *section, const char *name,
1199                             const char *value, int section_flag, void **state,
1200                             struct profile_node **node)
1201 {
1202         struct profile_node *p;
1203
1204         CHECK_MAGIC(section);
1205         p = *state;
1206         if (p) {
1207                 CHECK_MAGIC(p);
1208         } else
1209                 p = section->first_child;
1210
1211         for (; p; p = p->next) {
1212                 if (name && (strcmp(p->name, name)))
1213                         continue;
1214                 if (section_flag) {
1215                         if (p->value)
1216                                 continue;
1217                 } else {
1218                         if (!p->value)
1219                                 continue;
1220                         if (value && (strcmp(p->value, value)))
1221                                 continue;
1222                 }
1223                 if (p->deleted)
1224                     continue;
1225                 /* A match! */
1226                 if (node)
1227                         *node = p;
1228                 break;
1229         }
1230         if (p == 0) {
1231                 *state = 0;
1232                 return section_flag ? PROF_NO_SECTION : PROF_NO_RELATION;
1233         }
1234         /*
1235          * OK, we've found one match; now let's try to find another
1236          * one.  This way, if we return a non-zero state pointer,
1237          * there's guaranteed to be another match that's returned.
1238          */
1239         for (p = p->next; p; p = p->next) {
1240                 if (name && (strcmp(p->name, name)))
1241                         continue;
1242                 if (section_flag) {
1243                         if (p->value)
1244                                 continue;
1245                 } else {
1246                         if (!p->value)
1247                                 continue;
1248                         if (value && (strcmp(p->value, value)))
1249                                 continue;
1250                 }
1251                 /* A match! */
1252                 break;
1253         }
1254         *state = p;
1255         return 0;
1256 }
1257
1258 /*
1259  * This is a general-purpose iterator for returning all nodes that
1260  * match the specified name array.
1261  */
1262 struct profile_iterator {
1263         prf_magic_t             magic;
1264         profile_t               profile;
1265         int                     flags;
1266         const char              *const *names;
1267         const char              *name;
1268         prf_file_t              file;
1269         int                     file_serial;
1270         int                     done_idx;
1271         struct profile_node     *node;
1272         int                     num;
1273 };
1274
1275 errcode_t
1276 profile_iterator_create(profile_t profile, const char *const *names, int flags,
1277                         void **ret_iter)
1278 {
1279         struct profile_iterator *iter;
1280         int     done_idx = 0;
1281
1282         if (profile == 0)
1283                 return PROF_NO_PROFILE;
1284         if (profile->magic != PROF_MAGIC_PROFILE)
1285                 return PROF_MAGIC_PROFILE;
1286         if (!names)
1287                 return PROF_BAD_NAMESET;
1288         if (!(flags & PROFILE_ITER_LIST_SECTION)) {
1289                 if (!names[0])
1290                         return PROF_BAD_NAMESET;
1291                 done_idx = 1;
1292         }
1293
1294         if ((iter = malloc(sizeof(struct profile_iterator))) == NULL)
1295                 return ENOMEM;
1296
1297         iter->magic = PROF_MAGIC_ITERATOR;
1298         iter->profile = profile;
1299         iter->names = names;
1300         iter->flags = flags;
1301         iter->file = profile->first_file;
1302         iter->done_idx = done_idx;
1303         iter->node = 0;
1304         iter->num = 0;
1305         *ret_iter = iter;
1306         return 0;
1307 }
1308
1309 void profile_iterator_free(void **iter_p)
1310 {
1311         struct profile_iterator *iter;
1312
1313         if (!iter_p)
1314                 return;
1315         iter = *iter_p;
1316         if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
1317                 return;
1318         free(iter);
1319         *iter_p = 0;
1320 }
1321
1322 /*
1323  * Note: the returned character strings in ret_name and ret_value
1324  * points to the stored character string in the parse string.  Before
1325  * this string value is returned to a calling application
1326  * (profile_node_iterator is not an exported interface), it should be
1327  * strdup()'ed.
1328  */
1329 errcode_t profile_node_iterator(void **iter_p, struct profile_node **ret_node,
1330                                 char **ret_name, char **ret_value)
1331 {
1332         struct profile_iterator         *iter = *iter_p;
1333         struct profile_node             *section, *p;
1334         const char                      *const *cpp;
1335         errcode_t                       retval;
1336         int                             skip_num = 0;
1337
1338         if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
1339                 return PROF_MAGIC_ITERATOR;
1340         if (iter->file && iter->file->magic != PROF_MAGIC_FILE)
1341             return PROF_MAGIC_FILE;
1342         /*
1343          * If the file has changed, then the node pointer is invalid,
1344          * so we'll have search the file again looking for it.
1345          */
1346         if (iter->node && (iter->file &&
1347                            iter->file->upd_serial != iter->file_serial)) {
1348                 iter->flags &= ~PROFILE_ITER_FINAL_SEEN;
1349                 skip_num = iter->num;
1350                 iter->node = 0;
1351         }
1352         if (iter->node && iter->node->magic != PROF_MAGIC_NODE) {
1353             return PROF_MAGIC_NODE;
1354         }
1355 get_new_file:
1356         if (iter->node == 0) {
1357                 if (iter->file == 0 ||
1358                     (iter->flags & PROFILE_ITER_FINAL_SEEN)) {
1359                         profile_iterator_free(iter_p);
1360                         if (ret_node)
1361                                 *ret_node = 0;
1362                         if (ret_name)
1363                                 *ret_name = 0;
1364                         if (ret_value)
1365                                 *ret_value =0;
1366                         return 0;
1367                 }
1368                 if ((retval = profile_update_file(iter->file))) {
1369                     if (retval == ENOENT || retval == EACCES) {
1370                         /* XXX memory leak? */
1371                         iter->file = iter->file->next;
1372                         skip_num = 0;
1373                         retval = 0;
1374                         goto get_new_file;
1375                     } else {
1376                         profile_iterator_free(iter_p);
1377                         return retval;
1378                     }
1379                 }
1380                 iter->file_serial = iter->file->upd_serial;
1381                 /*
1382                  * Find the section to list if we are a LIST_SECTION,
1383                  * or find the containing section if not.
1384                  */
1385                 section = iter->file->root;
1386                 for (cpp = iter->names; cpp[iter->done_idx]; cpp++) {
1387                         for (p=section->first_child; p; p = p->next) {
1388                                 if (!strcmp(p->name, *cpp) && !p->value)
1389                                         break;
1390                         }
1391                         if (!p) {
1392                                 section = 0;
1393                                 break;
1394                         }
1395                         section = p;
1396                         if (p->final)
1397                                 iter->flags |= PROFILE_ITER_FINAL_SEEN;
1398                 }
1399                 if (!section) {
1400                         iter->file = iter->file->next;
1401                         skip_num = 0;
1402                         goto get_new_file;
1403                 }
1404                 iter->name = *cpp;
1405                 iter->node = section->first_child;
1406         }
1407         /*
1408          * OK, now we know iter->node is set up correctly.  Let's do
1409          * the search.
1410          */
1411         for (p = iter->node; p; p = p->next) {
1412                 if (iter->name && strcmp(p->name, iter->name))
1413                         continue;
1414                 if ((iter->flags & PROFILE_ITER_SECTIONS_ONLY) &&
1415                     p->value)
1416                         continue;
1417                 if ((iter->flags & PROFILE_ITER_RELATIONS_ONLY) &&
1418                     !p->value)
1419                         continue;
1420                 if (skip_num > 0) {
1421                         skip_num--;
1422                         continue;
1423                 }
1424                 if (p->deleted)
1425                         continue;
1426                 break;
1427         }
1428         iter->num++;
1429         if (!p) {
1430                 iter->file = iter->file->next;
1431                 iter->node = 0;
1432                 skip_num = 0;
1433                 goto get_new_file;
1434         }
1435         if ((iter->node = p->next) == NULL)
1436                 iter->file = iter->file->next;
1437         if (ret_node)
1438                 *ret_node = p;
1439         if (ret_name)
1440                 *ret_name = p->name;
1441         if (ret_value)
1442                 *ret_value = p->value;
1443         return 0;
1444 }
1445
1446
1447 /*
1448  * prof_get.c --- routines that expose the public interfaces for
1449  *      querying items from the profile.
1450  *
1451  */
1452
1453 /*
1454  * This function only gets the first value from the file; it is a
1455  * helper function for profile_get_string, profile_get_integer, etc.
1456  */
1457 errcode_t profile_get_value(profile_t profile, const char *name,
1458                             const char *subname, const char *subsubname,
1459                             const char **ret_value)
1460 {
1461         errcode_t               retval;
1462         void                    *state;
1463         char                    *value;
1464         const char              *names[4];
1465
1466         names[0] = name;
1467         names[1] = subname;
1468         names[2] = subsubname;
1469         names[3] = 0;
1470
1471         if ((retval = profile_iterator_create(profile, names,
1472                                               PROFILE_ITER_RELATIONS_ONLY,
1473                                               &state)))
1474                 return retval;
1475
1476         if ((retval = profile_node_iterator(&state, 0, 0, &value)))
1477                 goto cleanup;
1478
1479         if (value)
1480                 *ret_value = value;
1481         else
1482                 retval = PROF_NO_RELATION;
1483
1484 cleanup:
1485         profile_iterator_free(&state);
1486         return retval;
1487 }
1488
1489 errcode_t
1490 profile_get_string(profile_t profile, const char *name, const char *subname,
1491                    const char *subsubname, const char *def_val,
1492                    char **ret_string)
1493 {
1494         const char      *value;
1495         errcode_t       retval;
1496
1497         if (profile) {
1498                 retval = profile_get_value(profile, name, subname,
1499                                            subsubname, &value);
1500                 if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION)
1501                         value = def_val;
1502                 else if (retval)
1503                         return retval;
1504         } else
1505                 value = def_val;
1506
1507         if (value) {
1508                 *ret_string = malloc(strlen(value)+1);
1509                 if (*ret_string == 0)
1510                         return ENOMEM;
1511                 strcpy(*ret_string, value);
1512         } else
1513                 *ret_string = 0;
1514         return 0;
1515 }
1516
1517 errcode_t
1518 profile_get_integer(profile_t profile, const char *name, const char *subname,
1519                     const char *subsubname, int def_val, int *ret_int)
1520 {
1521         const char      *value;
1522         errcode_t       retval;
1523         char            *end_value;
1524         long            ret_long;
1525
1526         *ret_int = def_val;
1527         if (profile == 0)
1528                 return 0;
1529
1530         retval = profile_get_value(profile, name, subname, subsubname, &value);
1531         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1532                 *ret_int = def_val;
1533                 return 0;
1534         } else if (retval)
1535                 return retval;
1536
1537         if (value[0] == 0)
1538             /* Empty string is no good.  */
1539             return PROF_BAD_INTEGER;
1540         errno = 0;
1541         ret_long = strtol (value, &end_value, 10);
1542
1543         /* Overflow or underflow.  */
1544         if ((ret_long == LONG_MIN || ret_long == LONG_MAX) && errno != 0)
1545             return PROF_BAD_INTEGER;
1546         /* Value outside "int" range.  */
1547         if ((long) (int) ret_long != ret_long)
1548             return PROF_BAD_INTEGER;
1549         /* Garbage in string.  */
1550         if (end_value != value + strlen (value))
1551             return PROF_BAD_INTEGER;
1552
1553
1554         *ret_int = ret_long;
1555         return 0;
1556 }
1557
1558 errcode_t
1559 profile_get_uint(profile_t profile, const char *name, const char *subname,
1560                  const char *subsubname, unsigned int def_val,
1561                  unsigned int *ret_int)
1562 {
1563         const char      *value;
1564         errcode_t       retval;
1565         char            *end_value;
1566         unsigned long   ret_long;
1567
1568         *ret_int = def_val;
1569         if (profile == 0)
1570                 return 0;
1571
1572         retval = profile_get_value(profile, name, subname, subsubname, &value);
1573         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1574                 *ret_int = def_val;
1575                 return 0;
1576         } else if (retval)
1577                 return retval;
1578
1579         if (value[0] == 0)
1580             /* Empty string is no good.  */
1581             return PROF_BAD_INTEGER;
1582         errno = 0;
1583         ret_long = strtoul (value, &end_value, 10);
1584
1585         /* Overflow or underflow.  */
1586         if ((ret_long == ULONG_MAX) && errno != 0)
1587             return PROF_BAD_INTEGER;
1588         /* Value outside "int" range.  */
1589         if ((unsigned long) (unsigned int) ret_long != ret_long)
1590             return PROF_BAD_INTEGER;
1591         /* Garbage in string.  */
1592         if (end_value != value + strlen (value))
1593             return PROF_BAD_INTEGER;
1594
1595         *ret_int = ret_long;
1596         return 0;
1597 }
1598
1599 static const char *const conf_yes[] = {
1600     "y", "yes", "true", "t", "1", "on",
1601     0,
1602 };
1603
1604 static const char *const conf_no[] = {
1605     "n", "no", "false", "nil", "0", "off",
1606     0,
1607 };
1608
1609 static errcode_t
1610 profile_parse_boolean(const char *s, int *ret_boolean)
1611 {
1612     const char *const *p;
1613
1614     if (ret_boolean == NULL)
1615         return PROF_EINVAL;
1616
1617     for(p=conf_yes; *p; p++) {
1618                 if (!strcasecmp(*p,s)) {
1619                         *ret_boolean = 1;
1620                 return 0;
1621                 }
1622     }
1623
1624     for(p=conf_no; *p; p++) {
1625                 if (!strcasecmp(*p,s)) {
1626                         *ret_boolean = 0;
1627                         return 0;
1628                 }
1629     }
1630
1631         return PROF_BAD_BOOLEAN;
1632 }
1633
1634 errcode_t
1635 profile_get_boolean(profile_t profile, const char *name, const char *subname,
1636                     const char *subsubname, int def_val, int *ret_boolean)
1637 {
1638         const char      *value;
1639         errcode_t       retval;
1640
1641         if (profile == 0) {
1642                 *ret_boolean = def_val;
1643                 return 0;
1644         }
1645
1646         retval = profile_get_value(profile, name, subname, subsubname, &value);
1647         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1648                 *ret_boolean = def_val;
1649                 return 0;
1650         } else if (retval)
1651                 return retval;
1652
1653         return profile_parse_boolean (value, ret_boolean);
1654 }
1655
1656 errcode_t
1657 profile_iterator(void **iter_p, char **ret_name, char **ret_value)
1658 {
1659         char *name, *value;
1660         errcode_t       retval;
1661
1662         retval = profile_node_iterator(iter_p, 0, &name, &value);
1663         if (retval)
1664                 return retval;
1665
1666         if (ret_name) {
1667                 if (name) {
1668                         *ret_name = malloc(strlen(name)+1);
1669                         if (!*ret_name)
1670                                 return ENOMEM;
1671                         strcpy(*ret_name, name);
1672                 } else
1673                         *ret_name = 0;
1674         }
1675         if (ret_value) {
1676                 if (value) {
1677                         *ret_value = malloc(strlen(value)+1);
1678                         if (!*ret_value) {
1679                                 if (ret_name) {
1680                                         free(*ret_name);
1681                                         *ret_name = 0;
1682                                 }
1683                                 return ENOMEM;
1684                         }
1685                         strcpy(*ret_value, value);
1686                 } else
1687                         *ret_value = 0;
1688         }
1689         return 0;
1690 }
1691
1692 #ifdef DEBUG_PROGRAM
1693
1694 /*
1695  * test_profile.c --- testing program for the profile routine
1696  */
1697
1698 #include "argv_parse.h"
1699 #include "profile_helpers.h"
1700
1701 const char *program_name = "test_profile";
1702
1703 #define PRINT_VALUE     1
1704 #define PRINT_VALUES    2
1705
1706 static void do_cmd(profile_t profile, char **argv)
1707 {
1708         errcode_t       retval;
1709         const char      **names, *value;
1710         char            **values, **cpp;
1711         char    *cmd;
1712         int             print_status;
1713
1714         cmd = *(argv);
1715         names = (const char **) argv + 1;
1716         print_status = 0;
1717         retval = 0;
1718         if (cmd == 0)
1719                 return;
1720         if (!strcmp(cmd, "query")) {
1721                 retval = profile_get_values(profile, names, &values);
1722                 print_status = PRINT_VALUES;
1723         } else if (!strcmp(cmd, "query1")) {
1724                 const char *name = 0;
1725                 const char *subname = 0;
1726                 const char *subsubname = 0;
1727
1728                 name = names[0];
1729                 if (name)
1730                         subname = names[1];
1731                 if (subname)
1732                         subsubname = names[2];
1733                 if (subsubname && names[3]) {
1734                         fprintf(stderr,
1735                                 "Only 3 levels are allowed with query1\n");
1736                         retval = EINVAL;
1737                 } else
1738                         retval = profile_get_value(profile, name, subname,
1739                                                    subsubname, &value);
1740                 print_status = PRINT_VALUE;
1741         } else if (!strcmp(cmd, "list_sections")) {
1742                 retval = profile_get_subsection_names(profile, names,
1743                                                       &values);
1744                 print_status = PRINT_VALUES;
1745         } else if (!strcmp(cmd, "list_relations")) {
1746                 retval = profile_get_relation_names(profile, names,
1747                                                     &values);
1748                 print_status = PRINT_VALUES;
1749         } else if (!strcmp(cmd, "dump")) {
1750                 retval = profile_write_tree_file
1751                         (profile->first_file->root, stdout);
1752 #if 0
1753         } else if (!strcmp(cmd, "clear")) {
1754                 retval = profile_clear_relation(profile, names);
1755         } else if (!strcmp(cmd, "update")) {
1756                 retval = profile_update_relation(profile, names+2,
1757                                                  *names, *(names+1));
1758 #endif
1759         } else if (!strcmp(cmd, "verify")) {
1760                 retval = profile_verify_node
1761                         (profile->first_file->root);
1762 #if 0
1763         } else if (!strcmp(cmd, "rename_section")) {
1764                 retval = profile_rename_section(profile, names+1, *names);
1765         } else if (!strcmp(cmd, "add")) {
1766                 value = *names;
1767                 if (strcmp(value, "NULL") == 0)
1768                         value = NULL;
1769                 retval = profile_add_relation(profile, names+1, value);
1770         } else if (!strcmp(cmd, "flush")) {
1771                 retval = profile_flush(profile);
1772 #endif
1773         } else {
1774                 printf("Invalid command.\n");
1775         }
1776         if (retval) {
1777                 com_err(cmd, retval, "");
1778                 print_status = 0;
1779         }
1780         switch (print_status) {
1781         case PRINT_VALUE:
1782                 printf("%s\n", value);
1783                 break;
1784         case PRINT_VALUES:
1785                 for (cpp = values; *cpp; cpp++)
1786                         printf("%s\n", *cpp);
1787                 profile_free_list(values);
1788                 break;
1789         }
1790 }
1791
1792 static void do_batchmode(profile_t profile)
1793 {
1794         int             argc, ret;
1795         char            **argv;
1796         char            buf[256];
1797
1798         while (!feof(stdin)) {
1799                 if (fgets(buf, sizeof(buf), stdin) == NULL)
1800                         break;
1801                 printf(">%s", buf);
1802                 ret = argv_parse(buf, &argc, &argv);
1803                 if (ret != 0) {
1804                         printf("Argv_parse returned %d!\n", ret);
1805                         continue;
1806                 }
1807                 do_cmd(profile, argv);
1808                 printf("\n");
1809                 argv_free(argv);
1810         }
1811         profile_release(profile);
1812         exit(0);
1813
1814 }
1815
1816 void syntax_err_report(const char *filename, long err, int line_num)
1817 {
1818         fprintf(stderr, "Syntax error in %s, line number %d: %s\n",
1819                 filename, line_num, error_message(err));
1820         exit(1);
1821 }
1822
1823 const char *default_str = "[foo]\n\tbar=quux\n\tsub = {\n\t\twin = true\n}\n";
1824
1825 int main(int argc, char **argv)
1826 {
1827     profile_t   profile;
1828     long        retval;
1829     char        *cmd;
1830
1831     if (argc < 2) {
1832             fprintf(stderr, "Usage: %s filename [cmd argset]\n", program_name);
1833             exit(1);
1834     }
1835
1836     initialize_prof_error_table();
1837
1838     profile_set_syntax_err_cb(syntax_err_report);
1839
1840     retval = profile_init_path(argv[1], &profile);
1841     if (retval) {
1842         com_err(program_name, retval, "while initializing profile");
1843         exit(1);
1844     }
1845     retval = profile_set_default(profile, default_str);
1846     if (retval) {
1847         com_err(program_name, retval, "while setting default");
1848         exit(1);
1849     }
1850
1851     cmd = *(argv+2);
1852     if (!cmd || !strcmp(cmd, "batch"))
1853             do_batchmode(profile);
1854     else
1855             do_cmd(profile, argv+2);
1856     profile_release(profile);
1857
1858     return 0;
1859 }
1860
1861 #endif