/*-
* Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/cdefs.h>
#include <sys/time.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "debug.h"
#include "log.h"
#include "parser.h"
static void enable_cache(struct configuration *,const char *, int);
static struct configuration_entry *find_create_entry(struct configuration *,
const char *);
static int get_number(const char *, int, int);
static enum cache_policy_t get_policy(const char *);
static int get_yesno(const char *);
static int check_cachename(const char *);
static void check_files(struct configuration *, const char *, int);
static void set_keep_hot_count(struct configuration *, const char *, int);
static void set_negative_policy(struct configuration *, const char *,
enum cache_policy_t);
static void set_negative_time_to_live(struct configuration *,
const char *, int);
static void set_positive_policy(struct configuration *, const char *,
enum cache_policy_t);
static void set_perform_actual_lookups(struct configuration *, const char *,
int);
static void set_positive_time_to_live(struct configuration *,
const char *, int);
static void set_suggested_size(struct configuration *, const char *,
int size);
static void set_threads_num(struct configuration *, int);
static int strbreak(char *, char **, int);
static int
strbreak(char *str, char **fields, int fields_size)
{
char *c = str;
int i, num;
TRACE_IN(strbreak);
num = 0;
for (i = 0;
((*fields =
strsep(i < fields_size ? &c : NULL, "\n\t ")) != NULL);
++i)
if ((*(*fields)) != '\0') {
++fields;
++num;
}
TRACE_OUT(strbreak);
return (num);
}
/*
* Tries to find the configuration entry with the specified name. If search
* fails, the new entry with the default parameters will be created.
*/
static struct configuration_entry *
find_create_entry(struct configuration *config,
const char *entry_name)
{
struct configuration_entry *entry = NULL;
int res;
TRACE_IN(find_create_entry);
entry = configuration_find_entry(config, entry_name);
if (entry == NULL) {
entry = create_def_configuration_entry(entry_name);
assert( entry != NULL);
res = add_configuration_entry(config, entry);
assert(res == 0);
}
TRACE_OUT(find_create_entry);
return (entry);
}
/*
* The vast majority of the functions below corresponds to the particular
* keywords in the configuration file.
*/
static void
enable_cache(struct configuration *config, const char *entry_name, int flag)
{
struct configuration_entry *entry;
TRACE_IN(enable_cache);
entry = find_create_entry(config, entry_name);
entry->enabled = flag;
TRACE_OUT(enable_cache);
}
static void
set_positive_time_to_live(struct configuration *config,
const char *entry_name, int ttl)
{
struct configuration_entry *entry;
struct timeval lifetime;
TRACE_IN(set_positive_time_to_live);
assert(ttl >= 0);
assert(entry_name != NULL);
memset(&lifetime, 0, sizeof(struct timeval));
lifetime.tv_sec = ttl;
entry = find_create_entry(config, entry_name);
memcpy(&entry->positive_cache_params.max_lifetime,
&lifetime, sizeof(struct timeval));
memcpy(&entry->mp_cache_params.max_lifetime,
&lifetime, sizeof(struct timeval));
TRACE_OUT(set_positive_time_to_live);
}
static void
set_negative_time_to_live(struct configuration *config,
const char *entry_name, int nttl)
{
struct configuration_entry *entry;
struct timeval lifetime;
TRACE_IN(set_negative_time_to_live);
assert(nttl > 0);
assert(entry_name != NULL);
memset(&lifetime, 0, sizeof(struct timeval));
lifetime.tv_sec = nttl;
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
memcpy(&entry->negative_cache_params.max_lifetime,
&lifetime, sizeof(struct timeval));
TRACE_OUT(set_negative_time_to_live);
}
static void
set_positive_confidence_threshold(struct configuration *config,
const char *entry_name, int conf_thresh)
{
struct configuration_entry *entry;
TRACE_IN(set_positive_conf_thresh);
assert(conf_thresh > 0);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->positive_cache_params.confidence_threshold = conf_thresh;
TRACE_OUT(set_positive_conf_thresh);
}
static void
set_negative_confidence_threshold(struct configuration *config,
const char *entry_name, int conf_thresh)
{
struct configuration_entry *entry;
TRACE_IN(set_negative_conf_thresh);
assert(conf_thresh > 0);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->negative_cache_params.confidence_threshold = conf_thresh;
TRACE_OUT(set_negative_conf_thresh);
}
/*
* Hot count is actually the elements size limit.
*/
static void
set_keep_hot_count(struct configuration *config,
const char *entry_name, int count)
{
struct configuration_entry *entry;
TRACE_IN(set_keep_hot_count);
assert(count >= 0);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->positive_cache_params.max_elemsize = count;
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->negative_cache_params.max_elemsize = count;
TRACE_OUT(set_keep_hot_count);
}
static void
set_positive_policy(struct configuration *config,
const char *entry_name, enum cache_policy_t policy)
{
struct configuration_entry *entry;
TRACE_IN(set_positive_policy);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->positive_cache_params.policy = policy;
TRACE_OUT(set_positive_policy);
}
static void
set_negative_policy(struct configuration *config,
const char *entry_name, enum cache_policy_t policy)
{
struct configuration_entry *entry;
TRACE_IN(set_negative_policy);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->negative_cache_params.policy = policy;
TRACE_OUT(set_negative_policy);
}
static void
set_perform_actual_lookups(struct configuration *config,
const char *entry_name, int flag)
{
struct configuration_entry *entry;
TRACE_IN(set_perform_actual_lookups);
assert(entry_name != NULL);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->perform_actual_lookups = flag;
TRACE_OUT(set_perform_actual_lookups);
}
static void
set_suggested_size(struct configuration *config,
const char *entry_name, int size)
{
struct configuration_entry *entry;
TRACE_IN(set_suggested_size);
assert(config != NULL);
assert(entry_name != NULL);
assert(size > 0);
entry = find_create_entry(config, entry_name);
assert(entry != NULL);
entry->positive_cache_params.cache_entries_size = size;
entry->negative_cache_params.cache_entries_size = size;
TRACE_OUT(set_suggested_size);
}
static void
check_files(struct configuration *config, const char *entry_name, int flag)
{
TRACE_IN(check_files);
assert(entry_name != NULL);
TRACE_OUT(check_files);
}
static int
get_yesno(const char *str)
{
if (strcmp(str, "yes") == 0)
return (1);
else if (strcmp(str, "no") == 0)
return (0);
else
return (-1);
}
static int
get_number(const char *str, int low, int max)
{
char *end = NULL;
int res = 0;
if (str[0] == '\0')
return (-1);
res = strtol(str, &end, 10);
if (*end != '\0')
return (-1);
else
if (((res >= low) || (low == -1)) &&
((res <= max) || (max == -1)))
return (res);
else
return (-2);
}
static enum cache_policy_t
get_policy(const char *str)
{
if (strcmp(str, "fifo") == 0)
return (CPT_FIFO);
else if (strcmp(str, "lru") == 0)
return (CPT_LRU);
else if (strcmp(str, "lfu") == 0)
return (CPT_LFU);
return (-1);
}
static int
check_cachename(const char *str)
{
assert(str != NULL);
return ((strlen(str) > 0) ? 0 : -1);
}
static void
set_threads_num(struct configuration *config, int value)
{
assert(config != NULL);
config->threads_num = value;
}
/*
* The main configuration routine. Its implementation is hugely inspired by the
* the same routine implementation in Solaris NSCD.
*/
int
parse_config_file(struct configuration *config,
const char *fname, char const **error_str, int *error_line)
{
FILE *fin;
char buffer[255];
char *fields[128];
int field_count, line_num, value;
int res;
int invalid_value;
TRACE_IN(parse_config_file);
assert(config != NULL);
assert(fname != NULL);
fin = fopen(fname, "r");
if (fin == NULL) {
TRACE_OUT(parse_config_file);
return (-1);
}
res = 0;
line_num = 0;
invalid_value = 0;
memset(buffer, 0, sizeof(buffer));
while ((res == 0) && (fgets(buffer, sizeof(buffer) - 1, fin) != NULL)) {
field_count = strbreak(buffer, fields, sizeof(fields));
++line_num;
if (field_count == 0)
continue;
switch (fields[0][0]) {
case '#':
case '\0':
continue;
case 'e':
if ((field_count == 3) &&
(strcmp(fields[0], "enable-cache") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_yesno(fields[2])) != -1)) {
enable_cache(config, fields[1], value);
continue;
}
break;
case 'd':
if ((field_count == 2) &&
(strcmp(fields[0], "debug-level") == 0) &&
((value = get_number(fields[1], 0, 10)) != -1)) {
continue;
}
break;
case 'p':
if ((field_count == 3) &&
(strcmp(fields[0], "positive-time-to-live") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_number(fields[2], 0, -1)) != -1)) {
if (value <= 0) {
invalid_value = 1;
break;
}
set_positive_time_to_live(config,
fields[1], value);
continue;
} else if ((field_count == 3) &&
(strcmp(fields[0], "positive-confidence-threshold") == 0) &&
((value = get_number(fields[2], 1, -1)) != -1)) {
if (value <= 0) {
invalid_value = 1;
break;
}
set_positive_confidence_threshold(config,
fields[1], value);
continue;
} else if ((field_count == 3) &&
(strcmp(fields[0], "positive-policy") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_policy(fields[2])) != -1)) {
set_positive_policy(config, fields[1], value);
continue;
} else if ((field_count == 3) &&
(strcmp(fields[0], "perform-actual-lookups") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_yesno(fields[2])) != -1)) {
set_perform_actual_lookups(config, fields[1],
value);
continue;
}
break;
case 'n':
if ((field_count == 3) &&
(strcmp(fields[0], "negative-time-to-live") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_number(fields[2], 0, -1)) != -1)) {
if (value <= 0) {
invalid_value = 1;
break;
}
set_negative_time_to_live(config,
fields[1], value);
continue;
} else if ((field_count == 3) &&
(strcmp(fields[0], "negative-confidence-threshold") == 0) &&
((value = get_number(fields[2], 1, -1)) != -1)) {
if (value <= 0) {
invalid_value = 1;
break;
}
set_negative_confidence_threshold(config,
fields[1], value);
continue;
} else if ((field_count == 3) &&
(strcmp(fields[0], "negative-policy") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_policy(fields[2])) != -1)) {
set_negative_policy(config,
fields[1], value);
continue;
}
break;
case 's':
if ((field_count == 3) &&
(strcmp(fields[0], "suggested-size") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_number(fields[2], 1, -1)) != -1)) {
if (value <= 0) {
invalid_value = 1;
break;
}
set_suggested_size(config, fields[1], value);
continue;
}
break;
case 't':
if ((field_count == 2) &&
(strcmp(fields[0], "threads") == 0) &&
((value = get_number(fields[1], 1, -1)) != -1)) {
set_threads_num(config, value);
continue;
}
break;
case 'k':
if ((field_count == 3) &&
(strcmp(fields[0], "keep-hot-count") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_number(fields[2], 0, -1)) != -1)) {
if (value < 0) {
invalid_value = 1;
break;
}
set_keep_hot_count(config,
fields[1], value);
continue;
}
break;
case 'c':
if ((field_count == 3) &&
(strcmp(fields[0], "check-files") == 0) &&
(check_cachename(fields[1]) == 0) &&
((value = get_yesno(fields[2])) != -1)) {
check_files(config,
fields[1], value);
continue;
}
break;
default:
break;
}
if (invalid_value != 0) {
LOG_ERR_2("Invalid value for parameter",
"error in file %s on line %d",
fname, line_num);
*error_str = "invalid value";
} else {
LOG_ERR_2("config file parser", "error in file "
"%s on line %d", fname, line_num);
*error_str = "syntax error";
}
*error_line = line_num;
res = -1;
}
fclose(fin);
TRACE_OUT(parse_config_file);
return (res);
}
plain