1473 lines
39 KiB
C
1473 lines
39 KiB
C
/*
|
|
* Copyright (c) 1997 - 2004 Kungliga Tekniska Högskolan
|
|
* (Royal Institute of Technology, Stockholm, Sweden).
|
|
* All rights reserved.
|
|
*
|
|
* Portions Copyright (c) 2009 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "baselocl.h"
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <parse_time.h>
|
|
|
|
#if defined(HAVE_FRAMEWORK_COREFOUNDATION)
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#endif
|
|
|
|
/* Gaah! I want a portable funopen */
|
|
struct fileptr {
|
|
heim_context context;
|
|
const char *s;
|
|
FILE *f;
|
|
};
|
|
|
|
static char *
|
|
config_fgets(char *str, size_t len, struct fileptr *ptr)
|
|
{
|
|
/* XXX this is not correct, in that they don't do the same if the
|
|
line is longer than len */
|
|
if(ptr->f != NULL)
|
|
return fgets(str, len, ptr->f);
|
|
else {
|
|
/* this is almost strsep_copy */
|
|
const char *p;
|
|
ssize_t l;
|
|
if(*ptr->s == '\0')
|
|
return NULL;
|
|
p = ptr->s + strcspn(ptr->s, "\n");
|
|
if(*p == '\n')
|
|
p++;
|
|
l = min(len, (size_t)(p - ptr->s));
|
|
if(len > 0) {
|
|
memcpy(str, ptr->s, l);
|
|
str[l] = '\0';
|
|
}
|
|
ptr->s = p;
|
|
return str;
|
|
}
|
|
}
|
|
|
|
static heim_error_code parse_section(char *p, heim_config_section **s,
|
|
heim_config_section **res,
|
|
const char **err_message);
|
|
static heim_error_code parse_binding(struct fileptr *f, unsigned *lineno, char *p,
|
|
heim_config_binding **b,
|
|
heim_config_binding **parent,
|
|
const char **err_message);
|
|
static heim_error_code parse_list(struct fileptr *f, unsigned *lineno,
|
|
heim_config_binding **parent,
|
|
const char **err_message);
|
|
|
|
heim_config_section *
|
|
heim_config_get_entry(heim_config_section **parent, const char *name, int type)
|
|
{
|
|
heim_config_section **q;
|
|
|
|
for (q = parent; *q != NULL; q = &(*q)->next)
|
|
if (type == heim_config_list &&
|
|
(unsigned)type == (*q)->type &&
|
|
strcmp(name, (*q)->name) == 0)
|
|
return *q;
|
|
*q = calloc(1, sizeof(**q));
|
|
if (*q == NULL)
|
|
return NULL;
|
|
(*q)->name = strdup(name);
|
|
(*q)->type = type;
|
|
if ((*q)->name == NULL) {
|
|
free(*q);
|
|
*q = NULL;
|
|
return NULL;
|
|
}
|
|
return *q;
|
|
}
|
|
|
|
/*
|
|
* Parse a section:
|
|
*
|
|
* [section]
|
|
* foo = bar
|
|
* b = {
|
|
* a
|
|
* }
|
|
* ...
|
|
*
|
|
* starting at the line in `p', storing the resulting structure in
|
|
* `s' and hooking it into `parent'.
|
|
* Store the error message in `err_message'.
|
|
*/
|
|
|
|
static heim_error_code
|
|
parse_section(char *p, heim_config_section **s, heim_config_section **parent,
|
|
const char **err_message)
|
|
{
|
|
char *p1;
|
|
heim_config_section *tmp;
|
|
|
|
p1 = strchr (p + 1, ']');
|
|
if (p1 == NULL) {
|
|
*err_message = "missing ]";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
*p1 = '\0';
|
|
tmp = heim_config_get_entry(parent, p + 1, heim_config_list);
|
|
if(tmp == NULL) {
|
|
*err_message = "out of memory";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
*s = tmp;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Parse a brace-enclosed list from `f', hooking in the structure at
|
|
* `parent'.
|
|
* Store the error message in `err_message'.
|
|
*/
|
|
|
|
static heim_error_code
|
|
parse_list(struct fileptr *f, unsigned *lineno, heim_config_binding **parent,
|
|
const char **err_message)
|
|
{
|
|
char buf[2048];
|
|
heim_error_code ret;
|
|
heim_config_binding *b = NULL;
|
|
unsigned beg_lineno = *lineno;
|
|
|
|
while(config_fgets(buf, sizeof(buf), f) != NULL) {
|
|
char *p;
|
|
|
|
++*lineno;
|
|
buf[strcspn(buf, "\r\n")] = '\0';
|
|
p = buf;
|
|
while(isspace((unsigned char)*p))
|
|
++p;
|
|
if (*p == '#' || *p == ';' || *p == '\0')
|
|
continue;
|
|
while(isspace((unsigned char)*p))
|
|
++p;
|
|
if (*p == '}')
|
|
return 0;
|
|
if (*p == '\0')
|
|
continue;
|
|
ret = parse_binding (f, lineno, p, &b, parent, err_message);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
*lineno = beg_lineno;
|
|
*err_message = "unclosed {";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
static heim_error_code
|
|
parse_binding(struct fileptr *f, unsigned *lineno, char *p,
|
|
heim_config_binding **b, heim_config_binding **parent,
|
|
const char **err_message)
|
|
{
|
|
heim_config_binding *tmp;
|
|
char *p1, *p2;
|
|
heim_error_code ret = 0;
|
|
|
|
p1 = p;
|
|
while (*p && *p != '=' && !isspace((unsigned char)*p))
|
|
++p;
|
|
if (*p == '\0') {
|
|
*err_message = "missing =";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
p2 = p;
|
|
while (isspace((unsigned char)*p))
|
|
++p;
|
|
if (*p != '=') {
|
|
*err_message = "missing =";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
++p;
|
|
while(isspace((unsigned char)*p))
|
|
++p;
|
|
*p2 = '\0';
|
|
if (*p == '{') {
|
|
tmp = heim_config_get_entry(parent, p1, heim_config_list);
|
|
if (tmp == NULL) {
|
|
*err_message = "out of memory";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
ret = parse_list (f, lineno, &tmp->u.list, err_message);
|
|
} else {
|
|
tmp = heim_config_get_entry(parent, p1, heim_config_string);
|
|
if (tmp == NULL) {
|
|
*err_message = "out of memory";
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
p1 = p;
|
|
p = p1 + strlen(p1);
|
|
while(p > p1 && isspace((unsigned char)*(p-1)))
|
|
--p;
|
|
*p = '\0';
|
|
tmp->u.string = strdup(p1);
|
|
}
|
|
*b = tmp;
|
|
return ret;
|
|
}
|
|
|
|
#if defined(HAVE_FRAMEWORK_COREFOUNDATION)
|
|
|
|
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
|
|
#define HAVE_CFPROPERTYLISTCREATEWITHSTREAM 1
|
|
#endif
|
|
|
|
static char *
|
|
cfstring2cstring(CFStringRef string)
|
|
{
|
|
CFIndex len;
|
|
char *str;
|
|
|
|
str = (char *) CFStringGetCStringPtr(string, kCFStringEncodingUTF8);
|
|
if (str)
|
|
return strdup(str);
|
|
|
|
len = CFStringGetLength(string);
|
|
len = 1 + CFStringGetMaximumSizeForEncoding(len, kCFStringEncodingUTF8);
|
|
str = malloc(len);
|
|
if (str == NULL)
|
|
return NULL;
|
|
|
|
if (!CFStringGetCString (string, str, len, kCFStringEncodingUTF8)) {
|
|
free (str);
|
|
return NULL;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static void
|
|
convert_content(const void *key, const void *value, void *context)
|
|
{
|
|
heim_config_section *tmp, **parent = context;
|
|
char *k;
|
|
|
|
if (CFGetTypeID(key) != CFStringGetTypeID())
|
|
return;
|
|
|
|
k = cfstring2cstring(key);
|
|
if (k == NULL)
|
|
return;
|
|
|
|
if (CFGetTypeID(value) == CFStringGetTypeID()) {
|
|
tmp = heim_config_get_entry(parent, k, heim_config_string);
|
|
tmp->u.string = cfstring2cstring(value);
|
|
} else if (CFGetTypeID(value) == CFDictionaryGetTypeID()) {
|
|
tmp = heim_config_get_entry(parent, k, heim_config_list);
|
|
CFDictionaryApplyFunction(value, convert_content, &tmp->u.list);
|
|
} else {
|
|
/* log */
|
|
}
|
|
free(k);
|
|
}
|
|
|
|
static heim_error_code
|
|
parse_plist_config(heim_context context, const char *path, heim_config_section **parent)
|
|
{
|
|
CFReadStreamRef s;
|
|
CFDictionaryRef d;
|
|
CFURLRef url;
|
|
|
|
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8 *)path, strlen(path), 0);
|
|
if (url == NULL) {
|
|
heim_clear_error_message(context);
|
|
return ENOMEM;
|
|
}
|
|
|
|
s = CFReadStreamCreateWithFile(kCFAllocatorDefault, url);
|
|
CFRelease(url);
|
|
if (s == NULL) {
|
|
heim_clear_error_message(context);
|
|
return ENOMEM;
|
|
}
|
|
|
|
if (!CFReadStreamOpen(s)) {
|
|
CFRelease(s);
|
|
heim_clear_error_message(context);
|
|
return ENOENT;
|
|
}
|
|
|
|
#ifdef HAVE_CFPROPERTYLISTCREATEWITHSTREAM
|
|
d = (CFDictionaryRef)CFPropertyListCreateWithStream(NULL, s, 0, kCFPropertyListImmutable, NULL, NULL);
|
|
#else
|
|
d = (CFDictionaryRef)CFPropertyListCreateFromStream(NULL, s, 0, kCFPropertyListImmutable, NULL, NULL);
|
|
#endif
|
|
CFRelease(s);
|
|
if (d == NULL) {
|
|
heim_clear_error_message(context);
|
|
return ENOENT;
|
|
}
|
|
|
|
CFDictionaryApplyFunction(d, convert_content, parent);
|
|
CFRelease(d);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
static int
|
|
is_absolute_path(const char *path)
|
|
{
|
|
/*
|
|
* An absolute path is one that refers to an explicit object
|
|
* without ambiguity.
|
|
*/
|
|
#ifdef WIN32
|
|
size_t len = strlen(path);
|
|
|
|
/* UNC path is by definition absolute */
|
|
if (len > 2
|
|
&& ISPATHSEP(path[0])
|
|
&& ISPATHSEP(path[1]))
|
|
return 1;
|
|
|
|
/* A drive letter path might be absolute */
|
|
if (len > 3
|
|
&& isalpha((unsigned char)path[0])
|
|
&& path[1] == ':'
|
|
&& ISPATHSEP(path[2]))
|
|
return 1;
|
|
|
|
/*
|
|
* if no drive letter but first char is a path
|
|
* separator then the drive letter must be obtained
|
|
* from the including file.
|
|
*/
|
|
#else
|
|
/* UNIX is easy, first char '/' is absolute */
|
|
if (ISPATHSEP(path[0]))
|
|
return 1;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Parse the config file `fname', generating the structures into `res'
|
|
* returning error messages in `err_message'
|
|
*/
|
|
|
|
static heim_error_code
|
|
heim_config_parse_debug(struct fileptr *f,
|
|
heim_config_section **res,
|
|
unsigned *lineno,
|
|
const char **err_message)
|
|
{
|
|
heim_config_section *s = NULL;
|
|
heim_config_binding *b = NULL;
|
|
char buf[2048];
|
|
heim_error_code ret;
|
|
|
|
*lineno = 0;
|
|
*err_message = "";
|
|
|
|
while (config_fgets(buf, sizeof(buf), f) != NULL) {
|
|
char *p;
|
|
|
|
++*lineno;
|
|
buf[strcspn(buf, "\r\n")] = '\0';
|
|
p = buf;
|
|
while(isspace((unsigned char)*p))
|
|
++p;
|
|
if (*p == '#' || *p == ';')
|
|
continue;
|
|
if (*p == '[') {
|
|
ret = parse_section(p, &s, res, err_message);
|
|
if (ret)
|
|
return ret;
|
|
b = NULL;
|
|
} else if (*p == '}') {
|
|
*err_message = "unmatched }";
|
|
return 2048;
|
|
} else if (strncmp(p, "include", sizeof("include") - 1) == 0 &&
|
|
isspace((unsigned char)p[sizeof("include") - 1])) {
|
|
p += sizeof("include");
|
|
while (isspace((unsigned char)*p))
|
|
p++;
|
|
if (!is_absolute_path(p)) {
|
|
heim_set_error_message(f->context, HEIM_ERR_CONFIG_BADFORMAT,
|
|
"Configuration include path must be "
|
|
"absolute");
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
ret = heim_config_parse_file_multi(f->context, p, res);
|
|
if (ret)
|
|
return ret;
|
|
} else if (strncmp(p, "includedir", sizeof("includedir") - 1) == 0 &&
|
|
isspace((unsigned char)p[sizeof("includedir") - 1])) {
|
|
p += sizeof("includedir");
|
|
while (isspace((unsigned char)*p))
|
|
p++;
|
|
if (!is_absolute_path(p)) {
|
|
heim_set_error_message(f->context, HEIM_ERR_CONFIG_BADFORMAT,
|
|
"Configuration includedir path must be "
|
|
"absolute");
|
|
return HEIM_ERR_CONFIG_BADFORMAT;
|
|
}
|
|
ret = heim_config_parse_dir_multi(f->context, p, res);
|
|
if (ret)
|
|
return ret;
|
|
} else if(*p != '\0') {
|
|
if (s == NULL) {
|
|
*err_message = "binding before section";
|
|
return 2048;
|
|
}
|
|
ret = parse_binding(f, lineno, p, &b, &s->u.list, err_message);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
is_plist_file(const char *fname)
|
|
{
|
|
size_t len = strlen(fname);
|
|
char suffix[] = ".plist";
|
|
if (len < sizeof(suffix))
|
|
return 0;
|
|
if (strcasecmp(&fname[len - (sizeof(suffix) - 1)], suffix) != 0)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Parse configuration files in the given directory and add the result
|
|
* into res. Only files whose names consist only of alphanumeric
|
|
* characters, hyphen, and underscore, will be parsed, though files
|
|
* ending in ".conf" will also be parsed.
|
|
*
|
|
* This interface can be used to parse several configuration directories
|
|
* into one resulting heim_config_section by calling it repeatably.
|
|
*
|
|
* @param context a Kerberos 5 context.
|
|
* @param dname a directory name to a Kerberos configuration file
|
|
* @param res the returned result, must be free with heim_free_config_files().
|
|
* @return Return an error code or 0, see heim_get_error_message().
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
heim_error_code
|
|
heim_config_parse_dir_multi(heim_context context,
|
|
const char *dname,
|
|
heim_config_section **res)
|
|
{
|
|
struct dirent *entry;
|
|
heim_error_code ret;
|
|
DIR *d;
|
|
|
|
if ((d = opendir(dname)) == NULL)
|
|
return errno;
|
|
|
|
while ((entry = readdir(d)) != NULL) {
|
|
char *p = entry->d_name;
|
|
char *path;
|
|
int is_valid = 1;
|
|
|
|
while (*p) {
|
|
/*
|
|
* Here be dragons. The call to heim_config_parse_file_multi()
|
|
* below expands path tokens. Because of the limitations here
|
|
* on file naming, we can't have path tokens in the file name,
|
|
* so we're safe. Anyone changing this if condition here should
|
|
* be aware.
|
|
*/
|
|
if (!isalnum((unsigned char)*p) && *p != '_' && *p != '-' &&
|
|
strcmp(p, ".conf") != 0) {
|
|
is_valid = 0;
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
if (!is_valid)
|
|
continue;
|
|
|
|
if (asprintf(&path, "%s/%s", dname, entry->d_name) == -1 ||
|
|
path == NULL) {
|
|
(void) closedir(d);
|
|
return heim_enomem(context);
|
|
}
|
|
ret = heim_config_parse_file_multi(context, path, res);
|
|
free(path);
|
|
if (ret == ENOMEM) {
|
|
(void) closedir(d);
|
|
return ENOMEM;
|
|
}
|
|
/* Ignore malformed config files so we don't lock out admins, etc... */
|
|
}
|
|
(void) closedir(d);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
is_devnull(struct stat *st)
|
|
{
|
|
#ifdef WIN32
|
|
return 0;
|
|
#else
|
|
struct stat devnullst;
|
|
|
|
if (stat("/dev/null", &devnullst) == -1)
|
|
return 0;
|
|
return st->st_dev == devnullst.st_dev && st->st_ino == devnullst.st_ino;
|
|
#endif
|
|
}
|
|
|
|
HEIMDAL_THREAD_LOCAL int config_include_depth = 0;
|
|
|
|
/**
|
|
* Parse a configuration file and add the result into res. This
|
|
* interface can be used to parse several configuration files into one
|
|
* resulting heim_config_section by calling it repeatably.
|
|
*
|
|
* @param context a Kerberos 5 context.
|
|
* @param fname a file name to a Kerberos configuration file
|
|
* @param res the returned result, must be free with heim_free_config_files().
|
|
* @return Return an error code or 0, see heim_get_error_message().
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
heim_error_code
|
|
heim_config_parse_file_multi(heim_context context,
|
|
const char *fname,
|
|
heim_config_section **res)
|
|
{
|
|
const char *str;
|
|
char *newfname = NULL;
|
|
unsigned lineno = 0;
|
|
heim_error_code ret = 0;
|
|
struct fileptr f;
|
|
struct stat st;
|
|
|
|
if (config_include_depth > 5) {
|
|
heim_warnx(context, "Maximum config file include depth reached; "
|
|
"not including %s", fname);
|
|
return 0;
|
|
}
|
|
config_include_depth++;
|
|
|
|
/**
|
|
* If the fname starts with "~/" parse configuration file in the
|
|
* current users home directory. The behavior can be disabled and
|
|
* enabled by calling heim_set_home_dir_access().
|
|
*/
|
|
if (ISTILDE(fname[0]) && ISPATHSEP(fname[1])) {
|
|
if (!heim_context_get_homedir_access(context)) {
|
|
heim_set_error_message(context, EPERM,
|
|
"Access to home directory not allowed");
|
|
ret = EPERM;
|
|
goto out;
|
|
}
|
|
if (asprintf(&newfname, "%%{USERCONFIG}%s", &fname[1]) < 0 ||
|
|
newfname == NULL) {
|
|
ret = heim_enomem(context);
|
|
goto out;
|
|
}
|
|
fname = newfname;
|
|
}
|
|
|
|
if (is_plist_file(fname)) {
|
|
#if defined(HAVE_FRAMEWORK_COREFOUNDATION)
|
|
ret = parse_plist_config(context, fname, res);
|
|
if (ret) {
|
|
heim_set_error_message(context, ret,
|
|
"Failed to parse plist %s", fname);
|
|
goto out;
|
|
}
|
|
#else
|
|
heim_set_error_message(context, ENOENT,
|
|
"no support for plist configuration files");
|
|
ret = ENOENT;
|
|
goto out;
|
|
#endif
|
|
} else {
|
|
char *exp_fname = NULL;
|
|
|
|
/*
|
|
* Note that heim_config_parse_dir_multi() doesn't want tokens
|
|
* expanded here, but it happens to limit the names of files to
|
|
* include such that there can be no tokens to expand. Don't
|
|
* add token expansion for tokens using _, say.
|
|
*/
|
|
ret = heim_expand_path_tokens(context, fname, 1, &exp_fname, NULL);
|
|
if (ret)
|
|
goto out;
|
|
free(newfname);
|
|
fname = newfname = exp_fname;
|
|
|
|
f.context = context;
|
|
f.f = fopen(fname, "r");
|
|
f.s = NULL;
|
|
if (f.f == NULL || fstat(fileno(f.f), &st) == -1) {
|
|
if (f.f != NULL)
|
|
(void) fclose(f.f);
|
|
ret = errno;
|
|
heim_set_error_message(context, ret, "open or stat %s: %s",
|
|
fname, strerror(ret));
|
|
goto out;
|
|
}
|
|
|
|
if (!S_ISREG(st.st_mode) && !is_devnull(&st)) {
|
|
(void) fclose(f.f);
|
|
heim_set_error_message(context, EISDIR, "not a regular file %s: %s",
|
|
fname, strerror(EISDIR));
|
|
ret = EISDIR;
|
|
goto out;
|
|
}
|
|
|
|
ret = heim_config_parse_debug(&f, res, &lineno, &str);
|
|
fclose(f.f);
|
|
if (ret) {
|
|
if (ret != HEIM_ERR_CONFIG_BADFORMAT)
|
|
ret = HEIM_ERR_CONFIG_BADFORMAT;
|
|
heim_set_error_message(context, ret, "%s:%u: %s",
|
|
fname, lineno, str);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
out:
|
|
config_include_depth--;
|
|
if (ret == HEIM_ERR_CONFIG_BADFORMAT || (ret && config_include_depth > 0)) {
|
|
heim_warn(context, ret, "Ignoring");
|
|
if (config_include_depth > 0)
|
|
ret = 0;
|
|
}
|
|
free(newfname);
|
|
return ret;
|
|
}
|
|
|
|
heim_error_code
|
|
heim_config_parse_file(heim_context context,
|
|
const char *fname,
|
|
heim_config_section **res)
|
|
{
|
|
*res = NULL;
|
|
return heim_config_parse_file_multi(context, fname, res);
|
|
}
|
|
|
|
static void
|
|
free_binding(heim_context context, heim_config_binding *b)
|
|
{
|
|
heim_config_binding *next_b;
|
|
|
|
while (b) {
|
|
free (b->name);
|
|
assert(b->type == heim_config_string || b->type == heim_config_list);
|
|
if (b->type == heim_config_string)
|
|
free (b->u.string);
|
|
else
|
|
free_binding (context, b->u.list);
|
|
next_b = b->next;
|
|
free (b);
|
|
b = next_b;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Free configuration file section, the result of
|
|
* heim_config_parse_file() and heim_config_parse_file_multi().
|
|
*
|
|
* @param context A Kerberos 5 context
|
|
* @param s the configuration section to free
|
|
*
|
|
* @return returns 0 on successes, otherwise an error code, see
|
|
* heim_get_error_message()
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
heim_error_code
|
|
heim_config_file_free(heim_context context, heim_config_section *s)
|
|
{
|
|
free_binding (context, s);
|
|
return 0;
|
|
}
|
|
|
|
#ifndef HEIMDAL_SMALLER
|
|
|
|
heim_error_code
|
|
heim_config_copy(heim_context context,
|
|
heim_config_section *c,
|
|
heim_config_section **head)
|
|
{
|
|
heim_config_binding *d, *previous = NULL;
|
|
|
|
*head = NULL;
|
|
|
|
while (c) {
|
|
d = calloc(1, sizeof(*d));
|
|
|
|
if (*head == NULL)
|
|
*head = d;
|
|
|
|
d->name = strdup(c->name);
|
|
d->type = c->type;
|
|
assert(d->type == heim_config_string || d->type == heim_config_list);
|
|
if (d->type == heim_config_string)
|
|
d->u.string = strdup(c->u.string);
|
|
else
|
|
heim_config_copy (context, c->u.list, &d->u.list);
|
|
if (previous)
|
|
previous->next = d;
|
|
|
|
previous = d;
|
|
c = c->next;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif /* HEIMDAL_SMALLER */
|
|
|
|
const void *
|
|
heim_config_get_next(heim_context context,
|
|
const heim_config_section *c,
|
|
const heim_config_binding **pointer,
|
|
int type,
|
|
...)
|
|
{
|
|
const char *ret;
|
|
va_list args;
|
|
|
|
va_start(args, type);
|
|
ret = heim_config_vget_next(context, c, pointer, type, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
static const void *
|
|
vget_next(heim_context context,
|
|
const heim_config_binding *b,
|
|
const heim_config_binding **pointer,
|
|
int type,
|
|
const char *name,
|
|
va_list args)
|
|
{
|
|
const char *p = va_arg(args, const char *);
|
|
|
|
while (b != NULL) {
|
|
if (strcmp(b->name, name) == 0) {
|
|
if (b->type == (unsigned)type && p == NULL) {
|
|
*pointer = b;
|
|
return b->u.generic;
|
|
} else if (b->type == heim_config_list && p != NULL) {
|
|
return vget_next(context, b->u.list, pointer, type, p, args);
|
|
}
|
|
}
|
|
b = b->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const void *
|
|
heim_config_vget_next(heim_context context,
|
|
const heim_config_section *c,
|
|
const heim_config_binding **pointer,
|
|
int type,
|
|
va_list args)
|
|
{
|
|
const heim_config_binding *b;
|
|
const char *p;
|
|
|
|
if (c == NULL)
|
|
return NULL;
|
|
|
|
if (*pointer == NULL) {
|
|
/* first time here, walk down the tree looking for the right
|
|
section */
|
|
p = va_arg(args, const char *);
|
|
if (p == NULL)
|
|
return NULL;
|
|
return vget_next(context, c, pointer, type, p, args);
|
|
}
|
|
|
|
/* we were called again, so just look for more entries with the
|
|
same name and type */
|
|
for (b = (*pointer)->next; b != NULL; b = b->next) {
|
|
if(strcmp(b->name, (*pointer)->name) == 0 && b->type == (unsigned)type) {
|
|
*pointer = b;
|
|
return b->u.generic;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const void *
|
|
heim_config_get(heim_context context,
|
|
const heim_config_section *c,
|
|
int type,
|
|
...)
|
|
{
|
|
const void *ret;
|
|
va_list args;
|
|
|
|
va_start(args, type);
|
|
ret = heim_config_vget(context, c, type, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
|
|
const void *
|
|
heim_config_vget(heim_context context,
|
|
const heim_config_section *c,
|
|
int type,
|
|
va_list args)
|
|
{
|
|
const heim_config_binding *foo = NULL;
|
|
|
|
return heim_config_vget_next(context, c, &foo, type, args);
|
|
}
|
|
|
|
/**
|
|
* Get a list of configuration binding list for more processing
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return NULL if configuration list is not found, a list otherwise
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const heim_config_binding *
|
|
heim_config_get_list(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
const heim_config_binding *ret;
|
|
va_list args;
|
|
|
|
va_start(args, c);
|
|
ret = heim_config_vget_list(context, c, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Get a list of configuration binding list for more processing
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return NULL if configuration list is not found, a list otherwise
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const heim_config_binding *
|
|
heim_config_vget_list(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
return heim_config_vget(context, c, heim_config_list, args);
|
|
}
|
|
|
|
/**
|
|
* Returns a "const char *" to a string in the configuration database.
|
|
* The string may not be valid after a reload of the configuration
|
|
* database so a caller should make a local copy if it needs to keep
|
|
* the string.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return NULL if configuration string not found, a string otherwise
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const char *
|
|
heim_config_get_string(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
const char *ret;
|
|
va_list args;
|
|
|
|
va_start(args, c);
|
|
ret = heim_config_vget_string(context, c, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Like heim_config_get_string(), but uses a va_list instead of ...
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return NULL if configuration string not found, a string otherwise
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const char *
|
|
heim_config_vget_string(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
return heim_config_vget(context, c, heim_config_string, args);
|
|
}
|
|
|
|
/**
|
|
* Like heim_config_vget_string(), but instead of returning NULL,
|
|
* instead return a default value.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return a configuration string
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const char *
|
|
heim_config_vget_string_default(heim_context context,
|
|
const heim_config_section *c,
|
|
const char *def_value,
|
|
va_list args)
|
|
{
|
|
const char *ret;
|
|
|
|
ret = heim_config_vget_string(context, c, args);
|
|
if (ret == NULL)
|
|
ret = def_value;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Like heim_config_get_string(), but instead of returning NULL,
|
|
* instead return a default value.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return a configuration string
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
const char *
|
|
heim_config_get_string_default(heim_context context,
|
|
const heim_config_section *c,
|
|
const char *def_value,
|
|
...)
|
|
{
|
|
const char *ret;
|
|
va_list args;
|
|
|
|
va_start(args, def_value);
|
|
ret = heim_config_vget_string_default (context, c, def_value, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
static char *
|
|
next_component_string(char * begin, const char * delims, char **state)
|
|
{
|
|
char * end;
|
|
|
|
if (begin == NULL)
|
|
begin = *state;
|
|
|
|
if (*begin == '\0')
|
|
return NULL;
|
|
|
|
end = begin;
|
|
while (*end == '"') {
|
|
char * t = strchr(end + 1, '"');
|
|
|
|
if (t)
|
|
end = ++t;
|
|
else
|
|
end += strlen(end);
|
|
}
|
|
|
|
if (*end != '\0') {
|
|
size_t pos;
|
|
|
|
pos = strcspn(end, delims);
|
|
end = end + pos;
|
|
}
|
|
|
|
if (*end != '\0') {
|
|
*end = '\0';
|
|
*state = end + 1;
|
|
if (*begin == '"' && *(end - 1) == '"' && begin + 1 < end) {
|
|
begin++; *(end - 1) = '\0';
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
*state = end;
|
|
if (*begin == '"' && *(end - 1) == '"' && begin + 1 < end) {
|
|
begin++; *(end - 1) = '\0';
|
|
}
|
|
return begin;
|
|
}
|
|
|
|
/**
|
|
* Get a list of configuration strings, free the result with
|
|
* heim_config_free_strings().
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
char **
|
|
heim_config_vget_strings(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
char **strings = NULL;
|
|
size_t nstr = 0;
|
|
const heim_config_binding *b = NULL;
|
|
const char *p;
|
|
|
|
while((p = heim_config_vget_next(context, c, &b,
|
|
heim_config_string, args))) {
|
|
char *tmp = strdup(p);
|
|
char *pos = NULL;
|
|
char *s;
|
|
if(tmp == NULL)
|
|
goto cleanup;
|
|
s = next_component_string(tmp, " \t", &pos);
|
|
while(s){
|
|
char **tmp2 = realloc(strings, (nstr + 1) * sizeof(*strings));
|
|
if(tmp2 == NULL) {
|
|
free(tmp);
|
|
goto cleanup;
|
|
}
|
|
strings = tmp2;
|
|
strings[nstr] = strdup(s);
|
|
nstr++;
|
|
if(strings[nstr-1] == NULL) {
|
|
free(tmp);
|
|
goto cleanup;
|
|
}
|
|
s = next_component_string(NULL, " \t", &pos);
|
|
}
|
|
free(tmp);
|
|
}
|
|
if(nstr){
|
|
char **tmp = realloc(strings, (nstr + 1) * sizeof(*strings));
|
|
if(tmp == NULL)
|
|
goto cleanup;
|
|
strings = tmp;
|
|
strings[nstr] = NULL;
|
|
}
|
|
return strings;
|
|
cleanup:
|
|
while(nstr--)
|
|
free(strings[nstr]);
|
|
free(strings);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/**
|
|
* Get a list of configuration strings, free the result with
|
|
* heim_config_free_strings().
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
char **
|
|
heim_config_get_strings(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
char **ret;
|
|
va_start(ap, c);
|
|
ret = heim_config_vget_strings(context, c, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Free the resulting strings from heim_config-get_strings() and
|
|
* heim_config_vget_strings().
|
|
*
|
|
* @param strings strings to free
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
void
|
|
heim_config_free_strings(char **strings)
|
|
{
|
|
char **s = strings;
|
|
|
|
while (s && *s) {
|
|
free(*s);
|
|
s++;
|
|
}
|
|
free(strings);
|
|
}
|
|
|
|
/**
|
|
* Like heim_config_get_bool_default() but with a va_list list of
|
|
* configuration selection.
|
|
*
|
|
* Configuration value to a boolean value, where yes/true and any
|
|
* non-zero number means TRUE and other value is FALSE.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
int
|
|
heim_config_vget_bool_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
va_list args)
|
|
{
|
|
const char *str;
|
|
str = heim_config_vget_string(context, c, args);
|
|
if (str == NULL)
|
|
return def_value;
|
|
return !!(strcasecmp(str, "yes") == 0 ||
|
|
strcasecmp(str, "true") == 0 ||
|
|
atoi(str));
|
|
}
|
|
|
|
/**
|
|
* heim_config_get_bool() will convert the configuration
|
|
* option value to a boolean value, where yes/true and any non-zero
|
|
* number means TRUE and other value is FALSE.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
int
|
|
heim_config_vget_bool(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
return heim_config_vget_bool_default(context, c, 0, args);
|
|
}
|
|
|
|
/**
|
|
* heim_config_get_bool_default() will convert the configuration
|
|
* option value to a boolean value, where yes/true and any non-zero
|
|
* number means TRUE and other value is FALSE.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
int
|
|
heim_config_get_bool_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
|
|
va_start(ap, def_value);
|
|
ret = heim_config_vget_bool_default(context, c, def_value, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Like heim_config_get_bool() but with a va_list list of
|
|
* configuration selection.
|
|
*
|
|
* Configuration value to a boolean value, where yes/true and any
|
|
* non-zero number means TRUE and other value is FALSE.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return TRUE or FALSE
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
int
|
|
heim_config_get_bool(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
va_start(ap, c);
|
|
ret = heim_config_vget_bool (context, c, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Get the time from the configuration file using a relative time.
|
|
*
|
|
* Like heim_config_get_time_default() but with a va_list list of
|
|
* configuration selection.
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return parsed the time (or def_value on parse error)
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
time_t
|
|
heim_config_vget_time_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
va_list args)
|
|
{
|
|
const char *str;
|
|
time_t t = -1;
|
|
|
|
if ((str = heim_config_vget_string(context, c, args)))
|
|
t = parse_time(str, "s");
|
|
return t != -1 ? t : def_value;
|
|
}
|
|
|
|
/**
|
|
* Get the time from the configuration file using a relative time, for example: 1h30s
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param args a va_list of arguments
|
|
*
|
|
* @return parsed the time or -1 on error
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
time_t
|
|
heim_config_vget_time(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
return heim_config_vget_time_default(context, c, -1, args);
|
|
}
|
|
|
|
/**
|
|
* Get the time from the configuration file using a relative time, for example: 1h30s
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param def_value the default value to return if no configuration
|
|
* found in the database.
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return parsed the time (or def_value on parse error)
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
time_t
|
|
heim_config_get_time_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
time_t ret;
|
|
|
|
va_start(ap, def_value);
|
|
ret = heim_config_vget_time_default(context, c, def_value, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Get the time from the configuration file using a relative time, for example: 1h30s
|
|
*
|
|
* @param context A Kerberos 5 context.
|
|
* @param c a configuration section, or NULL to use the section from context
|
|
* @param ... a list of names, terminated with NULL.
|
|
*
|
|
* @return parsed the time or -1 on error
|
|
*
|
|
* @ingroup heim_support
|
|
*/
|
|
|
|
time_t
|
|
heim_config_get_time(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
va_start(ap, c);
|
|
ret = heim_config_vget_time(context, c, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int
|
|
heim_config_vget_int_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
va_list args)
|
|
{
|
|
const char *str;
|
|
str = heim_config_vget_string (context, c, args);
|
|
if(str == NULL)
|
|
return def_value;
|
|
else {
|
|
char *endptr;
|
|
long l;
|
|
l = strtol(str, &endptr, 0);
|
|
if (endptr == str)
|
|
return def_value;
|
|
else
|
|
return l;
|
|
}
|
|
}
|
|
|
|
int
|
|
heim_config_vget_int(heim_context context,
|
|
const heim_config_section *c,
|
|
va_list args)
|
|
{
|
|
return heim_config_vget_int_default(context, c, -1, args);
|
|
}
|
|
|
|
int
|
|
heim_config_get_int_default(heim_context context,
|
|
const heim_config_section *c,
|
|
int def_value,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
|
|
va_start(ap, def_value);
|
|
ret = heim_config_vget_int_default(context, c, def_value, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
heim_config_get_int(heim_context context,
|
|
const heim_config_section *c,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
va_start(ap, c);
|
|
ret = heim_config_vget_int (context, c, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
#ifndef HEIMDAL_SMALLER
|
|
heim_error_code
|
|
heim_config_parse_string_multi(heim_context context,
|
|
const char *string,
|
|
heim_config_section **res)
|
|
{
|
|
const char *str;
|
|
unsigned lineno = 0;
|
|
heim_error_code ret;
|
|
struct fileptr f;
|
|
|
|
f.context = context;
|
|
f.f = NULL;
|
|
f.s = string;
|
|
|
|
ret = heim_config_parse_debug(&f, res, &lineno, &str);
|
|
if (ret) {
|
|
if (ret != HEIM_ERR_CONFIG_BADFORMAT) {
|
|
ret = HEIM_ERR_CONFIG_BADFORMAT;
|
|
heim_set_error_message(context, ret, "%s:%u: %s",
|
|
"<constant>", lineno, str);
|
|
}
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|