Logo Search packages:      
Sourcecode: ldiskfsprogs version File versions  Download package

profile.c

/*
 * profile.c -- A simple configuration file parsing "library in a file"
 * 
 * The profile library was originally written by Theodore Ts'o in 1995
 * for use in the MIT Kerberos v5 library.  It has been
 * modified/enhanced/bug-fixed over time by other members of the MIT
 * Kerberos team.  This version was originally taken from the Kerberos
 * v5 distribution, version 1.4.2, and radically simplified for use in
 * e2fsprogs.  (Support for locking for multi-threaded operations,
 * being able to modify and update the configuration file
 * programmatically, and Mac/Windows portability have been removed.
 * It has been folded into a single C source file to make it easier to
 * fold into an application program.)
 *
 * Copyright (C) 2005, 2006 by Theodore Ts'o.
 *
 * %Begin-Header%
 * This file may be redistributed under the terms of the GNU Public
 * License.
 * %End-Header%
 * 
 * Copyright (C) 1985-2005 by the Massachusetts Institute of Technology.
 * 
 * All rights reserved.
 * 
 * Export of this software from the United States of America may require
 * a specific license from the United States Government.  It is the
 * responsibility of any person or organization contemplating export to
 * obtain such a license before exporting.
 * 
 * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
 * distribute this software and its documentation for any purpose and
 * without fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation, and that
 * the name of M.I.T. not be used in advertising or publicity pertaining
 * to distribution of the software without specific, written prior
 * permission.  Furthermore if you modify this software you must label
 * your software as modified software and not distribute it in such a
 * fashion that it might be confused with the original MIT software.
 * M.I.T. makes no representations about the suitability of this software
 * for any purpose.  It is provided "as is" without express or implied
 * warranty.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <time.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <limits.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif

#include <et/com_err.h>
#include "profile.h"
#include "prof_err.h"

#undef STAT_ONCE_PER_SECOND
#undef HAVE_STAT

/*
 * prof_int.h
 */

typedef long prf_magic_t;

/*
 * This is the structure which stores the profile information for a
 * particular configuration file.
 */
struct _prf_file_t {
      prf_magic_t magic;
      char        *filespec;
#ifdef STAT_ONCE_PER_SECOND
      time_t            last_stat;
#endif
      time_t            timestamp; /* time tree was last updated from file */
      int         flags;      /* r/w, dirty */
      int         upd_serial; /* incremented when data changes */
      struct profile_node *root;
      struct _prf_file_t *next;
};

typedef struct _prf_file_t *prf_file_t;

/*
 * The profile flags
 */
#define PROFILE_FILE_RW       0x0001
#define PROFILE_FILE_DIRTY    0x0002
#define PROFILE_FILE_NO_RELOAD      0x0004

/*
 * This structure defines the high-level, user visible profile_t
 * object, which is used as a handle by users who need to query some
 * configuration file(s)
 */
struct _profile_t {
      prf_magic_t magic;
      prf_file_t  first_file;
};

/*
 * Used by the profile iterator in prof_get.c
 */
#define PROFILE_ITER_LIST_SECTION   0x0001
#define PROFILE_ITER_SECTIONS_ONLY  0x0002
#define PROFILE_ITER_RELATIONS_ONLY 0x0004

#define PROFILE_ITER_FINAL_SEEN           0x0100

/*
 * Check if a filespec is last in a list (NULL on UNIX, invalid FSSpec on MacOS
 */

#define     PROFILE_LAST_FILESPEC(x) (((x) == NULL) || ((x)[0] == '\0'))

struct profile_node {
      errcode_t   magic;
      char *name;
      char *value;
      int group_level;
      unsigned int final:1;         /* Indicate don't search next file */
      unsigned int deleted:1;
      struct profile_node *first_child;
      struct profile_node *parent;
      struct profile_node *next, *prev;
};

#define CHECK_MAGIC(node) \
        if ((node)->magic != PROF_MAGIC_NODE) \
              return PROF_MAGIC_NODE;

/* profile parser declarations */
struct parse_state {
      int   state;
      int   group_level;
      int   line_num;
      struct profile_node *root_section;
      struct profile_node *current_section;
};

static const char *default_filename = "<default>";

static profile_syntax_err_cb_t      syntax_err_cb;

static errcode_t parse_line(char *line, struct parse_state *state);

#ifdef DEBUG_PROGRAM
static errcode_t profile_write_tree_file
      (struct profile_node *root, FILE *dstfile);

static errcode_t profile_write_tree_to_buffer
      (struct profile_node *root, char **buf);
#endif


static void profile_free_node
      (struct profile_node *relation);

static errcode_t profile_create_node
      (const char *name, const char *value,
               struct profile_node **ret_node);

#ifdef DEBUG_PROGRAM
static errcode_t profile_verify_node
      (struct profile_node *node);
#endif

static errcode_t profile_add_node
      (struct profile_node *section,
                const char *name, const char *value,
                struct profile_node **ret_node);

static errcode_t profile_find_node
      (struct profile_node *section,
                const char *name, const char *value,
                int section_flag, void **state,
                struct profile_node **node);

static errcode_t profile_node_iterator
      (void **iter_p, struct profile_node **ret_node,
               char **ret_name, char **ret_value);

static errcode_t profile_open_file
      (const char * file, prf_file_t *ret_prof);

static errcode_t profile_update_file
      (prf_file_t prf);

static void profile_free_file
      (prf_file_t profile);

static errcode_t profile_get_value(profile_t profile, const char *name,
                           const char *subname, const char *subsubname,
                           const char **ret_value);


/*
 * prof_init.c --- routines that manipulate the user-visible profile_t
 *    object.
 */

static int compstr(const void *m1, const void *m2) 
{
      const char *s1 = *((const char * const *) m1);
      const char *s2 = *((const char * const *) m2);

      return strcmp(s1, s2); 
}

static void free_list(char **list)
{
    char    **cp;

    if (list == 0)
          return;
    
    for (cp = list; *cp; cp++)
      free(*cp);
    free(list);
}

static errcode_t get_dirlist(const char *dirname, char***ret_array)
{
      DIR *dir;
      struct dirent *de;
      struct stat st;
      errcode_t retval;
      char *fn, *cp;
      char **array = 0, **new_array;
      int max = 0, num = 0;

      dir = opendir(dirname);
      if (!dir)
            return errno;

      while ((de = readdir(dir)) != NULL) {
            for (cp = de->d_name; *cp; cp++) {
                  if (!isalnum(*cp) &&
                      (*cp != '-') &&
                      (*cp != '_'))
                        break;
            }
            if (*cp)
                  continue;
            fn = malloc(strlen(dirname) + strlen(de->d_name) + 2);
            if (!fn) {
                  retval = ENOMEM;
                  goto errout;
            }
            sprintf(fn, "%s/%s", dirname, de->d_name);
            if ((stat(fn, &st) < 0) || !S_ISREG(st.st_mode)) {
                  free(fn);
                  continue;
            }
            if (num >= max) {
                  max += 10;
                  new_array = realloc(array, sizeof(char *) * (max+1));
                  if (!new_array) {
                        retval = ENOMEM;
                        goto errout;
                  }
                  array = new_array;
            }
            array[num++] = fn;
      }
      if (array) {
            qsort(array, num, sizeof(char *), compstr);
            array[num++] = 0;
      }
      *ret_array = array;
      closedir(dir);
      return 0;
errout:
      closedir(dir);
      free_list(array);
      return retval;
}

errcode_t 
profile_init(const char **files, profile_t *ret_profile)
{
      const char **fs;
      profile_t profile;
      prf_file_t  new_file, *last;
      errcode_t retval = 0;
      char **cpp, *cp, **array = 0;

      profile = malloc(sizeof(struct _profile_t));
      if (!profile)
            return ENOMEM;
      memset(profile, 0, sizeof(struct _profile_t));
      profile->magic = PROF_MAGIC_PROFILE;
      last = &profile->first_file;

        /* if the filenames list is not specified return an empty profile */
        if ( files ) {
          for (fs = files; !PROFILE_LAST_FILESPEC(*fs); fs++) {
            retval = get_dirlist(*fs, &array);
            if (retval == 0) {
                  if (!array)
                        continue;
                  for (cpp = array; (cp = *cpp); cpp++) {
                        retval = profile_open_file(cp, &new_file);
                        if (retval == EACCES)
                              continue;
                        if (retval)
                              goto errout;
                        *last = new_file;
                        last = &new_file->next;
                  }
            } else if ((retval != ENOTDIR) && 
                     strcmp(*fs, default_filename))
                  goto errout;

            retval = profile_open_file(*fs, &new_file);
            /* if this file is missing, skip to the next */
            if (retval == ENOENT || retval == EACCES) {
                  continue;
            }
            if (retval)
                  goto errout;
            *last = new_file;
            last = &new_file->next;
          }
          /*
           * If all the files were not found, return the appropriate error.
           */
          if (!profile->first_file) {
            profile_release(profile);
            return ENOENT;
          }
      }

      free_list(array);
        *ret_profile = profile;
        return 0;
errout:
      free_list(array);
      profile_release(profile);
      return retval;
}

void 
profile_release(profile_t profile)
{
      prf_file_t  p, next;

      if (!profile || profile->magic != PROF_MAGIC_PROFILE)
            return;

      for (p = profile->first_file; p; p = next) {
            next = p->next;
            profile_free_file(p);
      }
      profile->magic = 0;
      free(profile);
}

/*
 * This function sets the value of the pseudo file "<default>".  If
 * the file "<default>" had previously been passed to profile_init(),
 * then def_string parameter will be parsed and used as the profile
 * information for the "<default>" file.
 */
errcode_t profile_set_default(profile_t profile, const char *def_string)
{
      struct parse_state      state;
      prf_file_t        prf;
      errcode_t         retval;
      const char        *in;
      char              *line, *p, *end;
      int               line_size, len;

      if (!def_string || !profile || profile->magic != PROF_MAGIC_PROFILE)
            return PROF_MAGIC_PROFILE;

      for (prf = profile->first_file; prf; prf = prf->next) {
            if (strcmp(prf->filespec, default_filename) == 0)
                  break;
      }
      if (!prf)
            return 0;

      if (prf->root) {
            profile_free_node(prf->root);
            prf->root = 0;
      }

      memset(&state, 0, sizeof(struct parse_state));
      retval = profile_create_node("(root)", 0, &state.root_section);
      if (retval)
            return retval;

      line = 0;
      line_size = 0;
      in = def_string;
      while (*in) {
            end = strchr(in, '\n');
            len = end ? (end - in) : (int) strlen(in);
            if (len >= line_size) {
                  line_size = len+1;
                  p = realloc(line, line_size);
                  if (!p) {
                        retval = ENOMEM;
                        goto errout;
                  }
                  line = p;
            }
            memcpy(line, in, len);
            line[len] = 0;
            retval = parse_line(line, &state);
            if (retval) {
            errout:
                  if (syntax_err_cb)
                        (syntax_err_cb)(prf->filespec, retval, 
                                    state.line_num);
                  free(line);
                  if (prf->root)
                        profile_free_node(prf->root);
                  return retval;
            }
            if (!end)
                  break;
            in = end+1;
      }
      prf->root = state.root_section;
      free(line);

      return 0;
}

/*
 * prof_file.c ---- routines that manipulate an individual profile file.
 */

errcode_t profile_open_file(const char * filespec,
                      prf_file_t *ret_prof)
{
      prf_file_t  prf;
      errcode_t   retval;
      char        *home_env = 0;
      unsigned int      len;
      char        *expanded_filename;

      prf = malloc(sizeof(struct _prf_file_t));
      if (!prf)
            return ENOMEM;
      memset(prf, 0, sizeof(struct _prf_file_t));
      prf->magic = PROF_MAGIC_FILE;

      len = strlen(filespec)+1;
      if (filespec[0] == '~' && filespec[1] == '/') {
            home_env = getenv("HOME");
#ifdef HAVE_PWD_H
            if (home_env == NULL) {
#ifdef HAVE_GETWUID_R
                struct passwd *pw, pwx;
                uid_t uid;
                char pwbuf[BUFSIZ];

                uid = getuid();
                if (!getpwuid_r(uid, &pwx, pwbuf, sizeof(pwbuf), &pw)
                  && pw != NULL && pw->pw_dir[0] != 0)
                  home_env = pw->pw_dir;
#else
                struct passwd *pw;

                pw = getpwuid(getuid());
                home_env = pw->pw_dir;
#endif
            }
#endif
            if (home_env)
                  len += strlen(home_env);
      }
      expanded_filename = malloc(len);
      if (expanded_filename == 0) {
          profile_free_file(prf);   
          return errno;
      }
      if (home_env) {
          strcpy(expanded_filename, home_env);
          strcat(expanded_filename, filespec+1);
      } else
          memcpy(expanded_filename, filespec, len);

      prf->filespec = expanded_filename;

      if (strcmp(prf->filespec, default_filename) != 0) {
            retval = profile_update_file(prf);
            if (retval) {
                  profile_free_file(prf);
                  return retval;
            }
      }

      *ret_prof = prf;
      return 0;
}

errcode_t profile_update_file(prf_file_t prf)
{
      errcode_t retval;
#ifdef HAVE_STAT
      struct stat st;
#ifdef STAT_ONCE_PER_SECOND
      time_t now;
#endif
#endif
      FILE *f;
      char buf[2048];
      struct parse_state state;

      if (prf->flags & PROFILE_FILE_NO_RELOAD)
            return 0;

#ifdef HAVE_STAT
#ifdef STAT_ONCE_PER_SECOND
      now = time(0);
      if (now == prf->last_stat && prf->root != NULL) {
          return 0;
      }
#endif
      if (stat(prf->filespec, &st)) {
          retval = errno;
          return retval;
      }
#ifdef STAT_ONCE_PER_SECOND
      prf->last_stat = now;
#endif
      if (st.st_mtime == prf->timestamp && prf->root != NULL) {
          return 0;
      }
      if (prf->root) {
            profile_free_node(prf->root);
            prf->root = 0;
      }
#else
      /*
       * If we don't have the stat() call, assume that our in-core
       * memory image is correct.  That is, we won't reread the
       * profile file if it changes.
       */
      if (prf->root) {
          return 0;
      }
#endif
      memset(&state, 0, sizeof(struct parse_state));
      retval = profile_create_node("(root)", 0, &state.root_section);
      if (retval)
            return retval;
      errno = 0;
      f = fopen(prf->filespec, "r");
      if (f == NULL) {
            retval = errno;
            if (retval == 0)
                  retval = ENOENT;
            return retval;
      }
      prf->upd_serial++;
      while (!feof(f)) {
            if (fgets(buf, sizeof(buf), f) == NULL)
                  break;
            retval = parse_line(buf, &state);
            if (retval) {
                  if (syntax_err_cb)
                        (syntax_err_cb)(prf->filespec, retval, 
                                    state.line_num);
                  fclose(f);
                  return retval;
            }
      }
      prf->root = state.root_section;

      fclose(f);

#ifdef HAVE_STAT
      prf->timestamp = st.st_mtime;
#endif
      return 0;
}

void profile_free_file(prf_file_t prf)
{
    if (prf->root)
      profile_free_node(prf->root);
    if (prf->filespec)
          free(prf->filespec);
    free(prf);
}

/* Begin the profile parser */

profile_syntax_err_cb_t profile_set_syntax_err_cb(profile_syntax_err_cb_t hook)
{
      profile_syntax_err_cb_t old;

      old = syntax_err_cb;
      syntax_err_cb = hook;
      return(old);
}

#define STATE_INIT_COMMENT    0
#define STATE_STD_LINE        1
#define STATE_GET_OBRACE      2

static char *skip_over_blanks(char *cp)
{
      while (*cp && isspace((int) (*cp)))
            cp++;
      return cp;
}

static int end_or_comment(char ch)
{
      return (ch == 0 || ch == '#' || ch == ';');
}

static char *skip_over_nonblanks(char *cp)
{
      while (!end_or_comment(*cp) && !isspace(*cp))
            cp++;
      return cp;
}

static void strip_line(char *line)
{
      char *p = line + strlen(line);
      while (p > line && (p[-1] == '\n' || p[-1] == '\r'))
          *p-- = 0;
}

static void parse_quoted_string(char *str)
{
      char *to, *from;

      to = from = str;

      for (to = from = str; *from && *from != '"'; to++, from++) {
            if (*from == '\\') {
                  from++;
                  switch (*from) {
                  case 'n':
                        *to = '\n';
                        break;
                  case 't':
                        *to = '\t';
                        break;
                  case 'b':
                        *to = '\b';
                        break;
                  default:
                        *to = *from;
                  }
                  continue;
            }
            *to = *from;
      }
      *to = '\0';
}

static errcode_t parse_line(char *line, struct parse_state *state)
{
      char  *cp, ch, *tag, *value;
      char  *p;
      errcode_t retval;
      struct profile_node     *node;
      int do_subsection = 0;
      void *iter = 0;
      
      state->line_num++;
      if (state->state == STATE_GET_OBRACE) {
            cp = skip_over_blanks(line);
            if (*cp != '{')
                  return PROF_MISSING_OBRACE;
            state->state = STATE_STD_LINE;
            return 0;
      }
      if (state->state == STATE_INIT_COMMENT) {
            if (line[0] != '[')
                  return 0;
            state->state = STATE_STD_LINE;
      }

      if (*line == 0)
            return 0;
      strip_line(line);
      cp = skip_over_blanks(line);
      ch = *cp;
      if (end_or_comment(ch))
            return 0;
      if (ch == '[') {
            if (state->group_level > 0)
                  return PROF_SECTION_NOTOP;
            cp++;
            cp = skip_over_blanks(cp);
            p = strchr(cp, ']');
            if (p == NULL)
                  return PROF_SECTION_SYNTAX;
            if (*cp == '"') {
                  cp++;
                  parse_quoted_string(cp);
            } else {
                  *p-- = '\0';
                  while (isspace(*p) && (p > cp))
                        *p-- = '\0';
                  if (*cp == 0)
                        return PROF_SECTION_SYNTAX;
            }
            retval = profile_find_node(state->root_section, cp, 0, 1, 
                                 &iter, &state->current_section);
            if (retval == PROF_NO_SECTION) {
                  retval = profile_add_node(state->root_section,
                                      cp, 0,
                                      &state->current_section);
                  if (retval)
                        return retval;
            } else if (retval)
                  return retval;

            /*
             * Finish off the rest of the line.
             */
            cp = p+1;
            if (*cp == '*') {
                  state->current_section->final = 1;
                  cp++;
            }
            /*
             * Spaces or comments after ']' should not be fatal 
             */
            cp = skip_over_blanks(cp);
            if (!end_or_comment(*cp))
                  return PROF_SECTION_SYNTAX;
            return 0;
      }
      if (ch == '}') {
            if (state->group_level == 0)
                  return PROF_EXTRA_CBRACE;
            if (*(cp+1) == '*')
                  state->current_section->final = 1;
            state->current_section = state->current_section->parent;
            state->group_level--;
            return 0;
      }
      /*
       * Parse the relations
       */
      tag = cp;
      cp = strchr(cp, '=');
      if (!cp)
            return PROF_RELATION_SYNTAX;
      if (cp == tag)
          return PROF_RELATION_SYNTAX;
      *cp = '\0';
      if (*tag == '"') {
            tag++;
            parse_quoted_string(tag);
      } else {
            /* Look for whitespace on left-hand side.  */
            p = skip_over_nonblanks(tag);
            if (*p)
                  *p++ = 0;
            p = skip_over_blanks(p);
            /* If we have more non-whitespace, it's an error.  */
            if (*p)
                  return PROF_RELATION_SYNTAX;
      }

      cp = skip_over_blanks(cp+1);
      value = cp;
      ch = value[0];
      if (ch == '"') {
            value++;
            parse_quoted_string(value);
      } else if (end_or_comment(ch)) {
            do_subsection++;
            state->state = STATE_GET_OBRACE;
      } else if (value[0] == '{') {
            cp = skip_over_blanks(value+1);
            ch = *cp;
            if (end_or_comment(ch))
                  do_subsection++;
            else
                  return PROF_RELATION_SYNTAX;
      } else {
            cp = skip_over_nonblanks(value);
            p = skip_over_blanks(cp);
            ch = *p;
            *cp = 0;
            if (!end_or_comment(ch))
                  return PROF_RELATION_SYNTAX;
      }
      if (do_subsection) {
            p = strchr(tag, '*');
            if (p)
                  *p = '\0';
            retval = profile_add_node(state->current_section,
                                tag, 0, &state->current_section);
            if (retval)
                  return retval;
            if (p)
                  state->current_section->final = 1;
            state->group_level++;
            return 0;
      }
      p = strchr(tag, '*');
      if (p)
            *p = '\0';
      profile_add_node(state->current_section, tag, value, &node);
      if (p)
            node->final = 1;
      return 0;
}

#ifdef DEBUG_PROGRAM
/*
 * Return TRUE if the string begins or ends with whitespace
 */
static int need_double_quotes(char *str)
{
      if (!str || !*str)
            return 0;
      if (isspace((int) (*str)) ||isspace((int) (*(str + strlen(str) - 1))))
            return 1;
      if (strchr(str, '\n') || strchr(str, '\t') || strchr(str, '\b') ||
          strchr(str, ' ') || strchr(str, '#') || strchr(str, ';'))
            return 1;
      return 0;
}

/*
 * Output a string with double quotes, doing appropriate backquoting
 * of characters as necessary.
 */
static void output_quoted_string(char *str, void (*cb)(const char *,void *),
                         void *data)
{
      char  ch;
      char buf[2];

      cb("\"", data);
      if (!str) {
            cb("\"", data);
            return;
      }
      buf[1] = 0;
      while ((ch = *str++)) {
            switch (ch) {
            case '\\':
                  cb("\\\\", data);
                  break;
            case '\n':
                  cb("\\n", data);
                  break;
            case '\t':
                  cb("\\t", data);
                  break;
            case '\b':
                  cb("\\b", data);
                  break;
            default:
                  /* This would be a lot faster if we scanned
                     forward for the next "interesting"
                     character.  */
                  buf[0] = ch;
                  cb(buf, data);
                  break;
            }
      }
      cb("\"", data);
}

#ifndef EOL
#define EOL "\n"
#endif

/* Errors should be returned, not ignored!  */
static void dump_profile(struct profile_node *root, int level,
                   void (*cb)(const char *, void *), void *data)
{
      int i;
      struct profile_node *p;
      void *iter;
      long retval;
      
      iter = 0;
      do {
            retval = profile_find_node(root, 0, 0, 0, &iter, &p);
            if (retval)
                  break;
            for (i=0; i < level; i++)
                  cb("\t", data);
            if (need_double_quotes(p->name))
                  output_quoted_string(p->name, cb, data);
            else
                  cb(p->name, data);
            cb(" = ", data);
            if (need_double_quotes(p->value))
                  output_quoted_string(p->value, cb, data);
            else
                  cb(p->value, data);
            cb(EOL, data);
      } while (iter != 0);

      iter = 0;
      do {
            retval = profile_find_node(root, 0, 0, 1, &iter, &p);
            if (retval)
                  break;
            if (level == 0)   { /* [xxx] */
                  cb("[", data);
                  if (need_double_quotes(p->name))
                        output_quoted_string(p->name, cb, data);
                  else
                        cb(p->name, data);
                  cb("]", data);
                  cb(p->final ? "*" : "", data);
                  cb(EOL, data);
                  dump_profile(p, level+1, cb, data);
                  cb(EOL, data);
            } else {    /* xxx = { ... } */
                  for (i=0; i < level; i++)
                        cb("\t", data);
                  if (need_double_quotes(p->name))
                        output_quoted_string(p->name, cb, data);
                  else
                        cb(p->name, data);
                  cb(" = {", data);
                  cb(EOL, data);
                  dump_profile(p, level+1, cb, data);
                  for (i=0; i < level; i++)
                        cb("\t", data);
                  cb("}", data);
                  cb(p->final ? "*" : "", data);
                  cb(EOL, data);
            }
      } while (iter != 0);
}

static void dump_profile_to_file_cb(const char *str, void *data)
{
      fputs(str, data);
}

errcode_t profile_write_tree_file(struct profile_node *root, FILE *dstfile)
{
      dump_profile(root, 0, dump_profile_to_file_cb, dstfile);
      return 0;
}

struct prof_buf {
      char *base;
      size_t cur, max;
      int err;
};

static void add_data_to_buffer(struct prof_buf *b, const void *d, size_t len)
{
      if (b->err)
            return;
      if (b->max - b->cur < len) {
            size_t newsize;
            char *newptr;

            newsize = b->max + (b->max >> 1) + len + 1024;
            newptr = realloc(b->base, newsize);
            if (newptr == NULL) {
                  b->err = 1;
                  return;
            }
            b->base = newptr;
            b->max = newsize;
      }
      memcpy(b->base + b->cur, d, len);
      b->cur += len;          /* ignore overflow */
}

static void dump_profile_to_buffer_cb(const char *str, void *data)
{
      add_data_to_buffer((struct prof_buf *)data, str, strlen(str));
}

errcode_t profile_write_tree_to_buffer(struct profile_node *root,
                               char **buf)
{
      struct prof_buf prof_buf = { 0, 0, 0, 0 };

      dump_profile(root, 0, dump_profile_to_buffer_cb, &prof_buf);
      if (prof_buf.err) {
            *buf = NULL;
            return ENOMEM;
      }
      add_data_to_buffer(&prof_buf, "", 1); /* append nul */
      if (prof_buf.max - prof_buf.cur > (prof_buf.max >> 3)) {
            char *newptr = realloc(prof_buf.base, prof_buf.cur);
            if (newptr)
                  prof_buf.base = newptr;
      }
      *buf = prof_buf.base;
      return 0;
}
#endif

/*
 * prof_tree.c --- these routines maintain the parse tree of the
 *    config file.
 * 
 * All of the details of how the tree is stored is abstracted away in
 * this file; all of the other profile routines build, access, and
 * modify the tree via the accessor functions found in this file.
 *
 * Each node may represent either a relation or a section header.
 * 
 * A section header must have its value field set to 0, and may a one
 * or more child nodes, pointed to by first_child.
 * 
 * A relation has as its value a pointer to allocated memory
 * containing a string.  Its first_child pointer must be null.
 *
 */

/*
 * Free a node, and any children
 */
void profile_free_node(struct profile_node *node)
{
      struct profile_node *child, *next;

      if (node->magic != PROF_MAGIC_NODE)
            return;
      
      if (node->name)
            free(node->name);
      if (node->value)
            free(node->value);

      for (child=node->first_child; child; child = next) {
            next = child->next;
            profile_free_node(child);
      }
      node->magic = 0;
      
      free(node);
}

#ifndef HAVE_STRDUP
#undef strdup
#define strdup MYstrdup
static char *MYstrdup (const char *s)
{
    size_t sz = strlen(s) + 1;
    char *p = malloc(sz);
    if (p != 0)
      memcpy(p, s, sz);
    return p;
}
#endif

/*
 * Create a node
 */
errcode_t profile_create_node(const char *name, const char *value,
                        struct profile_node **ret_node)
{
      struct profile_node *new;

      new = malloc(sizeof(struct profile_node));
      if (!new)
            return ENOMEM;
      memset(new, 0, sizeof(struct profile_node));
      new->name = strdup(name);
      if (new->name == 0) {
          profile_free_node(new);
          return ENOMEM;
      }
      if (value) {
            new->value = strdup(value);
            if (new->value == 0) {
                profile_free_node(new);
                return ENOMEM;
            }
      }
      new->magic = PROF_MAGIC_NODE;

      *ret_node = new;
      return 0;
}

/*
 * This function verifies that all of the representation invarients of
 * the profile are true.  If not, we have a programming bug somewhere,
 * probably in this file.
 */
#ifdef DEBUG_PROGRAM
errcode_t profile_verify_node(struct profile_node *node)
{
      struct profile_node *p, *last;
      errcode_t   retval;

      CHECK_MAGIC(node);

      if (node->value && node->first_child)
            return PROF_SECTION_WITH_VALUE;

      last = 0;
      for (p = node->first_child; p; last = p, p = p->next) {
            if (p->prev != last)
                  return PROF_BAD_LINK_LIST;
            if (last && (last->next != p))
                  return PROF_BAD_LINK_LIST;
            if (node->group_level+1 != p->group_level)
                  return PROF_BAD_GROUP_LVL;
            if (p->parent != node)
                  return PROF_BAD_PARENT_PTR;
            retval = profile_verify_node(p);
            if (retval)
                  return retval;
      }
      return 0;
}
#endif

/*
 * Add a node to a particular section
 */
errcode_t profile_add_node(struct profile_node *section, const char *name,
                     const char *value, struct profile_node **ret_node)
{
      errcode_t retval;
      struct profile_node *p, *last, *new;

      CHECK_MAGIC(section);

      if (section->value)
            return PROF_ADD_NOT_SECTION;

      /*
       * Find the place to insert the new node.  We look for the
       * place *after* the last match of the node name, since 
       * order matters.
       */
      for (p=section->first_child, last = 0; p; last = p, p = p->next) {
            int cmp;
            cmp = strcmp(p->name, name);
            if (cmp > 0)
                  break;
      }
      retval = profile_create_node(name, value, &new);
      if (retval)
            return retval;
      new->group_level = section->group_level+1;
      new->deleted = 0;
      new->parent = section;
      new->prev = last;
      new->next = p;
      if (p)
            p->prev = new;
      if (last)
            last->next = new;
      else
            section->first_child = new;
      if (ret_node)
            *ret_node = new;
      return 0;
}

/*
 * Iterate through the section, returning the nodes which match
 * the given name.  If name is NULL, then interate through all the
 * nodes in the section.  If section_flag is non-zero, only return the
 * section which matches the name; don't return relations.  If value
 * is non-NULL, then only return relations which match the requested
 * value.  (The value argument is ignored if section_flag is non-zero.)
 * 
 * The first time this routine is called, the state pointer must be
 * null.  When this profile_find_node_relation() returns, if the state
 * pointer is non-NULL, then this routine should be called again.
 * (This won't happen if section_flag is non-zero, obviously.)
 *
 */
errcode_t profile_find_node(struct profile_node *section, const char *name,
                      const char *value, int section_flag, void **state,
                      struct profile_node **node)
{
      struct profile_node *p;

      CHECK_MAGIC(section);
      p = *state;
      if (p) {
            CHECK_MAGIC(p);
      } else
            p = section->first_child;
      
      for (; p; p = p->next) {
            if (name && (strcmp(p->name, name)))
                  continue;
            if (section_flag) {
                  if (p->value)
                        continue;
            } else {
                  if (!p->value)
                        continue;
                  if (value && (strcmp(p->value, value)))
                        continue;
            }
            if (p->deleted)
                continue;
            /* A match! */
            if (node)
                  *node = p;
            break;
      }
      if (p == 0) {
            *state = 0;
            return section_flag ? PROF_NO_SECTION : PROF_NO_RELATION;
      }
      /*
       * OK, we've found one match; now let's try to find another
       * one.  This way, if we return a non-zero state pointer,
       * there's guaranteed to be another match that's returned.
       */
      for (p = p->next; p; p = p->next) {
            if (name && (strcmp(p->name, name)))
                  continue;
            if (section_flag) {
                  if (p->value)
                        continue;
            } else {
                  if (!p->value)
                        continue;
                  if (value && (strcmp(p->value, value)))
                        continue;
            }
            /* A match! */
            break;
      }
      *state = p;
      return 0;
}

/*
 * This is a general-purpose iterator for returning all nodes that
 * match the specified name array.  
 */
struct profile_iterator {
      prf_magic_t       magic;
      profile_t         profile;
      int               flags;
      const char        *const *names;
      const char        *name;
      prf_file_t        file;
      int               file_serial;
      int               done_idx;
      struct profile_node     *node;
      int               num;
};

errcode_t 
profile_iterator_create(profile_t profile, const char *const *names, int flags,
                  void **ret_iter)
{
      struct profile_iterator *iter;
      int   done_idx = 0;

      if (profile == 0)
            return PROF_NO_PROFILE;
      if (profile->magic != PROF_MAGIC_PROFILE)
            return PROF_MAGIC_PROFILE;
      if (!names)
            return PROF_BAD_NAMESET;
      if (!(flags & PROFILE_ITER_LIST_SECTION)) {
            if (!names[0])
                  return PROF_BAD_NAMESET;
            done_idx = 1;
      }

      if ((iter = malloc(sizeof(struct profile_iterator))) == NULL)
            return ENOMEM;

      iter->magic = PROF_MAGIC_ITERATOR;
      iter->profile = profile;
      iter->names = names;
      iter->flags = flags;
      iter->file = profile->first_file;
      iter->done_idx = done_idx;
      iter->node = 0;
      iter->num = 0;
      *ret_iter = iter;
      return 0;
}

void profile_iterator_free(void **iter_p)
{
      struct profile_iterator *iter;

      if (!iter_p)
            return;
      iter = *iter_p;
      if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
            return;
      free(iter);
      *iter_p = 0;
}

/*
 * Note: the returned character strings in ret_name and ret_value
 * points to the stored character string in the parse string.  Before
 * this string value is returned to a calling application
 * (profile_node_iterator is not an exported interface), it should be
 * strdup()'ed.
 */
errcode_t profile_node_iterator(void **iter_p, struct profile_node **ret_node,
                        char **ret_name, char **ret_value)
{
      struct profile_iterator       *iter = *iter_p;
      struct profile_node           *section, *p;
      const char              *const *cpp;
      errcode_t               retval;
      int                     skip_num = 0;

      if (!iter || iter->magic != PROF_MAGIC_ITERATOR)
            return PROF_MAGIC_ITERATOR;
      if (iter->file && iter->file->magic != PROF_MAGIC_FILE)
          return PROF_MAGIC_FILE;
      /*
       * If the file has changed, then the node pointer is invalid,
       * so we'll have search the file again looking for it.
       */
      if (iter->node && (iter->file && 
                     iter->file->upd_serial != iter->file_serial)) {
            iter->flags &= ~PROFILE_ITER_FINAL_SEEN;
            skip_num = iter->num;
            iter->node = 0;
      }
      if (iter->node && iter->node->magic != PROF_MAGIC_NODE) {
          return PROF_MAGIC_NODE;
      }
get_new_file:
      if (iter->node == 0) {
            if (iter->file == 0 ||
                (iter->flags & PROFILE_ITER_FINAL_SEEN)) {
                  profile_iterator_free(iter_p);
                  if (ret_node)
                        *ret_node = 0;
                  if (ret_name)
                        *ret_name = 0;
                  if (ret_value)
                        *ret_value =0;
                  return 0;
            }
            if ((retval = profile_update_file(iter->file))) {
                if (retval == ENOENT || retval == EACCES) {
                  /* XXX memory leak? */
                  iter->file = iter->file->next;
                  skip_num = 0;
                  retval = 0;
                  goto get_new_file;
                } else {
                  profile_iterator_free(iter_p);
                  return retval;
                }
            }
            iter->file_serial = iter->file->upd_serial;
            /*
             * Find the section to list if we are a LIST_SECTION,
             * or find the containing section if not.
             */
            section = iter->file->root;
            for (cpp = iter->names; cpp[iter->done_idx]; cpp++) {
                  for (p=section->first_child; p; p = p->next) {
                        if (!strcmp(p->name, *cpp) && !p->value)
                              break;
                  }
                  if (!p) {
                        section = 0;
                        break;
                  }
                  section = p;
                  if (p->final)
                        iter->flags |= PROFILE_ITER_FINAL_SEEN;
            }
            if (!section) {
                  iter->file = iter->file->next;
                  skip_num = 0;
                  goto get_new_file;
            }
            iter->name = *cpp;
            iter->node = section->first_child;
      }
      /*
       * OK, now we know iter->node is set up correctly.  Let's do
       * the search.
       */
      for (p = iter->node; p; p = p->next) {
            if (iter->name && strcmp(p->name, iter->name))
                  continue;
            if ((iter->flags & PROFILE_ITER_SECTIONS_ONLY) &&
                p->value)
                  continue;
            if ((iter->flags & PROFILE_ITER_RELATIONS_ONLY) &&
                !p->value)
                  continue;
            if (skip_num > 0) {
                  skip_num--;
                  continue;
            }
            if (p->deleted)
                  continue;
            break;
      }
      iter->num++;
      if (!p) {
            iter->file = iter->file->next;
            iter->node = 0;
            skip_num = 0;
            goto get_new_file;
      }
      if ((iter->node = p->next) == NULL)
            iter->file = iter->file->next;
      if (ret_node)
            *ret_node = p;
      if (ret_name)
            *ret_name = p->name;
      if (ret_value)
            *ret_value = p->value;
      return 0;
}


/*
 * prof_get.c --- routines that expose the public interfaces for
 *    querying items from the profile.
 *
 */

/*
 * This function only gets the first value from the file; it is a
 * helper function for profile_get_string, profile_get_integer, etc.
 */
errcode_t profile_get_value(profile_t profile, const char *name,
                      const char *subname, const char *subsubname,
                      const char **ret_value)
{
      errcode_t         retval;
      void              *state;
      char              *value;
      const char        *names[4];

      names[0] = name;
      names[1] = subname;
      names[2] = subsubname;
      names[3] = 0;

      if ((retval = profile_iterator_create(profile, names,
                                    PROFILE_ITER_RELATIONS_ONLY,
                                    &state)))
            return retval;

      if ((retval = profile_node_iterator(&state, 0, 0, &value)))
            goto cleanup;

      if (value)
            *ret_value = value;
      else
            retval = PROF_NO_RELATION;
      
cleanup:
      profile_iterator_free(&state);
      return retval;
}

errcode_t 
profile_get_string(profile_t profile, const char *name, const char *subname,
               const char *subsubname, const char *def_val,
               char **ret_string)
{
      const char  *value;
      errcode_t   retval;

      if (profile) {
            retval = profile_get_value(profile, name, subname, 
                                 subsubname, &value);
            if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION)
                  value = def_val;
            else if (retval)
                  return retval;
      } else
            value = def_val;
    
      if (value) {
            *ret_string = malloc(strlen(value)+1);
            if (*ret_string == 0)
                  return ENOMEM;
            strcpy(*ret_string, value);
      } else
            *ret_string = 0;
      return 0;
}

errcode_t 
profile_get_integer(profile_t profile, const char *name, const char *subname,
                const char *subsubname, int def_val, int *ret_int)
{
      const char  *value;
      errcode_t   retval;
      char            *end_value;
      long        ret_long;

      *ret_int = def_val;
      if (profile == 0)
            return 0;

      retval = profile_get_value(profile, name, subname, subsubname, &value);
      if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
            *ret_int = def_val;
            return 0;
      } else if (retval)
            return retval;

      if (value[0] == 0)
          /* Empty string is no good.  */
          return PROF_BAD_INTEGER;
      errno = 0;
      ret_long = strtol (value, &end_value, 10);

      /* Overflow or underflow.  */
      if ((ret_long == LONG_MIN || ret_long == LONG_MAX) && errno != 0)
          return PROF_BAD_INTEGER;
      /* Value outside "int" range.  */
      if ((long) (int) ret_long != ret_long)
          return PROF_BAD_INTEGER;
      /* Garbage in string.  */
      if (end_value != value + strlen (value))
          return PROF_BAD_INTEGER;
      
   
      *ret_int = ret_long;
      return 0;
}

errcode_t 
profile_get_uint(profile_t profile, const char *name, const char *subname,
             const char *subsubname, unsigned int def_val, 
             unsigned int *ret_int)
{
      const char  *value;
      errcode_t   retval;
      char            *end_value;
      unsigned long     ret_long;

      *ret_int = def_val;
      if (profile == 0)
            return 0;

      retval = profile_get_value(profile, name, subname, subsubname, &value);
      if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
            *ret_int = def_val;
            return 0;
      } else if (retval)
            return retval;

      if (value[0] == 0)
          /* Empty string is no good.  */
          return PROF_BAD_INTEGER;
      errno = 0;
      ret_long = strtoul (value, &end_value, 10);

      /* Overflow or underflow.  */
      if ((ret_long == ULONG_MAX) && errno != 0)
          return PROF_BAD_INTEGER;
      /* Value outside "int" range.  */
      if ((unsigned long) (unsigned int) ret_long != ret_long)
          return PROF_BAD_INTEGER;
      /* Garbage in string.  */
      if (end_value != value + strlen (value))
          return PROF_BAD_INTEGER;
      
      *ret_int = ret_long;
      return 0;
}

static const char *const conf_yes[] = {
    "y", "yes", "true", "t", "1", "on",
    0,
};

static const char *const conf_no[] = {
    "n", "no", "false", "nil", "0", "off",
    0,
};

static errcode_t
profile_parse_boolean(const char *s, int *ret_boolean)
{
    const char *const *p;
    
    if (ret_boolean == NULL)
      return PROF_EINVAL;

    for(p=conf_yes; *p; p++) {
            if (!strcasecmp(*p,s)) {
                  *ret_boolean = 1;
            return 0;
            }
    }

    for(p=conf_no; *p; p++) {
            if (!strcasecmp(*p,s)) {
                  *ret_boolean = 0;
                  return 0;
            }
    }
      
      return PROF_BAD_BOOLEAN;
}

errcode_t 
profile_get_boolean(profile_t profile, const char *name, const char *subname,
                const char *subsubname, int def_val, int *ret_boolean)
{
      const char  *value;
      errcode_t   retval;

      if (profile == 0) {
            *ret_boolean = def_val;
            return 0;
      }

      retval = profile_get_value(profile, name, subname, subsubname, &value);
      if (retval == PROF_NO_SECTION || retval == PROF_NO_RELATION) {
            *ret_boolean = def_val;
            return 0;
      } else if (retval)
            return retval;
   
      return profile_parse_boolean (value, ret_boolean);
}

errcode_t 
profile_iterator(void **iter_p, char **ret_name, char **ret_value)
{
      char *name, *value;
      errcode_t   retval;
      
      retval = profile_node_iterator(iter_p, 0, &name, &value);
      if (retval)
            return retval;

      if (ret_name) {
            if (name) {
                  *ret_name = malloc(strlen(name)+1);
                  if (!*ret_name)
                        return ENOMEM;
                  strcpy(*ret_name, name);
            } else
                  *ret_name = 0;
      }
      if (ret_value) {
            if (value) {
                  *ret_value = malloc(strlen(value)+1);
                  if (!*ret_value) {
                        if (ret_name) {
                              free(*ret_name);
                              *ret_name = 0;
                        }
                        return ENOMEM;
                  }
                  strcpy(*ret_value, value);
            } else
                  *ret_value = 0;
      }
      return 0;
}

#ifdef DEBUG_PROGRAM

/*
 * test_profile.c --- testing program for the profile routine
 */

#include "argv_parse.h"
#include "profile_helpers.h"

const char *program_name = "test_profile";

#define PRINT_VALUE     1
#define PRINT_VALUES    2

static void do_cmd(profile_t profile, char **argv)
{
      errcode_t   retval;
      const char  **names, *value;
      char        **values, **cpp;
      char  *cmd;
      int         print_status;

      cmd = *(argv);
      names = (const char **) argv + 1;
      print_status = 0;
      retval = 0;
      if (cmd == 0)
            return;
      if (!strcmp(cmd, "query")) {
            retval = profile_get_values(profile, names, &values);
            print_status = PRINT_VALUES;
      } else if (!strcmp(cmd, "query1")) {
            const char *name = 0;
            const char *subname = 0;
            const char *subsubname = 0;

            name = names[0];
            if (name)
                  subname = names[1];
            if (subname)
                  subsubname = names[2];
            if (subsubname && names[3]) {
                  fprintf(stderr, 
                        "Only 3 levels are allowed with query1\n");
                  retval = EINVAL;
            } else
                  retval = profile_get_value(profile, name, subname, 
                                       subsubname, &value);
            print_status = PRINT_VALUE;
      } else if (!strcmp(cmd, "list_sections")) {
            retval = profile_get_subsection_names(profile, names, 
                                          &values);
            print_status = PRINT_VALUES;
      } else if (!strcmp(cmd, "list_relations")) {
            retval = profile_get_relation_names(profile, names, 
                                        &values);
            print_status = PRINT_VALUES;
      } else if (!strcmp(cmd, "dump")) {
            retval = profile_write_tree_file
                  (profile->first_file->root, stdout);
#if 0
      } else if (!strcmp(cmd, "clear")) {
            retval = profile_clear_relation(profile, names);
      } else if (!strcmp(cmd, "update")) {
            retval = profile_update_relation(profile, names+2,
                                     *names, *(names+1));
#endif
      } else if (!strcmp(cmd, "verify")) {
            retval = profile_verify_node
                  (profile->first_file->root);
#if 0
      } else if (!strcmp(cmd, "rename_section")) {
            retval = profile_rename_section(profile, names+1, *names);
      } else if (!strcmp(cmd, "add")) {
            value = *names;
            if (strcmp(value, "NULL") == 0)
                  value = NULL;
            retval = profile_add_relation(profile, names+1, value);
      } else if (!strcmp(cmd, "flush")) {
            retval = profile_flush(profile);
#endif
      } else {
            printf("Invalid command.\n");
      }
      if (retval) {
            com_err(cmd, retval, "");
            print_status = 0;
      }
      switch (print_status) {
      case PRINT_VALUE:
            printf("%s\n", value);
            break;
      case PRINT_VALUES:
            for (cpp = values; *cpp; cpp++)
                  printf("%s\n", *cpp);
            profile_free_list(values);
            break;
      }
}

static void do_batchmode(profile_t profile)
{
      int         argc, ret;
      char        **argv;
      char        buf[256];

      while (!feof(stdin)) {
            if (fgets(buf, sizeof(buf), stdin) == NULL)
                  break;
            printf(">%s", buf);
            ret = argv_parse(buf, &argc, &argv);
            if (ret != 0) {
                  printf("Argv_parse returned %d!\n", ret);
                  continue;
            }
            do_cmd(profile, argv);
            printf("\n");
            argv_free(argv);
      }
      profile_release(profile);
      exit(0);
      
}

void syntax_err_report(const char *filename, long err, int line_num)
{
      fprintf(stderr, "Syntax error in %s, line number %d: %s\n",
            filename, line_num, error_message(err));
      exit(1);
}

const char *default_str = "[foo]\n\tbar=quux\n\tsub = {\n\t\twin = true\n}\n";

int main(int argc, char **argv)
{
    profile_t     profile;
    long    retval;
    char    *cmd;
    
    if (argc < 2) {
          fprintf(stderr, "Usage: %s filename [cmd argset]\n", program_name);
          exit(1);
    }

    initialize_prof_error_table();

    profile_set_syntax_err_cb(syntax_err_report);
    
    retval = profile_init_path(argv[1], &profile);
    if (retval) {
      com_err(program_name, retval, "while initializing profile");
      exit(1);
    }
    retval = profile_set_default(profile, default_str);
    if (retval) {
      com_err(program_name, retval, "while setting default");
      exit(1);
    }

    cmd = *(argv+2);
    if (!cmd || !strcmp(cmd, "batch"))
          do_batchmode(profile);
    else
          do_cmd(profile, argv+2);
    profile_release(profile);

    return 0;
}

#endif

Generated by  Doxygen 1.6.0   Back to index