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     if (prf->filespec)
 607             free(prf->filespec);
 608     free(prf);
 609 }
 610
 611 /* Begin the profile parser */
 612
 613 profile_syntax_err_cb_t profile_set_syntax_err_cb(profile_syntax_err_cb_t hook)
 614 {
 615         profile_syntax_err_cb_t old;
 616
 617         old = syntax_err_cb;
 618         syntax_err_cb = hook;
 619         return(old);
 620 }
 621
 622 #define STATE_INIT_COMMENT      0
 623 #define STATE_STD_LINE          1
 624 #define STATE_GET_OBRACE        2
 625
 626 static char *skip_over_blanks(char *cp)
 627 {
 628         while (*cp && isspace((int) (*cp)))
 629                 cp++;
 630         return cp;
 631 }
 632
 633 static int end_or_comment(char ch)
 634 {
 635         return (ch == 0 || ch == '#' || ch == ';');
 636 }
 637
 638 static char *skip_over_nonblanks(char *cp)
 639 {
 640         while (!end_or_comment(*cp) && !isspace(*cp))
 641                 cp++;
 642         return cp;
 643 }
 644
 645 static void strip_line(char *line)
 646 {
 647         char *p = line + strlen(line);
 648         while (p > line && (p[-1] == '\n' || p[-1] == '\r'))
 649             *p-- = 0;
 650 }
 651
 652 static void parse_quoted_string(char *str)
 653 {
 654         char *to, *from;
 655
 656         to = from = str;
 657
 658         for (to = from = str; *from && *from != '"'; to++, from++) {
 659                 if (*from == '\\') {
 660                         from++;
 661                         switch (*from) {
 662                         case 'n':
 663                                 *to = '\n';
 664                                 break;
 665                         case 't':
 666                                 *to = '\t';
 667                                 break;
 668                         case 'b':
 669                                 *to = '\b';
 670                                 break;
 671                         default:
 672                                 *to = *from;
 673                         }
 674                         continue;
 675                 }
 676                 *to = *from;
 677         }
 678         *to = '\0';
 679 }
 680
 681 static errcode_t parse_line(char *line, struct parse_state *state)
 682 {
 683         char    *cp, ch, *tag, *value;
 684         char    *p;
 685         errcode_t retval;
 686         struct profile_node     *node;
 687         int do_subsection = 0;
 688         void *iter = 0;
 689
 690         state->line_num++;
 691         if (state->state == STATE_GET_OBRACE) {
 692                 cp = skip_over_blanks(line);
 693                 if (*cp != '{')
 694                         return PROF_MISSING_OBRACE;
 695                 state->state = STATE_STD_LINE;
 696                 return 0;
 697         }
 698         if (state->state == STATE_INIT_COMMENT) {
 699                 if (line[0] != '[')
 700                         return 0;
 701                 state->state = STATE_STD_LINE;
 702         }
 703
 704         if (*line == 0)
 705                 return 0;
 706         strip_line(line);
 707         cp = skip_over_blanks(line);
 708         ch = *cp;
 709         if (end_or_comment(ch))
 710                 return 0;
 711         if (ch == '[') {
 712                 if (state->group_level > 0)
 713                         return PROF_SECTION_NOTOP;
 714                 cp++;
 715                 cp = skip_over_blanks(cp);
 716                 p = strchr(cp, ']');
 717                 if (p == NULL)
 718                         return PROF_SECTION_SYNTAX;
 719                 if (*cp == '"') {
 720                         cp++;
 721                         parse_quoted_string(cp);
 722                 } else {
 723                         *p-- = '\0';
 724                         while (isspace(*p) && (p > cp))
 725                                 *p-- = '\0';
 726                         if (*cp == 0)
 727                                 return PROF_SECTION_SYNTAX;
 728                 }
 729                 retval = profile_find_node(state->root_section, cp, 0, 1,
 730                                            &iter, &state->current_section);
 731                 if (retval == PROF_NO_SECTION) {
 732                         retval = profile_add_node(state->root_section,
 733                                                   cp, 0,
 734                                                   &state->current_section);
 735                         if (retval)
 736                                 return retval;
 737                 } else if (retval)
 738                         return retval;
 739
 740                 /*
 741                  * Finish off the rest of the line.
 742                  */
 743                 cp = p+1;
 744                 if (*cp == '*') {
 745                         state->current_section->final = 1;
 746                         cp++;
 747                 }
 748                 /*
 749                  * Spaces or comments after ']' should not be fatal
 750                  */
 751                 cp = skip_over_blanks(cp);
 752                 if (!end_or_comment(*cp))
 753                         return PROF_SECTION_SYNTAX;
 754                 return 0;
 755         }
 756         if (ch == '}') {
 757                 if (state->group_level == 0)
 758                         return PROF_EXTRA_CBRACE;
 759                 if (*(cp+1) == '*')
 760                         state->current_section->final = 1;
 761                 state->current_section = state->current_section->parent;
 762                 state->group_level--;
 763                 return 0;
 764         }
 765         /*
 766          * Parse the relations
 767          */
 768         tag = cp;
 769         cp = strchr(cp, '=');
 770         if (!cp)
 771                 return PROF_RELATION_SYNTAX;
 772         if (cp == tag)
 773             return PROF_RELATION_SYNTAX;
 774         *cp = '\0';
 775         if (*tag == '"') {
 776                 tag++;
 777                 parse_quoted_string(tag);
 778         } else {
 779                 /* Look for whitespace on left-hand side.  */
 780                 p = skip_over_nonblanks(tag);
 781                 if (*p)
 782                         *p++ = 0;
 783                 p = skip_over_blanks(p);
 784                 /* If we have more non-whitespace, it's an error.  */
 785                 if (*p)
 786                         return PROF_RELATION_SYNTAX;
 787         }
 788
 789         cp = skip_over_blanks(cp+1);
 790         value = cp;
 791         ch = value[0];
 792         if (ch == '"') {
 793                 value++;
 794                 parse_quoted_string(value);
 795         } else if (end_or_comment(ch)) {
 796                 do_subsection++;
 797                 state->state = STATE_GET_OBRACE;
 798         } else if (value[0] == '{') {
 799                 cp = skip_over_blanks(value+1);
 800                 ch = *cp;
 801                 if (end_or_comment(ch))
 802                         do_subsection++;
 803                 else
 804                         return PROF_RELATION_SYNTAX;
 805         } else {
 806                 cp = skip_over_nonblanks(value);
 807                 p = skip_over_blanks(cp);
 808                 ch = *p;
 809                 *cp = 0;
 810                 if (!end_or_comment(ch))
 811                         return PROF_RELATION_SYNTAX;
 812         }
 813         if (do_subsection) {
 814                 p = strchr(tag, '*');
 815                 if (p)
 816                         *p = '\0';
 817                 retval = profile_add_node(state->current_section,
 818                                           tag, 0, &state->current_section);
 819                 if (retval)
 820                         return retval;
 821                 if (p)
 822                         state->current_section->final = 1;
 823                 state->group_level++;
 824                 return 0;
 825         }
 826         p = strchr(tag, '*');
 827         if (p)
 828                 *p = '\0';
 829         profile_add_node(state->current_section, tag, value, &node);
 830         if (p)
 831                 node->final = 1;
 832         return 0;
 833 }
 834
 835 #ifdef DEBUG_PROGRAM
 836 /*
 837  * Return TRUE if the string begins or ends with whitespace
 838  */
 839 static int need_double_quotes(char *str)
 840 {
 841         if (!str || !*str)
 842                 return 0;
 843         if (isspace((int) (*str)) ||isspace((int) (*(str + strlen(str) - 1))))
 844                 return 1;
 845         if (strchr(str, '\n') || strchr(str, '\t') || strchr(str, '\b') ||
 846             strchr(str, ' ') || strchr(str, '#') || strchr(str, ';'))
 847                 return 1;
 848         return 0;
 849 }
 850
 851 /*
 852  * Output a string with double quotes, doing appropriate backquoting
 853  * of characters as necessary.
 854  */
 855 static void output_quoted_string(char *str, void (*cb)(const char *,void *),
 856                                  void *data)
 857 {
 858         char    ch;
 859         char buf[2];
 860
 861         cb("\"", data);
 862         if (!str) {
 863                 cb("\"", data);
 864                 return;
 865         }
 866         buf[1] = 0;
 867         while ((ch = *str++)) {
 868                 switch (ch) {
 869                 case '\\':
 870                         cb("\\\\", data);
 871                         break;
 872                 case '\n':
 873                         cb("\\n", data);
 874                         break;
 875                 case '\t':
 876                         cb("\\t", data);
 877                         break;
 878                 case '\b':
 879                         cb("\\b", data);
 880                         break;
 881                 default:
 882                         /* This would be a lot faster if we scanned
 883                            forward for the next "interesting"
 884                            character.  */
 885                         buf[0] = ch;
 886                         cb(buf, data);
 887                         break;
 888                 }
 889         }
 890         cb("\"", data);
 891 }
 892
 893 #ifndef EOL
 894 #define EOL "\n"
 895 #endif
 896
 897 /* Errors should be returned, not ignored!  */
 898 static void dump_profile(struct profile_node *root, int level,
 899                          void (*cb)(const char *, void *), void *data)
 900 {
 901         int i;
 902         struct profile_node *p;
 903         void *iter;
 904         long retval;
 905
 906         iter = 0;
 907         do {
 908                 retval = profile_find_node(root, 0, 0, 0, &iter, &p);
 909                 if (retval)
 910                         break;
 911                 for (i=0; i < level; i++)
 912                         cb("\t", data);
 913                 if (need_double_quotes(p->name))
 914                         output_quoted_string(p->name, cb, data);
 915                 else
 916                         cb(p->name, data);
 917                 cb(" = ", data);
 918                 if (need_double_quotes(p->value))
 919                         output_quoted_string(p->value, cb, data);
 920                 else
 921                         cb(p->value, data);
 922                 cb(EOL, data);
 923         } while (iter != 0);
 924
 925         iter = 0;
 926         do {
 927                 retval = profile_find_node(root, 0, 0, 1, &iter, &p);
 928                 if (retval)
 929                         break;
 930                 if (level == 0) { /* [xxx] */
 931                         cb("[", data);
 932                         if (need_double_quotes(p->name))
 933                                 output_quoted_string(p->name, cb, data);
 934                         else
 935                                 cb(p->name, data);
 936                         cb("]", data);
 937                         cb(p->final ? "*" : "", data);
 938                         cb(EOL, data);
 939                         dump_profile(p, level+1, cb, data);
 940                         cb(EOL, data);
 941                 } else {        /* xxx = { ... } */
 942                         for (i=0; i < level; i++)
 943                                 cb("\t", data);
 944                         if (need_double_quotes(p->name))
 945                                 output_quoted_string(p->name, cb, data);
 946                         else
 947                                 cb(p->name, data);
 948                         cb(" = {", data);
 949                         cb(EOL, data);
 950                         dump_profile(p, level+1, cb, data);
 951                         for (i=0; i < level; i++)
 952                                 cb("\t", data);
 953                         cb("}", data);
 954                         cb(p->final ? "*" : "", data);
 955                         cb(EOL, data);
 956                 }
 957         } while (iter != 0);
 958 }
 959
 960 static void dump_profile_to_file_cb(const char *str, void *data)
 961 {
 962         fputs(str, data);
 963 }
 964
 965 errcode_t profile_write_tree_file(struct profile_node *root, FILE *dstfile)
 966 {
 967         dump_profile(root, 0, dump_profile_to_file_cb, dstfile);
 968         return 0;
 969 }
 970
 971 struct prof_buf {
 972         char *base;
 973         size_t cur, max;
 974         int err;
 975 };
 976
 977 static void add_data_to_buffer(struct prof_buf *b, const void *d, size_t len)
 978 {
 979         if (b->err)
 980                 return;
 981         if (b->max - b->cur < len) {
 982                 size_t newsize;
 983                 char *newptr;
 984
 985                 newsize = b->max + (b->max >> 1) + len + 1024;
 986                 newptr = realloc(b->base, newsize);
 987                 if (newptr == NULL) {
 988                         b->err = 1;
 989                         return;
 990                 }
 991                 b->base = newptr;
 992                 b->max = newsize;
 993         }
 994         memcpy(b->base + b->cur, d, len);
 995         b->cur += len;          /* ignore overflow */
 996 }
 997
 998 static void dump_profile_to_buffer_cb(const char *str, void *data)
 999 {
1000         add_data_to_buffer((struct prof_buf *)data, str, strlen(str));
1001 }
1002
1003 errcode_t profile_write_tree_to_buffer(struct profile_node *root,
1004                                        char **buf)
1005 {
1006         struct prof_buf prof_buf = { 0, 0, 0, 0 };
1007
1008         dump_profile(root, 0, dump_profile_to_buffer_cb, &prof_buf);
1009         if (prof_buf.err) {
1010                 *buf = NULL;
1011                 return ENOMEM;
1012         }
1013         add_data_to_buffer(&prof_buf, "", 1); /* append nul */
1014         if (prof_buf.max - prof_buf.cur > (prof_buf.max >> 3)) {
1015                 char *newptr = realloc(prof_buf.base, prof_buf.cur);
1016                 if (newptr)
1017                         prof_buf.base = newptr;
1018         }
1019         *buf = prof_buf.base;
1020         return 0;
1021 }
1022 #endif
1023
1024 /*
1025  * prof_tree.c --- these routines maintain the parse tree of the
1026  *      config file.
1027  *
1028  * All of the details of how the tree is stored is abstracted away in
1029  * this file; all of the other profile routines build, access, and
1030  * modify the tree via the accessor functions found in this file.
1031  *
1032  * Each node may represent either a relation or a section header.
1033  *
1034  * A section header must have its value field set to 0, and may a one
1035  * or more child nodes, pointed to by first_child.
1036  *
1037  * A relation has as its value a pointer to allocated memory
1038  * containing a string.  Its first_child pointer must be null.
1039  *
1040  */
1041
1042 /*
1043  * Free a node, and any children
1044  */
1045 void profile_free_node(struct profile_node *node)
1046 {
1047         struct profile_node *child, *next;
1048
1049         if (node->magic != PROF_MAGIC_NODE)
1050                 return;
1051
1052         if (node->name)
1053                 free(node->name);
1054         if (node->value)
1055                 free(node->value);
1056
1057         for (child=node->first_child; child; child = next) {
1058                 next = child->next;
1059                 profile_free_node(child);
1060         }
1061         node->magic = 0;
1062
1063         free(node);
1064 }
1065
1066 #ifndef HAVE_STRDUP
1067 #undef strdup
1068 #define strdup MYstrdup
1069 static char *MYstrdup (const char *s)
1070 {
1071     size_t sz = strlen(s) + 1;
1072     char *p = malloc(sz);
1073     if (p != 0)
1074         memcpy(p, s, sz);
1075     return p;
1076 }
1077 #endif
1078
1079 /*
1080  * Create a node
1081  */
1082 errcode_t profile_create_node(const char *name, const char *value,
1083                               struct profile_node **ret_node)
1084 {
1085         struct profile_node *new;
1086
1087         new = malloc(sizeof(struct profile_node));
1088         if (!new)
1089                 return ENOMEM;
1090         memset(new, 0, sizeof(struct profile_node));
1091         new->name = strdup(name);
1092         if (new->name == 0) {
1093             profile_free_node(new);
1094             return ENOMEM;
1095         }
1096         if (value) {
1097                 new->value = strdup(value);
1098                 if (new->value == 0) {
1099                     profile_free_node(new);
1100                     return ENOMEM;
1101                 }
1102         }
1103         new->magic = PROF_MAGIC_NODE;
1104
1105         *ret_node = new;
1106         return 0;
1107 }
1108
1109 /*
1110  * This function verifies that all of the representation invarients of
1111  * the profile are true.  If not, we have a programming bug somewhere,
1112  * probably in this file.
1113  */
1114 #ifdef DEBUG_PROGRAM
1115 errcode_t profile_verify_node(struct profile_node *node)
1116 {
1117         struct profile_node *p, *last;
1118         errcode_t       retval;
1119
1120         CHECK_MAGIC(node);
1121
1122         if (node->value && node->first_child)
1123                 return PROF_SECTION_WITH_VALUE;
1124
1125         last = 0;
1126         for (p = node->first_child; p; last = p, p = p->next) {
1127                 if (p->prev != last)
1128                         return PROF_BAD_LINK_LIST;
1129                 if (last && (last->next != p))
1130                         return PROF_BAD_LINK_LIST;
1131                 if (node->group_level+1 != p->group_level)
1132                         return PROF_BAD_GROUP_LVL;
1133                 if (p->parent != node)
1134                         return PROF_BAD_PARENT_PTR;
1135                 retval = profile_verify_node(p);
1136                 if (retval)
1137                         return retval;
1138         }
1139         return 0;
1140 }
1141 #endif
1142
1143 /*
1144  * Add a node to a particular section
1145  */
1146 errcode_t profile_add_node(struct profile_node *section, const char *name,
1147                            const char *value, struct profile_node **ret_node)
1148 {
1149         errcode_t retval;
1150         struct profile_node *p, *last, *new;
1151
1152         CHECK_MAGIC(section);
1153
1154         if (section->value)
1155                 return PROF_ADD_NOT_SECTION;
1156
1157         /*
1158          * Find the place to insert the new node.  We look for the
1159          * place *after* the last match of the node name, since
1160          * order matters.
1161          */
1162         for (p=section->first_child, last = 0; p; last = p, p = p->next) {
1163                 int cmp;
1164                 cmp = strcmp(p->name, name);
1165                 if (cmp > 0)
1166                         break;
1167         }
1168         retval = profile_create_node(name, value, &new);
1169         if (retval)
1170                 return retval;
1171         new->group_level = section->group_level+1;
1172         new->deleted = 0;
1173         new->parent = section;
1174         new->prev = last;
1175         new->next = p;
1176         if (p)
1177                 p->prev = new;
1178         if (last)
1179                 last->next = new;
1180         else
1181                 section->first_child = new;
1182         if (ret_node)
1183                 *ret_node = new;
1184         return 0;
1185 }
1186
1187 /*
1188  * Iterate through the section, returning the nodes which match
1189  * the given name.  If name is NULL, then interate through all the
1190  * nodes in the section.  If section_flag is non-zero, only return the
1191  * section which matches the name; don't return relations.  If value
1192  * is non-NULL, then only return relations which match the requested
1193  * value.  (The value argument is ignored if section_flag is non-zero.)
1194  *
1195  * The first time this routine is called, the state pointer must be
1196  * null.  When this profile_find_node_relation() returns, if the state
1197  * pointer is non-NULL, then this routine should be called again.
1198  * (This won't happen if section_flag is non-zero, obviously.)
1199  *
1200  */
1201 errcode_t profile_find_node(struct profile_node *section, const char *name,
1202                             const char *value, int section_flag, void **state,
1203                             struct profile_node **node)
1204 {
1205         struct profile_node *p;
1206
1207         CHECK_MAGIC(section);
1208         p = *state;
1209         if (p) {
1210                 CHECK_MAGIC(p);
1211         } else
1212                 p = section->first_child;
1213
1214         for (; p; p = p->next) {
1215                 if (name && (strcmp(p->name, name)))
1216                         continue;
1217                 if (section_flag) {
1218                         if (p->value)
1219                                 continue;
1220                 } else {
1221                         if (!p->value)
1222                                 continue;
1223                         if (value && (strcmp(p->value, value)))
1224                                 continue;
1225                 }
1226                 if (p->deleted)
1227                     continue;
1228                 /* A match! */
1229                 if (node)
1230                         *node = p;
1231                 break;
1232         }
1233         if (p == 0) {
1234                 *state = 0;
1235                 return section_flag ? PROF_NO_SECTION : PROF_NO_RELATION;
1236         }
1237         /*
1238          * OK, we've found one match; now let's try to find another
1239          * one.  This way, if we return a non-zero state pointer,
1240          * there's guaranteed to be another match that's returned.
1241          */
1242         for (p = p->next; p; p = p->next) {
1243                 if (name && (strcmp(p->name, name)))
1244                         continue;
1245                 if (section_flag) {
1246                         if (p->value)
1247                                 continue;
1248                 } else {
1249                         if (!p->value)
1250                                 continue;
1251                         if (value && (strcmp(p->value, value)))
1252                                 continue;
1253                 }
1254                 /* A match! */
1255                 break;
1256         }
1257         *state = p;
1258         return 0;
1259 }
1260
1261 /*
1262  * This is a general-purpose iterator for returning all nodes that
1263  * match the specified name array.
1264  */
1265 struct profile_iterator {
1266         prf_magic_t             magic;
1267         profile_t               profile;
1268         int                     flags;
1269         const char              *const *names;
1270         const char              *name;
1271         prf_file_t              file;
1272         int                     file_serial;
1273         int                     done_idx;
1274         struct profile_node     *node;
1275         int                     num;
1276 };
1277
1278 errcode_t
1279 profile_iterator_create(profile_t profile, const char *const *names, int flags,
1280                         void **ret_iter)
1281 {
1282         struct profile_iterator *iter;
1283         int     done_idx = 0;
1284
1285         if (profile == 0)
1286                 return PROF_NO_PROFILE;
1287         if (profile->magic != PROF_MAGIC_PROFILE)
1288                 return PROF_MAGIC_PROFILE;
1289         if (!names)
1290                 return PROF_BAD_NAMESET;
1291         if (!(flags & PROFILE_ITER_LIST_SECTION)) {
1292                 if (!names[0])
1293                         return PROF_BAD_NAMESET;
1294                 done_idx = 1;
1295         }
1296
1297         if ((iter = malloc(sizeof(struct profile_iterator))) == NULL)
1298                 return ENOMEM;
1299
1300         iter->magic = PROF_MAGIC_ITERATOR;
1301         iter->profile = profile;
1302         iter->names = names;
1303         iter->flags = flags;
1304         iter->file = profile->first_file;
1305         iter->done_idx = done_idx;
1306         iter->node = 0;
1307         iter->num = 0;
1308         *ret_iter = iter;
1309         return 0;
1310 }
1311
1312 void profile_iterator_free(void **iter_p)
1313 {
1314         struct profile_iterator *iter;
1315
1316         if (!iter_p)
1317                 return;
1318         iter = *iter_p;
1319         if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
1320                 return;
1321         free(iter);
1322         *iter_p = 0;
1323 }
1324
1325 /*
1326  * Note: the returned character strings in ret_name and ret_value
1327  * points to the stored character string in the parse string.  Before
1328  * this string value is returned to a calling application
1329  * (profile_node_iterator is not an exported interface), it should be
1330  * strdup()'ed.
1331  */
1332 errcode_t profile_node_iterator(void **iter_p, struct profile_node **ret_node,
1333                                 char **ret_name, char **ret_value)
1334 {
1335         struct profile_iterator         *iter = *iter_p;
1336         struct profile_node             *section, *p;
1337         const char                      *const *cpp;
1338         errcode_t                       retval;
1339         int                             skip_num = 0;
1340
1341         if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
1342                 return PROF_MAGIC_ITERATOR;
1343         if (iter->file && iter->file->magic != PROF_MAGIC_FILE)
1344             return PROF_MAGIC_FILE;
1345         /*
1346          * If the file has changed, then the node pointer is invalid,
1347          * so we'll have search the file again looking for it.
1348          */
1349         if (iter->node && (iter->file &&
1350                            iter->file->upd_serial != iter->file_serial)) {
1351                 iter->flags &= ~PROFILE_ITER_FINAL_SEEN;
1352                 skip_num = iter->num;
1353                 iter->node = 0;
1354         }
1355         if (iter->node && iter->node->magic != PROF_MAGIC_NODE) {
1356             return PROF_MAGIC_NODE;
1357         }
1358 get_new_file:
1359         if (iter->node == 0) {
1360                 if (iter->file == 0 ||
1361                     (iter->flags & PROFILE_ITER_FINAL_SEEN)) {
1362                         profile_iterator_free(iter_p);
1363                         if (ret_node)
1364                                 *ret_node = 0;
1365                         if (ret_name)
1366                                 *ret_name = 0;
1367                         if (ret_value)
1368                                 *ret_value =0;
1369                         return 0;
1370                 }
1371                 if ((retval = profile_update_file(iter->file))) {
1372                     if (retval == ENOENT || retval == EACCES) {
1373                         /* XXX memory leak? */
1374                         iter->file = iter->file->next;
1375                         skip_num = 0;
1376                         retval = 0;
1377                         goto get_new_file;
1378                     } else {
1379                         profile_iterator_free(iter_p);
1380                         return retval;
1381                     }
1382                 }
1383                 iter->file_serial = iter->file->upd_serial;
1384                 /*
1385                  * Find the section to list if we are a LIST_SECTION,
1386                  * or find the containing section if not.
1387                  */
1388                 section = iter->file->root;
1389                 for (cpp = iter->names; cpp[iter->done_idx]; cpp++) {
1390                         for (p=section->first_child; p; p = p->next) {
1391                                 if (!strcmp(p->name, *cpp) && !p->value)
1392                                         break;
1393                         }
1394                         if (!p) {
1395                                 section = 0;
1396                                 break;
1397                         }
1398                         section = p;
1399                         if (p->final)
1400                                 iter->flags |= PROFILE_ITER_FINAL_SEEN;
1401                 }
1402                 if (!section) {
1403                         iter->file = iter->file->next;
1404                         skip_num = 0;
1405                         goto get_new_file;
1406                 }
1407                 iter->name = *cpp;
1408                 iter->node = section->first_child;
1409         }
1410         /*
1411          * OK, now we know iter->node is set up correctly.  Let's do
1412          * the search.
1413          */
1414         for (p = iter->node; p; p = p->next) {
1415                 if (iter->name && strcmp(p->name, iter->name))
1416                         continue;
1417                 if ((iter->flags & PROFILE_ITER_SECTIONS_ONLY) &&
1418                     p->value)
1419                         continue;
1420                 if ((iter->flags & PROFILE_ITER_RELATIONS_ONLY) &&
1421                     !p->value)
1422                         continue;
1423                 if (skip_num > 0) {
1424                         skip_num--;
1425                         continue;
1426                 }
1427                 if (p->deleted)
1428                         continue;
1429                 break;
1430         }
1431         iter->num++;
1432         if (!p) {
1433                 iter->file = iter->file->next;
1434                 iter->node = 0;
1435                 skip_num = 0;
1436                 goto get_new_file;
1437         }
1438         if ((iter->node = p->next) == NULL)
1439                 iter->file = iter->file->next;
1440         if (ret_node)
1441                 *ret_node = p;
1442         if (ret_name)
1443                 *ret_name = p->name;
1444         if (ret_value)
1445                 *ret_value = p->value;
1446         return 0;
1447 }
1448
1449
1450 /*
1451  * prof_get.c --- routines that expose the public interfaces for
1452  *      querying items from the profile.
1453  *
1454  */
1455
1456 /*
1457  * This function only gets the first value from the file; it is a
1458  * helper function for profile_get_string, profile_get_integer, etc.
1459  */
1460 errcode_t profile_get_value(profile_t profile, const char *name,
1461                             const char *subname, const char *subsubname,
1462                             const char **ret_value)
1463 {
1464         errcode_t               retval;
1465         void                    *state;
1466         char                    *value;
1467         const char              *names[4];
1468
1469         names[0] = name;
1470         names[1] = subname;
1471         names[2] = subsubname;
1472         names[3] = 0;
1473
1474         if ((retval = profile_iterator_create(profile, names,
1475                                               PROFILE_ITER_RELATIONS_ONLY,
1476                                               &state)))
1477                 return retval;
1478
1479         if ((retval = profile_node_iterator(&state, 0, 0, &value)))
1480                 goto cleanup;
1481
1482         if (value)
1483                 *ret_value = value;
1484         else
1485                 retval = PROF_NO_RELATION;
1486
1487 cleanup:
1488         profile_iterator_free(&state);
1489         return retval;
1490 }
1491
1492 errcode_t
1493 profile_get_string(profile_t profile, const char *name, const char *subname,
1494                    const char *subsubname, const char *def_val,
1495                    char **ret_string)
1496 {
1497         const char      *value;
1498         errcode_t       retval;
1499
1500         if (profile) {
1501                 retval = profile_get_value(profile, name, subname,
1502                                            subsubname, &value);
1503                 if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION)
1504                         value = def_val;
1505                 else if (retval)
1506                         return retval;
1507         } else
1508                 value = def_val;
1509
1510         if (value) {
1511                 *ret_string = malloc(strlen(value)+1);
1512                 if (*ret_string == 0)
1513                         return ENOMEM;
1514                 strcpy(*ret_string, value);
1515         } else
1516                 *ret_string = 0;
1517         return 0;
1518 }
1519
1520 errcode_t
1521 profile_get_integer(profile_t profile, const char *name, const char *subname,
1522                     const char *subsubname, int def_val, int *ret_int)
1523 {
1524         const char      *value;
1525         errcode_t       retval;
1526         char            *end_value;
1527         long            ret_long;
1528
1529         *ret_int = def_val;
1530         if (profile == 0)
1531                 return 0;
1532
1533         retval = profile_get_value(profile, name, subname, subsubname, &value);
1534         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1535                 *ret_int = def_val;
1536                 return 0;
1537         } else if (retval)
1538                 return retval;
1539
1540         if (value[0] == 0)
1541             /* Empty string is no good.  */
1542             return PROF_BAD_INTEGER;
1543         errno = 0;
1544         ret_long = strtol (value, &end_value, 10);
1545
1546         /* Overflow or underflow.  */
1547         if ((ret_long == LONG_MIN || ret_long == LONG_MAX) && errno != 0)
1548             return PROF_BAD_INTEGER;
1549         /* Value outside "int" range.  */
1550         if ((long) (int) ret_long != ret_long)
1551             return PROF_BAD_INTEGER;
1552         /* Garbage in string.  */
1553         if (end_value != value + strlen (value))
1554             return PROF_BAD_INTEGER;
1555
1556
1557         *ret_int = ret_long;
1558         return 0;
1559 }
1560
1561 errcode_t
1562 profile_get_uint(profile_t profile, const char *name, const char *subname,
1563                  const char *subsubname, unsigned int def_val,
1564                  unsigned int *ret_int)
1565 {
1566         const char      *value;
1567         errcode_t       retval;
1568         char            *end_value;
1569         unsigned long   ret_long;
1570
1571         *ret_int = def_val;
1572         if (profile == 0)
1573                 return 0;
1574
1575         retval = profile_get_value(profile, name, subname, subsubname, &value);
1576         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1577                 *ret_int = def_val;
1578                 return 0;
1579         } else if (retval)
1580                 return retval;
1581
1582         if (value[0] == 0)
1583             /* Empty string is no good.  */
1584             return PROF_BAD_INTEGER;
1585         errno = 0;
1586         ret_long = strtoul (value, &end_value, 10);
1587
1588         /* Overflow or underflow.  */
1589         if ((ret_long == ULONG_MAX) && errno != 0)
1590             return PROF_BAD_INTEGER;
1591         /* Value outside "int" range.  */
1592         if ((unsigned long) (unsigned int) ret_long != ret_long)
1593             return PROF_BAD_INTEGER;
1594         /* Garbage in string.  */
1595         if (end_value != value + strlen (value))
1596             return PROF_BAD_INTEGER;
1597
1598         *ret_int = ret_long;
1599         return 0;
1600 }
1601
1602 static const char *const conf_yes[] = {
1603     "y", "yes", "true", "t", "1", "on",
1604     0,
1605 };
1606
1607 static const char *const conf_no[] = {
1608     "n", "no", "false", "nil", "0", "off",
1609     0,
1610 };
1611
1612 static errcode_t
1613 profile_parse_boolean(const char *s, int *ret_boolean)
1614 {
1615     const char *const *p;
1616
1617     if (ret_boolean == NULL)
1618         return PROF_EINVAL;
1619
1620     for(p=conf_yes; *p; p++) {
1621                 if (!strcasecmp(*p,s)) {
1622                         *ret_boolean = 1;
1623                 return 0;
1624                 }
1625     }
1626
1627     for(p=conf_no; *p; p++) {
1628                 if (!strcasecmp(*p,s)) {
1629                         *ret_boolean = 0;
1630                         return 0;
1631                 }
1632     }
1633
1634         return PROF_BAD_BOOLEAN;
1635 }
1636
1637 errcode_t
1638 profile_get_boolean(profile_t profile, const char *name, const char *subname,
1639                     const char *subsubname, int def_val, int *ret_boolean)
1640 {
1641         const char      *value;
1642         errcode_t       retval;
1643
1644         if (profile == 0) {
1645                 *ret_boolean = def_val;
1646                 return 0;
1647         }
1648
1649         retval = profile_get_value(profile, name, subname, subsubname, &value);
1650         if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
1651                 *ret_boolean = def_val;
1652                 return 0;
1653         } else if (retval)
1654                 return retval;
1655
1656         return profile_parse_boolean (value, ret_boolean);
1657 }
1658
1659 errcode_t
1660 profile_iterator(void **iter_p, char **ret_name, char **ret_value)
1661 {
1662         char *name, *value;
1663         errcode_t       retval;
1664
1665         retval = profile_node_iterator(iter_p, 0, &name, &value);
1666         if (retval)
1667                 return retval;
1668
1669         if (ret_name) {
1670                 if (name) {
1671                         *ret_name = malloc(strlen(name)+1);
1672                         if (!*ret_name)
1673                                 return ENOMEM;
1674                         strcpy(*ret_name, name);
1675                 } else
1676                         *ret_name = 0;
1677         }
1678         if (ret_value) {
1679                 if (value) {
1680                         *ret_value = malloc(strlen(value)+1);
1681                         if (!*ret_value) {
1682                                 if (ret_name) {
1683                                         free(*ret_name);
1684                                         *ret_name = 0;
1685                                 }
1686                                 return ENOMEM;
1687                         }
1688                         strcpy(*ret_value, value);
1689                 } else
1690                         *ret_value = 0;
1691         }
1692         return 0;
1693 }
1694
1695 #ifdef DEBUG_PROGRAM
1696
1697 /*
1698  * test_profile.c --- testing program for the profile routine
1699  */
1700
1701 #include "argv_parse.h"
1702 #include "profile_helpers.h"
1703
1704 const char *program_name = "test_profile";
1705
1706 #define PRINT_VALUE     1
1707 #define PRINT_VALUES    2
1708
1709 static void do_cmd(profile_t profile, char **argv)
1710 {
1711         errcode_t       retval;
1712         const char      **names, *value;
1713         char            **values, **cpp;
1714         char    *cmd;
1715         int             print_status;
1716
1717         cmd = *(argv);
1718         names = (const char **) argv + 1;
1719         print_status = 0;
1720         retval = 0;
1721         if (cmd == 0)
1722                 return;
1723         if (!strcmp(cmd, "query")) {
1724                 retval = profile_get_values(profile, names, &values);
1725                 print_status = PRINT_VALUES;
1726         } else if (!strcmp(cmd, "query1")) {
1727                 const char *name = 0;
1728                 const char *subname = 0;
1729                 const char *subsubname = 0;
1730
1731                 name = names[0];
1732                 if (name)
1733                         subname = names[1];
1734                 if (subname)
1735                         subsubname = names[2];
1736                 if (subsubname && names[3]) {
1737                         fprintf(stderr,
1738                                 "Only 3 levels are allowed with query1\n");
1739                         retval = EINVAL;
1740                 } else
1741                         retval = profile_get_value(profile, name, subname,
1742                                                    subsubname, &value);
1743                 print_status = PRINT_VALUE;
1744         } else if (!strcmp(cmd, "list_sections")) {
1745                 retval = profile_get_subsection_names(profile, names,
1746                                                       &values);
1747                 print_status = PRINT_VALUES;
1748         } else if (!strcmp(cmd, "list_relations")) {
1749                 retval = profile_get_relation_names(profile, names,
1750                                                     &values);
1751                 print_status = PRINT_VALUES;
1752         } else if (!strcmp(cmd, "dump")) {
1753                 retval = profile_write_tree_file
1754                         (profile->first_file->root, stdout);
1755 #if 0
1756         } else if (!strcmp(cmd, "clear")) {
1757                 retval = profile_clear_relation(profile, names);
1758         } else if (!strcmp(cmd, "update")) {
1759                 retval = profile_update_relation(profile, names+2,
1760                                                  *names, *(names+1));
1761 #endif
1762         } else if (!strcmp(cmd, "verify")) {
1763                 retval = profile_verify_node
1764                         (profile->first_file->root);
1765 #if 0
1766         } else if (!strcmp(cmd, "rename_section")) {
1767                 retval = profile_rename_section(profile, names+1, *names);
1768         } else if (!strcmp(cmd, "add")) {
1769                 value = *names;
1770                 if (strcmp(value, "NULL") == 0)
1771                         value = NULL;
1772                 retval = profile_add_relation(profile, names+1, value);
1773         } else if (!strcmp(cmd, "flush")) {
1774                 retval = profile_flush(profile);
1775 #endif
1776         } else {
1777                 printf("Invalid command.\n");
1778         }
1779         if (retval) {
1780                 com_err(cmd, retval, "");
1781                 print_status = 0;
1782         }
1783         switch (print_status) {
1784         case PRINT_VALUE:
1785                 printf("%s\n", value);
1786                 break;
1787         case PRINT_VALUES:
1788                 for (cpp = values; *cpp; cpp++)
1789                         printf("%s\n", *cpp);
1790                 profile_free_list(values);
1791                 break;
1792         }
1793 }
1794
1795 static void do_batchmode(profile_t profile)
1796 {
1797         int             argc, ret;
1798         char            **argv;
1799         char            buf[256];
1800
1801         while (!feof(stdin)) {
1802                 if (fgets(buf, sizeof(buf), stdin) == NULL)
1803                         break;
1804                 printf(">%s", buf);
1805                 ret = argv_parse(buf, &argc, &argv);
1806                 if (ret != 0) {
1807                         printf("Argv_parse returned %d!\n", ret);
1808                         continue;
1809                 }
1810                 do_cmd(profile, argv);
1811                 printf("\n");
1812                 argv_free(argv);
1813         }
1814         profile_release(profile);
1815         exit(0);
1816
1817 }
1818
1819 void syntax_err_report(const char *filename, long err, int line_num)
1820 {
1821         fprintf(stderr, "Syntax error in %s, line number %d: %s\n",
1822                 filename, line_num, error_message(err));
1823         exit(1);
1824 }
1825
1826 const char *default_str = "[foo]\n\tbar=quux\n\tsub = {\n\t\twin = true\n}\n";
1827
1828 int main(int argc, char **argv)
1829 {
1830     profile_t   profile;
1831     long        retval;
1832     char        *cmd;
1833
1834     if (argc < 2) {
1835             fprintf(stderr, "Usage: %s filename [cmd argset]\n", program_name);
1836             exit(1);
1837     }
1838
1839     initialize_prof_error_table();
1840
1841     profile_set_syntax_err_cb(syntax_err_report);
1842
1843     retval = profile_init_path(argv[1], &profile);
1844     if (retval) {
1845         com_err(program_name, retval, "while initializing profile");
1846         exit(1);
1847     }
1848     retval = profile_set_default(profile, default_str);
1849     if (retval) {
1850         com_err(program_name, retval, "while setting default");
1851         exit(1);
1852     }
1853
1854     cmd = *(argv+2);
1855     if (!cmd || !strcmp(cmd, "batch"))
1856             do_batchmode(profile);
1857     else
1858             do_cmd(profile, argv+2);
1859     profile_release(profile);
1860
1861     return 0;
1862 }
1863
1864 #endif