/* * 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. * */ #include "config.h" #ifdef HAVE_UNISTD_H #include #endif #include #ifdef HAVE_STDLIB_H #include #endif #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_PWD_H #include #endif #include #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 = ""; 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; free(fn); 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: if (array) array[num] = 0; closedir(dir); free_list(array); return retval; } errcode_t profile_init(const char * const *files, profile_t *ret_profile) { const char * const *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++) { if (array) free_list(array); array = NULL; 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) { retval = ENOENT; goto errout; } } 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 "". If * the file "" had previously been passed to profile_init(), * then def_string parameter will be parsed and used as the profile * information for the "" 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); 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; free(node->name); 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->magic = PROF_MAGIC_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; } } *ret_node = new; return 0; } /* * This function verifies that all of the representation invariants 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 iterate 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 == NULL || (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? */ if (iter->file) 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) { if (iter->file) 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) { if (iter->file) iter->file = iter->file->next; iter->node = 0; skip_num = 0; goto get_new_file; } if ((iter->node = p->next) == NULL) if (iter->file) 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, 0); /* 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, 0); /* 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; } errcode_t profile_get_double(profile_t profile, const char *name, const char *subname, const char *subsubname, double def_val, double *ret_double) { const char *value; errcode_t retval; char *end_value; double double_val; *ret_double = 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_double = def_val; return 0; } else if (retval) return retval; if (value[0] == 0) /* Empty string is no good. */ return PROF_BAD_INTEGER; errno = 0; double_val = strtod(value, &end_value); /* Overflow or underflow. */ if (errno != 0) return PROF_BAD_INTEGER; /* Garbage in string. */ if (end_value != value + strlen(value)) return PROF_BAD_INTEGER; *ret_double = double_val; 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