From 94dc650256935aa0c5cfff7675e535c54bb8c9b7 Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Fri, 27 Jan 2006 00:45:54 +0000 Subject: Move rrdbot code into right project. --- daemon/config.c | 575 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 575 insertions(+) create mode 100644 daemon/config.c (limited to 'daemon/config.c') diff --git a/daemon/config.c b/daemon/config.c new file mode 100644 index 0000000..ca64514 --- /dev/null +++ b/daemon/config.c @@ -0,0 +1,575 @@ +/* + * Copyright (c) 2005, Nate Nielsen + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * 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. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 + * COPYRIGHT OWNER 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. + * + * + * CONTRIBUTORS + * Nate Nielsen + * + */ + +#include "usuals.h" +#include +#include +#include +#include + +#include "stringx.h" +#include "rrdbotd.h" + +/* TODO: Put file names in all the parsing error messages */ + +/* + * These routines parse the configuration files and setup the in memory + * data structures. They're mostly run before becoming a daemon, and just + * exit on error. + */ + +typedef struct _config_ctx +{ + const char* confname; + char* configmem; + uint interval; + uint timeout; + rb_item* items; +} +config_ctx; + +/* ----------------------------------------------------------------------------- + * STRINGS + */ + +#define CONFIG_POLL "poll" +#define CONFIG_INTERVAL "interval" +#define CONFIG_FIELD "field." +#define CONFIG_SNMP "snmp" + +#define FIELD_VALID "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-0123456789." + +/* ----------------------------------------------------------------------------- + * CONFIG LOADING + */ + +static rb_item* +sort_items_by_host(rb_item *item) +{ + rb_item *sort = NULL; + rb_item *cur; + rb_item *it; + + while(item) + { + cur = item; + item = item->next; + cur->next = NULL; + + /* First item */ + if(!sort) + { + sort = cur; + continue; + } + + /* Before first item */ + else if(cur->host <= sort->host) + { + cur->next = sort; + sort = cur; + continue; + } + + for(it = sort; it->next; it = it->next) + { + if(cur->host <= sort->next->host) + break; + } + + ASSERT(it); + cur->next = it->next; + it->next = cur; + } + + return sort; +} + +static void +config_done(config_ctx* ctx) +{ + char key[MAXPATHLEN]; + rb_item* it; + rb_poller* poll; + char *t; + + /* No polling specified */ + if(!ctx->items) + return; + + /* Make sure we found an interval */ + if(ctx->interval == 0) + errx(2, "no interval specified in config file: %s", ctx->confname); + + if(ctx->timeout == 0) + ctx->timeout = g_state.timeout; + + /* And a nice key for lookups */ + snprintf(key, sizeof(key), "%d-%d:%s/%s.rrd", ctx->timeout, + ctx->interval, g_state.rrddir, ctx->confname); + key[sizeof(key) - 1] = 0; + + /* See if we have one of these pollers already */ + poll = (rb_poller*)hsh_get(g_state.poll_by_key, key, -1); + if(!poll) + { + poll = (rb_poller*)calloc(1, sizeof(*poll)); + + if(!poll || !hsh_set(g_state.poll_by_key, key, -1, poll)) + errx(1, "out of memory"); + + strcpy(poll->key, key); + t = strchr(poll->key, ':'); + ASSERT(t); + poll->rrdname = t + 1; + + poll->interval = ctx->interval * 1000; + poll->timeout = ctx->timeout * 1000; + + /* Add it to the main lists */ + poll->next = g_state.polls; + g_state.polls = poll; + } + + /* Get the last item and add to the list */ + for(it = ctx->items; it->next; it = it->next) + it->poller = poll; + + ASSERT(it); + it->poller = poll; + + /* Add the items to this poller */ + it->next = poll->items; + poll->items = sort_items_by_host(ctx->items); + + /* + * This remains allocated for the life of the program as + * All the configuration strings are in this memory. + * This allows all the users of these strings not to worry + * about reallocating or freeing them + */ + rb_atexit(free, ctx->configmem); + ctx->configmem = NULL; + + /* Clear current config and get ready for next */ + ctx->items = NULL; + ctx->interval = 0; + + +} + +static void +parse_uri(char *uri, char** scheme, char** host, + char** user, char** path, config_ctx* ctx) +{ + /* Copy only for error messages as we mess with original */ + char* copy = strdup(uri); + char* t; + + *host = NULL; + *path = NULL; + *user = NULL; + + *scheme = strsep(&uri, ":"); + if(uri == NULL) + errx(2, "invalid poll uri (scheme invalid): %s", copy); + + if((uri[0] != '/' && uri[1] != '/')) + errx(2, "invalid poll uri (scheme invalid): %s", copy); + + uri += 2; + *host = strsep(&uri, "/"); + if(*host[0]) + { + /* Parse the user name out from the host */ + t = strchr(*host, '@'); + if(t) + { + *t = 0; + *user = *host; + *host = t + 1; + } + } + + if(!*host[0]) + errx(2, "invalid poll uri (no hostname found): %s", copy); + + if(!uri || !uri[0] || !uri[1]) + errx(2, "invalid poll uri (no pathname found): %s", copy); + + *path = uri; + + /* This copy only for error messages */ + free(copy); +} + +static rb_item* +parse_item(const char* field, char* uri, config_ctx *ctx) +{ + rb_item *ritem; + rb_host *rhost; + + char* host; + char* user; + char* scheme; + char* path; + + /* Parse the SNMP URI */ + parse_uri(uri, &scheme, &host, &user, &path, ctx); + ASSERT(scheme && host && path); + + /* TODO: SNMP version support */ + + /* Currently we only support SNMP pollers */ + if(strcmp(scheme, CONFIG_SNMP) != 0) + errx(2, "invalid poll scheme: %s", scheme); + + /* TODO: THis code assumes all hosts have the same community + the lookups below won't work wehn host/community is different */ + + /* See if we can find an associated host */ + rhost = (rb_host*)hsh_get(g_state.host_by_name, host, -1); + if(!rhost) + { + /* Make a new one if necessary */ + rhost = (rb_host*)calloc(1, sizeof(*rhost)); + + if(!rhost || !hsh_set(g_state.host_by_name, host, -1, rhost)) + errx(1, "out of memory"); + + /* TODO: Version support */ + rhost->version = 1; + rhost->name = host; + rhost->community = user ? user : "public"; + + /* TODO: Eventually resolving should be in a separate thread, + and done regularly */ + if(sock_any_pton(host, &(rhost->address), + SANY_OPT_DEFPORT(161) | SANY_OPT_DEFLOCAL) == -1) + { + rb_message(LOG_WARNING, "couldn't resolve host address (ignoring): %s", host); + free(rhost); + return; + } + + /* And add it to the list */ + rhost->next = g_state.hosts; + g_state.hosts = rhost; + } + + /* Make a new item */ + ritem = calloc(1, sizeof(*ritem)); + if(!ritem) + errx(1, "out of memory"); + + ritem->rrdfield = field; + ritem->host = rhost; + ritem->poller = NULL; /* Set later in config_done */ + ritem->req = NULL; + ritem->value = RB_UNKNOWN; + + /* And parse the OID */ + if(rb_parse_mib(path, &(ritem->snmpfield)) == -1) + errx(2, "invalid OID: %s", path + 1); + + /* And add it to the list */ + ritem->next = ctx->items; + ctx->items = ritem; +} + +static void +config_value(const char* header, const char* name, char* value, + config_ctx* ctx) +{ + if(strcmp(header, "poll") != 0) + return; + + if(strcmp(name, CONFIG_INTERVAL) == 0) + { + char* t; + int i; + + if(ctx->interval > 0) + errx(2, CONFIG_INTERVAL " specified twice: %s", value); + + i = strtol(value, &t, 10); + if(i < 1) + err(2, CONFIG_INTERVAL " must be a positive number: %s", value); + + ctx->interval = (uint32_t)i; + } + + /* If it starts with "field." */ + if(strncmp(name, CONFIG_FIELD, KL(CONFIG_FIELD)) == 0) + { + rb_poller* poll; + const char* field; + const char* t; + + /* Check the name */ + field = name + KL(CONFIG_FIELD); + t = field + strspn(field, FIELD_VALID); + if(*t) + err(2, "the '%s' field name must only contain characters, digits, underscore and dash", field); + + /* Parse out the field */ + parse_item(field, value, ctx); + } +} + +/* ----------------------------------------------------------------------------- + * CONFIG FILES + */ + +static char* +read_config_file(const char* configfile) +{ + char* config = NULL; + FILE* f = NULL; + long len; + + ASSERT(configfile); + + f = fopen(configfile, "r"); + if(f == NULL) + err(1, "couldn't open config file: %s", configfile); + + /* Figure out size */ + if(fseek(f, 0, SEEK_END) == -1 || (len = ftell(f)) == -1 || fseek(f, 0, SEEK_SET) == -1) + err(1, "couldn't seek config file: %s", configfile); + + if((config = (char*)malloc(len + 2)) == NULL) + errx(1, "out of memory"); + + /* And read in one block */ + if(fread(config, 1, len, f) != len) + err(1, "couldn't read config file: %s", configfile); + + fclose(f); + + /* Null terminate the data */ + config[len] = '\n'; + config[len + 1] = 0; + + /* Remove nasty dos line endings */ + remove_cr(config); + + rb_messagex(LOG_DEBUG, "read config file: %s", configfile); + return config; +} + +static void +parse_config_file(const char* configfile, config_ctx *ctx) +{ + char* name = NULL; + char* value = NULL; + char* config; + char* next; + char* header; + char* p; + char* t; + int pos; + + config = read_config_file(configfile); + ctx->configmem = config; + next = config; + + /* Go through lines and process them */ + while((t = strchr(next, '\n')) != NULL) + { + *t = 0; + p = next; /* Do this before cleaning below */ + next = t + 1; + + t = trim_start(p); + + /* Continuation line (had spaces at start) */ + if(p < t && *t) + { + if(!value) + errx(2, "invalid continuation in config: %s", p); + + /* Calculate the end of the current value */ + t = value + strlen(value); + ASSERT(t < p); + + /* Continuations are separated by spaces */ + *t = ' '; + t++; + + continue; + } + + // No continuation hand off value if necessary + if(name && value) + { + rb_messagex(LOG_DEBUG, "parsed configuration value: [%s] %s = %s", header, name, value); + config_value(header, name, value, ctx); + } + + name = NULL; + value = NULL; + + /* Empty lines / comments at start / comments without continuation */ + if(!*t || *p == '#') + continue; + + /* A header */ + if(*p == '[') + { + t = p + strcspn(p, "]"); + if(!*t || t == p + 1) + errx(2, "invalid config header: %s", p); + + *t = 0; + header = trim_space(p + 1); + continue; + } + + /* Look for the break between name = value on the same line */ + t = p + strcspn(p, ":="); + if(!*t) + errx(2, "invalid config line: %s", p); + + /* Null terminate and split value part */ + *t = 0; + t++; + + name = trim_space(p); + value = trim_space(t); + } + + if(name && value) + { + rb_messagex(LOG_DEBUG, "parsed configuration value: [%s] %s = %s", header, name, value); + config_value(header, name, value, ctx); + } + + config_done(ctx); + + /* If nobody claimed this memory then we don't need to keep it around */ + if(ctx->configmem) + free(ctx->configmem); + ctx->configmem = NULL; +} + +void +rb_config_parse() +{ + char configfile[MAXPATHLEN]; + struct dirent* dire; + config_ctx ctx; + DIR* dir; + + /* Setup the hash tables properly */ + g_state.poll_by_key = hsh_create(); + g_state.host_by_name = hsh_create(); + + dir = opendir(g_state.confdir); + if(!dir) + err("couldn't read config directory: %s", g_state.confdir); + + while((dire = readdir(dir)) != NULL) + { + if(dire->d_type != DT_REG && dire->d_type != DT_LNK) + continue; + + /* Build a happy path name */ + snprintf(configfile, MAXPATHLEN, "%s/%s", g_state.confdir, dire->d_name); + configfile[MAXPATHLEN - 1] = 0; + + memset(&ctx, 0, sizeof(ctx)); + ctx.confname = dire->d_name; + + parse_config_file(configfile, &ctx); + } + + closedir(dir); +} + +/* ----------------------------------------------------------------------------- + * FREEING MEMORY + */ + +static void +free_items(rb_item* item) +{ + rb_item* next; + for(; item; item = next) + { + next = item->next; + free(item); + } +} + +static void +free_hosts(rb_host* host) +{ + rb_host* next; + for(; host; host = next) + { + next = host->next; + free(host); + } +} + +static void +free_pollers(rb_poller* poll) +{ + rb_poller* next; + for(; poll; poll = next) + { + free_items(poll->items); + + next = poll->next; + free(poll); + } + +} + +void +rb_config_free() +{ + hsh_free(g_state.poll_by_key); + hsh_free(g_state.host_by_name); + + free_hosts(g_state.hosts); + + /* Note that rb_item's are owned by pollers */ + free_pollers(g_state.polls); +} -- cgit v1.2.3