diff options
Diffstat (limited to 'src/pmieconf/rules.c')
| -rw-r--r-- | src/pmieconf/rules.c | 2335 |
1 files changed, 2335 insertions, 0 deletions
diff --git a/src/pmieconf/rules.c b/src/pmieconf/rules.c new file mode 100644 index 0000000..cb0c9a0 --- /dev/null +++ b/src/pmieconf/rules.c @@ -0,0 +1,2335 @@ +/* + * rules.c - rule description parsing routines (rules & pmie config) + * + * Copyright (c) 1998-2002 Silicon Graphics, Inc. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <time.h> +#include <ctype.h> +#include <string.h> +#include <dirent.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/param.h> +#include <sys/types.h> +#include "pmapi.h" +#include "impl.h" +#include "rules.h" +#include "stats.h" + +#define SEP __pmPathSeparator() + + +#define PMIE_FILE "pmieconf-pmie" +#define PMIE_VERSION "1" /* local configurations file format version */ +#define RULES_FILE "pmieconf-rules" +#define RULES_VERSION "1" /* rule description file format version */ + +#define START_STRING \ + "// --- START GENERATED SECTION (do not change this section) ---\n" +#define END_STRING \ + "// --- END GENERATED SECTION (changes below will be preserved) ---\n" +#define TOKEN_LENGTH 2048 /* max length of input token, incl string */ +#define LINE_LENGTH 4096 + +#if !defined(sgi) +#define PROC_DIR "/proc" +#else +#define PROC_DIR "/proc/pinfo" +#endif + +char errmsg[512]; /* error message buffer */ +char rulepath[MAXPATHLEN+1]; /* root of rules files */ +char pmiefile[MAXPATHLEN+1]; /* pmie configuration file */ +char token[TOKEN_LENGTH+1]; + +rule_t *rulelist; /* global list of rules */ +unsigned int rulecount; /* # rule list elements */ +rule_t *globals; /* list of atoms with global scope */ + +#define GLOBAL_LEN 7 +static char global_name[] = "global"; /* GLOBAL_LEN chars long */ +static char global_data[] = "generic variables applied to all rules"; +static char global_help[] = \ + "The global variables are used by all rules, but their values can be\n" + "overridden at the level of an individual rule or group of rules."; +static char yes[] = "yes"; +static char no[] = "no"; + +static char *filename; /* file currently being parsed */ +static unsigned int linenum; /* input line number */ + +symbol_t types[] = { + { TYPE_STRING, "string" }, /* predicate data types */ + { TYPE_DOUBLE, "double" }, + { TYPE_INTEGER, "integer" }, + { TYPE_UNSIGNED, "unsigned" }, + { TYPE_PERCENT, "percent" }, + { TYPE_HOSTLIST, "hostlist" }, + { TYPE_INSTLIST, "instlist" }, + { TYPE_PRINT, "print" }, /* action types */ + { TYPE_SHELL, "shell" }, + { TYPE_ALARM, "alarm" }, + { TYPE_SYSLOG, "syslog" }, + { TYPE_RULE, "rule" }, /* fundamental type */ +}; +int numtypes = (sizeof(types)/sizeof(types[0])); + +symbol_t attribs[] = { + { ATTRIB_HELP, "help" }, + { ATTRIB_MODIFY, "modify" }, + { ATTRIB_ENABLED, "enabled" }, + { ATTRIB_DISPLAY, "display" }, + { ATTRIB_DEFAULT, "default" }, + { ATTRIB_DEFAULT, "summary" }, /* alias for "default" */ + { ATTRIB_VERSION, "version" }, /* applies to rules only */ + { ATTRIB_PREDICATE, "predicate" }, /* applies to rules only */ + { ATTRIB_ENUMERATE, "enumerate" }, /* applies to rules only */ +}; +int numattribs = (sizeof(attribs)/sizeof(attribs[0])); + +/* pmiefile variables */ +static int gotpath; /* state flag - has realpath been run */ +static char *save_area; /* holds text to restore on write */ +static int sa_size; /* current size of save area */ +static int sa_mark = 1; /* number used chars in save area, 1 for \0 */ +static dep_t *dlist; /* list of depreciated rules */ +static int dcount; /* number of entries in dlist */ +static char drulestring[] = "rule definition no longer exists"; +static char dverstring[] = "rule version no longer supported"; + +/* io-related stuff */ +extern int resized(void); + +char *get_pmiefile(void) { return &pmiefile[0]; } +char *get_rules(void) { return &rulepath[0]; } + +char * +get_aname(rule_t *r, atom_t *a) +{ + if (r == globals) + return &a->name[GLOBAL_LEN]; /* lose "globals." at the start */ + return a->name; +} + + +/* + * #### error reporting routines ### + */ + +static void +alloc_error(size_t request) +{ + if (linenum == 0) /* parsing user input, not a file */ + snprintf(errmsg, sizeof(errmsg), "insufficient memory for requested operation.\n" + " requested: %u bytes", (unsigned int)request); + else + snprintf(errmsg, sizeof(errmsg), "insufficient memory for parsing file.\n" + " requested: %u bytes", (unsigned int)request); +} + +static void +parse_error(char *expected, char *found) +{ + if (linenum == 0) /* parsing user input, not a file */ + snprintf(errmsg, sizeof(errmsg), "input is invalid - expected %.60s, got \"%.60s\"", + expected, found); + else + snprintf(errmsg, sizeof(errmsg), "file parsing error.\n" + " line number: %u (\"%s\")\n" + " expected: %.60s\n" + " found: %.60s", linenum, filename, expected, found); +} + +/* report attribute format error */ +static void +type_error(char *attrib, char *expected) +{ + snprintf(errmsg, sizeof(errmsg), "%s's value is invalid.\n" + " It should %s.", attrib, expected); +} + + +/* + * #### search routines ### + */ + +char * +find_rule(char *name, rule_t **rule) +{ + int i; + + for (i = 0; i < rulecount; i++) { + if (strcmp(rulelist[i].self.name, name) == 0) { + *rule = &rulelist[i]; + return NULL; + } + } + snprintf(errmsg, sizeof(errmsg), "rule named \"%s\" does not exist", name); + return errmsg; +} + +/* is global attribute 'atom' overridden by a local in 'rule's atom list */ +int +is_overridden(rule_t *rule, atom_t *atom) +{ + atom_t *aptr; + + for (aptr = rule->self.next; aptr != NULL; aptr = aptr->next) + if (strcmp(get_aname(globals, atom), get_aname(rule, aptr)) == 0) + return 1; + return 0; +} + +/* tests whether a rule is in the fullname group, if so returns 0 */ +int +rule_match(char *fullname, char *rulename) +{ + char *s; + + /* if fullname == rulename, then obvious match */ + if (strcmp(fullname, rulename) == 0) + return 1; + /* fullname may be a group, so match against rulename's groups */ + s = strcpy(token, rulename); /* reuse the token buffer */ + while ((s = strrchr(s, '.')) != NULL) { + s[0] = '\0'; + if (strcmp(token, fullname) == 0) + return 1; + } + return 0; +} + +/* find rule or set of rules in given rule or group name */ +char * +lookup_rules(char *name, rule_t ***rlist, unsigned int *count, int all) +{ + size_t size; + rule_t **rptr = NULL; + unsigned int i; + unsigned int matches = 0; + + /* search through the rulelist and build up rlist & count */ + for (i = 0; i < rulecount; i++) { + /* don't match globals if we've been asked for "all" */ + if ((all && i > 0) || rule_match(name, rulelist[i].self.name)) { + size = (1 + matches) * sizeof(rule_t *); + if ((rptr = (rule_t **)realloc(rptr, size)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory for rule search" + " (needed %u bytes)\n", (unsigned int)size); + return errmsg; + } + rptr[matches] = &rulelist[i]; + matches++; + } + } + if (matches == 0) { + snprintf(errmsg, sizeof(errmsg), "no group or rule names match \"%s\"", name); + return errmsg; + } + *rlist = rptr; /* rlist must be freed by caller */ + *count = matches; + return NULL; +} + + +/* + * #### memory management routines ### + */ + +static char * +alloc_string(size_t size) +{ + char *p; + + if ((p = (char *)malloc(size)) == NULL) + alloc_error(size); + return p; +} + +atom_t * +alloc_atom(rule_t *r, atom_t atom, int global) +{ + atom_t *aptr; + atom_t *tmp; + + /* create some space and copy in the atom data we have already */ + if ((aptr = (atom_t *)malloc(sizeof(atom_t))) == NULL) { + alloc_error(sizeof(atom_t)); + return NULL; + } + *aptr = atom; + aptr->next = NULL; /* want contents of this atom, but not rest of list */ + if (global) { /* applies to all rules */ + r = rulelist; + aptr->global = 1; + } + + aptr->next = NULL; /* want contents of this atom, but not rest of list */ + + /* stick into the list of atoms associated with this rule */ + if (r->self.next == NULL) + r->self.next = aptr; /* insert at head of list */ + else { + for (tmp = r->self.next; tmp->next != NULL; tmp = tmp->next); + tmp->next = aptr; /* append at tail of list */ + } + + return aptr; +} + +rule_t * +alloc_rule(rule_t rule) +{ + size_t size; + rule_t *rptr; + + /* first check that name is unique */ + if (find_rule(rule.self.name, &rptr) == NULL) { + snprintf(errmsg, sizeof(errmsg), "rule name \"%s\" has already been used, duplicate name" + " found in:\n\t\"%.60s\", line %u.", rule.self.name, filename, linenum); + return NULL; + } + size = (rulecount+1) * sizeof(rule_t); + if ((rulelist = globals = (rule_t *)realloc(rulelist, size)) == NULL) { + alloc_error(size); + return NULL; + } + rptr = &rulelist[rulecount]; + *rptr = rule; + rulecount++; + return rptr; +} + + +/* + * #### misc parsing routines ### + */ + +/* given string contains no isgraph chars? */ +int +empty_string(char *s) +{ + char *str = s; + while (*str != '\0') { + if (isgraph((int)*str)) + return 0; + str++; + } + return 1; +} + + +/* lookup keyword, returns symbol identifier or -1 if not there */ +int +map_symbol(symbol_t *table, int tsize, char *symbol) +{ + int i; + + for (i = 0; i < tsize; i++) { + if (strcmp(symbol, table[i].symbol) == 0) + return table[i].symbol_id; + } + return -1; +} + +/* lookup symbol identifier, returns keyword or NULL if not there */ +char * +map_identifier(symbol_t *table, int tsize, int symbol_id) +{ + int i; + + for (i = 0; i < tsize; i++) { + if (symbol_id == table[i].symbol_id) + return table[i].symbol; + } + return NULL; +} + + +/* parse yes/no attribute value; returns 0 no, 1 yes, -1 error */ +int +map_boolean(char *token) +{ + if (token[0] == 'y') + return 1; + if (token[0] == 'n') + return 0; + parse_error("yes or no", token); + return -1; +} + + +/* scan token from string, return 1 ok, 0 no more, -1 error */ +int +string_token(char **scan, char *token) +{ + char *s = *scan; + char *t = token; + + while (! isgraph((int)*s) || *s == ',') { + if (*s == '\0') + return 0; + s++; + } + + if (*s == '\'') { /* quoted token */ + *t++ = *s++; + while (*s != '\'') { + if (*s == '\\') + s++; + if (*s == '\0') + return -1; + *t++ = *s++; + } + *t++ = *s++; + } + else { /* ordinary token */ + while (isgraph((int)*s) && *s != ',') + *t++ = *s++; + } + + *t = '\0'; + *scan = s; + return 1; +} + + +/* check proposed value for type, returns NULL/failure message */ +char * +validate(int type, char *name, char *value) +{ + int x; + char *s; + double d; + /* + * Below we don't care about the value from strtol() and strtoul() + * we're interested in updating the pointer "s". The messiness is + * thanks to gcc and glibc ... strtol() amd strtoul() are marked + * __attribute__((warn_unused_result)) ... to avoid warnings on all + * platforms, assign to dummy variables that are explicitly marked + * unused. + */ + long l __attribute__((unused)); + unsigned long ul __attribute__((unused)); + + switch (type) { + case TYPE_RULE: + case TYPE_STRING: + break; + case TYPE_SHELL: + case TYPE_PRINT: + case TYPE_ALARM: + case TYPE_SYSLOG: + if (map_boolean(value) < 0) + return errmsg; + break; + case TYPE_DOUBLE: + d = strtod(value, &s); + if (*s != '\0') { + type_error(name, "be a real number"); + return errmsg; + } + break; + case TYPE_INTEGER: + l = strtol(value, &s, 10); + if (*s != '\0') { + type_error(name, "be an integer number"); + return errmsg; + } + break; + case TYPE_UNSIGNED: + ul = strtoul(value, &s, 10); + if (*s != '\0') { + type_error(name, "be a positive integer number"); + return errmsg; + } + break; + case TYPE_PERCENT: + if ((s = strrchr(value, '%')) != NULL) /* % as final char is OK */ + *s = '\0'; + d = strtod(value, &s); + if (*s != '\0' || d < 0.0 || d > 100.0) { + type_error(name, "be a percentage between 0.0 and 100.0"); + return errmsg; + } + break; + case TYPE_HOSTLIST: + case TYPE_INSTLIST: + if ((s = alloc_string(strlen(value)+1)) == NULL) + return errmsg; + while ((x = string_token(&value, s)) > 0) + ; + if (x < 0) { + type_error(name, "include a closing single quote"); + return errmsg; + } + free(s); + break; + } + return NULL; +} + + +/* + * printable string form of atoms value, returns NULL terminated string + * pp (pretty print) argument valued 1 means use format appropriate for + * a user interface + */ + +char * +value_string(atom_t *atom, int pp) +{ + int key; + int i = 0; + int start = 1; + int quoted = 0; + char *s; + + switch (atom->type) { + case TYPE_RULE: + case TYPE_STRING: + if (pp) { + snprintf(token, sizeof(token), "\"%s\"", atom->data); + return token; + } + return atom->data; + case TYPE_PRINT: + case TYPE_SHELL: + case TYPE_ALARM: + case TYPE_SYSLOG: + return atom->enabled? yes : no; + case TYPE_HOSTLIST: + case TYPE_INSTLIST: + if (pp) token[i++] = '"'; + if (atom->type == TYPE_HOSTLIST) key = ':'; + else key = '#'; + for (s = atom->data; *s != '\0'; s++) { + if (!isspace((int)*s)) { + if (start && !pp) { + token[i++] = key; + token[i++] = '\''; + if (*s != '\'') + quoted = 0; + else if (!quoted) { + quoted = 1; + start = 0; + continue; + } + } + else if (*s == '\'' && !start && !pp) + quoted = 0; + start = 0; + } + else if (!pp && !quoted) { + quoted = 0; + if (i > 0 && token[i-1] != '\'') + token[i++] = '\''; + start = 1; + } + token[i++] = *s; + } + if (!pp && i > 0 && token[i-1] != '\'') + token[i++] = '\''; + else if (pp) token[i++] = '"'; + token[i++] = '\0'; + return token; + case TYPE_DOUBLE: + snprintf(token, sizeof(token), "%g", strtod(atom->data, &s)); + return token; + case TYPE_INTEGER: + snprintf(token, sizeof(token), "%ld", strtol(atom->data, &s, 10)); + return token; + case TYPE_UNSIGNED: + snprintf(token, sizeof(token), "%lu", strtoul(atom->data, &s, 10)); + return token; + case TYPE_PERCENT: + snprintf(token, sizeof(token), "%g%c", strtod(atom->data, &s), pp? '%':'\0'); + return token; + } + return NULL; +} + + +/* #### rules file parsing routines #### */ + + +/* returns attrib number or -1 if not an attribute */ +int +is_attribute(char *aname) +{ + return map_symbol(attribs, numattribs, aname); +} + +/* returns attrib value as a string, or NULL on error */ +char * +get_attribute(char *attrib, atom_t *atom) +{ + char *value = NULL; + + switch (map_symbol(attribs, numattribs, attrib)) { + case ATTRIB_HELP: + value = atom->help; + break; + case ATTRIB_MODIFY: + if (atom->modify) value = yes; + else value = no; + break; + case ATTRIB_ENABLED: + if (atom->enabled) value = yes; + else value = no; + break; + case ATTRIB_DISPLAY: + if (atom->display) value = yes; + else value = no; + break; + case ATTRIB_DEFAULT: + if (IS_ACTION(atom->type)) { + if (atom->enabled) value = yes; + else value = no; + } + else + value = atom->data; + break; + } + return value; +} + + +/* + * #### sorting routines ### + */ + +static int +compare_rules(const void *a, const void *b) +{ + rule_t *ra = (rule_t *)a; + rule_t *rb = (rule_t *)b; + return strcmp(ra->self.name, rb->self.name); +} + +void +sort_rules(void) +{ + /* start at second array element so that 'globals' is skipped */ + qsort(&rulelist[1], rulecount-1, sizeof(rule_t), compare_rules); +} + + +/* revert to default rules file values for a single atom (enabled/data/both) */ +static char * +atom_defaults(atom_t *a, atom_t *p, char *param) +{ + int sts = map_symbol(attribs, numattribs, param); + + if (sts != -1) { /* an attribute - is it valid? */ + if (sts == ATTRIB_ENABLED) { + if (a->global) { /* this was a global atom promoted to local */ + if (p) p->next = a->next; + free(a->name); + free(a); + a = NULL; + } + else { + a->enabled = a->denabled; /* reset enabled flag */ + a->changed = 0; + } + return NULL; + } + snprintf(errmsg, sizeof(errmsg), "variable \"%s\" is inappropriate for this " + "operation", param); + return errmsg; + } + else { + if (a->global) { /* this was a global atom promoted to local */ + if (p) p->next = a->next; + free(a->name); + free(a); + a = NULL; + } + else { + if (strcmp(a->data, a->ddata) != 0) { /* need to alloc mem? */ + free(a->data); + if ((a->data = strdup(a->ddata)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to set defaults"); + return errmsg; + } + } + a->enabled = a->denabled; + a->changed = 0; + } + return NULL; + } +} + +/* revert to default rules values for a rule or attribute (enabled/data/both) */ +char * +rule_defaults(rule_t *rule, char *param) +{ + atom_t *aptr; + atom_t *prev = NULL; + + if (param == NULL) { /* for this rule, reset all attributes */ + for (aptr = &rule->self; aptr != NULL; aptr = aptr->next) { + atom_defaults(aptr, prev, aptr->name); + prev = aptr; + } + } + else { /* find the associated atom, and just reset that */ + if (map_symbol(attribs, numattribs, param) != -1) { + rule->self.enabled = rule->self.denabled; /* reset enabled flag */ + rule->self.changed = 0; + return NULL; + } + for (aptr = &rule->self; aptr != NULL; aptr = aptr->next) { + if (strcmp(get_aname(rule, aptr), param) == 0) + return atom_defaults(aptr, prev, param); + prev = aptr; + } + } + return NULL; +} + +/* set an attribute field in an atom; returns NULL/failure message */ +static char * +set_attribute(rule_t *r, atom_t *atom, int attrib, char *value, int changed) +{ + char *s; + int sts; + + switch(attrib) { + case ATTRIB_HELP: + if (empty_string(value)) { + parse_error("non-empty string for help", value); + return errmsg; + } + if ((s = alloc_string(strlen(value)+1)) == NULL) + return errmsg; + atom->help = strcpy(s, value); + break; + case ATTRIB_MODIFY: + if ((sts = map_boolean(value)) < 0) + return errmsg; + atom->modify = sts; + break; + case ATTRIB_ENABLED: + if ((sts = map_boolean(value)) < 0) + return errmsg; + if (!changed) /* initially, set enabled to default */ + atom->denabled = sts; + atom->enabled = sts; + break; + case ATTRIB_DISPLAY: + if ((sts = map_boolean(value)) < 0) + return errmsg; + atom->display = sts; + break; + case ATTRIB_DEFAULT: + if (IS_ACTION(atom->type) && changed) { + if ((sts = map_boolean(value)) < 0) + return errmsg; + atom->enabled = sts; + } + else { /* actions from rules file (string) handled here too... */ + if (!IS_ACTION(atom->type) && + (validate(atom->type, get_aname(r, atom), value) != NULL)) + return errmsg; + sts = strlen(value)+1; + if ((s = alloc_string(sts)) == NULL) + return errmsg; + atom->data = strcpy(s, value); + if (!changed) { /* initially, set the default as well */ + if ((s = alloc_string(sts)) == NULL) { + free(atom->data); + atom->data = NULL; + return errmsg; + } + atom->ddata = strcpy(s, value); + } + } + break; + } + if (changed) + atom->changed = 1; + return NULL; +} + +/* set a parameter field in a rule; returns NULL/failure message */ +char * +value_change(rule_t *rule, char *param, char *value) +{ + int sts; + atom_t *aptr; + + if ((sts = map_symbol(attribs, numattribs, param)) != -1) + return set_attribute(rule, &rule->self, sts, value, 1); + else { + for (aptr = rule->self.next; aptr != NULL; aptr = aptr->next) { + if (strcmp(get_aname(rule, aptr), param) == 0) + return set_attribute(rule, aptr, ATTRIB_DEFAULT, value, 1); + } + /* if found in globals, promote the global to customised local.. */ + for (aptr = globals->self.next; aptr != NULL; aptr = aptr->next) { + if (strcmp(get_aname(globals, aptr), param) == 0) { + if ((aptr = alloc_atom(rule, *aptr, 0)) == NULL) + return errmsg; + if ((aptr->name = strdup(get_aname(globals, aptr))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to change value"); + return errmsg; + } + return set_attribute(globals, aptr, ATTRIB_DEFAULT, value, 1); + } + } + } + snprintf(errmsg, sizeof(errmsg), "variable \"%s\" is undefined for rule %s", + param, rule->self.name); + return errmsg; +} + +static char * +append_string(char *s, char *append, int len) +{ + size_t size = (strlen(s) + len + 1); + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - \"%s\" + (%d)\"%s\" = (%d chars)\n", + s, len, append, size); +#endif + if ((s = (char *)realloc(s, size)) == NULL) + return NULL; + strncat(s, append, len); + s[size-1] = '\0'; + return s; +} + +/* fix up value strings by doing variable expansion */ +char * +dollar_expand(rule_t *rule, char *string, int pp) +{ + atom_t *aptr; + char *tmp, *r; + char *sptr; + char *s; + char *mark = NULL; + char localbuf[TOKEN_LENGTH]; + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - dollar_expand %s in %s\n", string, rule->self.name); +#endif + if ((s = (char *)malloc(sizeof(char))) == NULL) + return NULL; + *s = '\0'; + + for (sptr = string; *sptr != '\0'; sptr++) { + if (*sptr == '\\' && *(sptr+1) == '$') { /* skip escaped $ */ + if ((s = append_string(s, sptr+1, 1)) == NULL) + return NULL; + sptr++; /* move passed the escaped char */ + continue; + } + if (*sptr == '$') { + if (mark == NULL) /* start of an expansion section */ + mark = sptr+1; + else { /* end of an expansion section */ + /* look through atom list & if not there search globally */ + strncpy(localbuf, mark, sptr - mark); + localbuf[sptr - mark] = '\0'; + mark = NULL; +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - expand localbuf: %s\n", localbuf); +#endif + if ((tmp = get_attribute(localbuf, &rule->self)) == NULL) { + for (aptr = &rule->self; tmp == NULL && aptr != NULL; aptr = aptr->next) + if (strcmp(get_aname(rule, aptr), localbuf) == 0) + tmp = value_string(aptr, pp); + for (aptr = globals->self.next; tmp == NULL && aptr != NULL; aptr = aptr->next) + if (strcmp(get_aname(globals, aptr), localbuf) == 0) + tmp = value_string(aptr, pp); +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - expanded localbuf? %s\n", tmp); +#endif + if (tmp == NULL) { + snprintf(errmsg, sizeof(errmsg), "variable \"$%s$\" in %s is undefined", + localbuf, rule->self.name); + free(s); + return NULL; + } + } + if (tmp != NULL) { + if ((r = dollar_expand(rule, tmp, pp)) == NULL) { + free(s); + return NULL; + } + if ((s = append_string(s, r, strlen(r))) == NULL) { + free(r); + return NULL; + } + free(r); + } + } + } + else if (mark == NULL) { /* need memory to hold this character */ + if ((s = append_string(s, sptr, 1)) == NULL) + return NULL; + } + } + if (mark != NULL) /* no terminating '$' */ + s = append_string(s, mark, strlen(mark)); +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - expanded '%s' to '%s'\n", string, s); +#endif + return s; +} + + +/* + * #### main parsing routines ### + */ + +/* need a SIGWINCH-aware read routine for interactive pmieconf */ +static int +mygetc(FILE *f) +{ + int c; + + for (;;) { + setoserror(0); + c = getc(f); + /* did we get told to resize the window during read? */ + if (c == -1 && oserror() == EINTR && resized() == 1) + continue; /* signal handled, try reading again */ + break; + } + return c; +} + +/* + * skip leading white space and comments, return first character in next token + * or zero on end of file + */ +static int +prime_next_pread(FILE *f, int end) +{ + int c; + + do { + c = mygetc(f); + if (c == '#') + do { + c = mygetc(f); + } while (c != '\n' && c != end && c != EOF); + if (c == end) + return 0; + else if (c == EOF) + return -2; + if (c == '\n' && end != '\n') + linenum++; + } while (!isgraph(c)); + return c; +} + +/* + * read next input token; returns 1 ok, 0 end, -1 error, -2 EOF (if end!=EOF) + * nb: `end' can be either EOL or EOF, depending on use of this routine + */ +int +read_token(FILE *f, char *token, int token_length, int end) +{ + int c; + int n = 0; + + switch (c = prime_next_pread(f, end)) { + case 0: /* end */ + case -2: /* EOF */ + return c; + case '"': /* scan string */ + c = mygetc(f); + while (c != '"') { + if (c == '\\') + c = mygetc(f); + if (c == end || c == EOF || n == token_length) { + token[n] = '\0'; + parse_error("end-of-string", token); + return -1; + } + if (c == '\n' && end != '\n') + linenum++; + token[n++] = c; + c = mygetc(f); + } + break; + case ';': + case '=': + token[n++] = c; /* single char token */ + break; + default: /* some other token */ + while (isgraph(c)) { + if (c == '=' || c == ';') { + ungetc(c, f); + break; + } + if (n == token_length) { + token[n] = '\0'; + parse_error("end-of-token", token); + return -1; + } + token[n++] = c; + c = mygetc(f); + if (c == end || c == EOF) + ungetc(c, f); + } + if (c == '\n' && end != '\n') + linenum++; + break; + } + + token[n] = '\0'; + return 1; +} + +/* + * get attribute list part of an atom; returns -1 on error, 0 on reaching + * the end of the attribute list, and 1 at end of each attribute. + */ +static int +read_next_attribute(FILE *f, char **attr, char **value) +{ + int sts; + + if ((sts = read_token(f, token, TOKEN_LENGTH, EOF)) <= 0) { + if (sts == 0) + parse_error("attribute or ';'", "end-of-file"); + return -1; + } + if (token[0] == ';') + return 0; + if (map_symbol(attribs, numattribs, token) < 0) { + parse_error("attribute keyword", token); + return -1; + } + if ((*attr = alloc_string(strlen(token)+1)) == NULL) + return -1; + strcpy(*attr, token); + if ((sts = read_token(f, token, TOKEN_LENGTH, EOF)) <= 0 + || token[0] != '=') { + if (sts == 0) + parse_error("=", "end-of-file"); + else + parse_error("=", token); + free(*attr); + return -1; + } + if ((sts = read_token(f, token, TOKEN_LENGTH, EOF)) <= 0) { + if (sts == 0) + parse_error("attribute value", "end-of-file"); + else + parse_error("attribute value", token); + free(*attr); + return -1; + } + if ((*value = alloc_string(strlen(token)+1)) == NULL) { + free(*attr); + return -1; + } + strcpy(*value, token); + return 1; +} + + +/* parse an atom, return NULL/failure message */ +static char * +read_atom(FILE *f, rule_t *r, char *name, int type, int global) +{ + int sts; + int attrib; + char *attr; + char *value; + atom_t atom; + + memset(&atom, 0, sizeof(atom_t)); + atom.name = name; + atom.type = type; + atom.enabled = atom.display = atom.modify = 1; /* defaults */ + for (;;) { + if ((sts = read_next_attribute(f, &attr, &value)) < 0) + return errmsg; + else if (sts == 0) { /* end of parameter list */ + if (alloc_atom(r, atom, global) == NULL) + return errmsg; + break; + } + else { + if ((attrib = map_symbol(attribs, numattribs, attr)) < 0) { + parse_error("attribute keyword", attr); + goto fail; + } + if (set_attribute(r, &atom, attrib, value, 0) != NULL) + goto fail; + free(attr); + free(value); + } + } + return NULL; + +fail: + free(attr); + free(value); + return errmsg; +} + + +/* parse type-identifier pair, return NULL/failure message */ +static char * +read_type(FILE *f, rule_t *r, int *type, int *global, char **name) +{ + int sts; + + /* read type - rule, percent, double, unsigned, string... */ + if ((sts = read_token(f, token, TOKEN_LENGTH, EOF)) < 0) + return errmsg; + else if (sts == 0) + return NULL; + if ((*type = map_symbol(types, numtypes, token)) < 0) { + parse_error("type keyword", token); + return errmsg; + } + + /* read name identifying this rule/atom of type '*type' */ + if ((sts = read_token(f, token, TOKEN_LENGTH, EOF)) <= 0) + return errmsg; + if ((*name = alloc_string(strlen(token)+1)) == NULL) + return errmsg; + strcpy(*name, token); + *global = (strncmp(*name, "global.", GLOBAL_LEN) == 0)? 1 : 0; + + /* do some simple validity checks */ + if (IS_RULE(*type) && strncmp(*name, global_name, GLOBAL_LEN-1) == 0) { + snprintf(errmsg, sizeof(errmsg), "rule name may not be \"%s\" - this is reserved", + global_name); + free(*name); + return errmsg; + } + if (r == NULL) { /* any rule defined yet? - simple validity checks */ + if (*global && IS_RULE(*type)) { + snprintf(errmsg, sizeof(errmsg), "rules not allowed in global group: \"%s\"", *name); + free(*name); + return errmsg; + } + else if (!*global && !IS_RULE(*type)) { /* not global, and no rule */ + snprintf(errmsg, sizeof(errmsg), "no rule defined, cannot make sense of %s \"%s\"" + " without one\n line number: %u (\"%s\")\n", + types[*type].symbol, *name, linenum, filename); + free(*name); + return errmsg; + } + } + return NULL; +} + +/* set an attribute field in an atom; returns NULL/failure message */ +static char * +set_rule_attribute(rule_t *rule, int attrib, char *value) +{ + char *s; + + if (attrib == ATTRIB_PREDICATE) { + if ((s = alloc_string(strlen(value)+1)) == NULL) + return errmsg; + rule->predicate = strcpy(s, value); + return NULL; + } + if (attrib == ATTRIB_ENUMERATE) { + if ((s = alloc_string(strlen(value)+1)) == NULL) + return errmsg; + rule->enumerate = strcpy(s, value); + return NULL; + } + else if (attrib == ATTRIB_VERSION) { + rule->version = strtoul(value, &s, 10); + if (*s != '\0') { + parse_error("version number", "be a positive integer number"); + return errmsg; + } + return NULL; + } + /* else */ + return set_attribute(rule, &rule->self, attrib, value, 0); +} + + +/* parse a single "rule" expression, return NULL/failure message */ +static char * +read_rule(FILE *f, rule_t **r, char *name) +{ + int sts; + int attrib; + char *attr; + char *value; + rule_t rule; + + memset(&rule, 0, sizeof(rule_t)); + rule.self.name = name; + rule.self.type = TYPE_RULE; + rule.version = rule.self.enabled = rule.self.display = 1; /* defaults */ + for (;;) { + if ((sts = read_next_attribute(f, &attr, &value)) < 0) + return errmsg; + else if (sts == 0) { /* end of attribute list */ + if ((*r = alloc_rule(rule)) == NULL) + return errmsg; + break; + } + else { + if ((attrib = map_symbol(attribs, numattribs, attr)) < 0) { + parse_error("rule attribute keyword", attr); + goto fail; + } + if (set_rule_attribute(&rule, attrib, value) != NULL) + goto fail; + free(attr); + free(value); + } + } + return NULL; + +fail: + free(attr); + free(value); + return errmsg; +} + + +/* parse rule description file; returns NULL/failure message */ +static char * +read_all_rules(FILE *f) +{ + rule_t *rule = NULL; /* current rule */ + char *name = NULL; + int type = 0; + int global = 0; + + /* rule files have quite a simple grammar, along these lines: + TYPE identifier [ ATTRIB '=' value ]* ';' + */ + for (;;) { + if (read_type(f, rule, &type, &global, &name) != NULL) + return errmsg; + if (feof(f)) /* end of file reached without error */ + break; + if (type == TYPE_RULE) { + if (read_rule(f, &rule, name) != NULL) + return errmsg; + } + else { + if (read_atom(f, rule, name, type, global) != NULL) + return errmsg; + } + } + + return NULL; +} + + +/* + * validate header of rule description file, return NULL/failure message + */ +static char * +read_pheader(FILE *f) +{ + int c; + + c = getc(f); + if (c != '#' || read_token(f, token, TOKEN_LENGTH, EOF) != 1 || + strcmp(token, RULES_FILE) != 0 || + read_token(f, token, TOKEN_LENGTH, EOF) != 1) { + snprintf(errmsg, sizeof(errmsg), "%s is not a rule description file (bad header)\n" + "found \"%s\", expected \"%s\"", filename, + token, RULES_FILE); + return errmsg; + } + else if (strcmp(token, RULES_VERSION) != 0) { /* one version only */ + snprintf(errmsg, sizeof(errmsg), "unknown version number in %s: \"%s\" (expected %s)", + filename, token, RULES_VERSION); + return errmsg; + } + return NULL; +} + + +/* + * builds up rule data structures for all rule files in given directory + * and all its subdirectories, returns NULL/failure message + */ +char * +read_rule_subdir(char *subdir) +{ + struct stat sbuf; + struct dirent *dp; + FILE *fp; + DIR *dirp; + char fullpath[MAXPATHLEN+1]; + + if (stat(subdir, &sbuf) < 0) { + snprintf(errmsg, sizeof(errmsg), "cannot stat %s: %s", + subdir, osstrerror()); + return errmsg; + } + if (!S_ISDIR(sbuf.st_mode)) { + if ((fp = fopen(subdir, "r")) == NULL) { + snprintf(errmsg, sizeof(errmsg), "cannot open %s: %s", + subdir, osstrerror()); + return errmsg; + } + linenum = 1; + filename = subdir; + if (read_pheader(fp) == NULL) { + if (read_all_rules(fp) != NULL) { + fclose(fp); + return errmsg; + } + } +#ifdef PMIECONF_DEBUG + else { + fprintf(stderr, "debug - %s isn't a pmie rule file: %s\n", + filename, errmsg); + } +#endif + fclose(fp); + } + else { + /* iterate through the rules directory and for each subdirectory */ + /* fetch all the rules along with associated parameters & values */ + + if ((dirp = opendir(subdir)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "cannot opendir %s: %s", subdir, osstrerror()); + return errmsg; + } + while ((dp = readdir(dirp)) != NULL) { /* groups */ + if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0) + continue; + snprintf(fullpath, sizeof(fullpath), "%s%c%s", subdir, SEP, dp->d_name); + if (read_rule_subdir(fullpath) != NULL) { /* recurse */ + closedir(dirp); + return errmsg; + } + } + closedir(dirp); + } + return NULL; +} + + +/* ##### pmiefile parsing routines #### */ + + +/* returns NULL on successfully adding rule to list, else failure message */ +char * +deprecate_rule(char *name, unsigned int version, int type) +{ + int index; + + /* first check to see if this rule is deprecated already */ + for (index = 0; index < dcount; index++) { + if (strcmp(dlist[index].name, name) == 0 + && dlist[index].version == version) + return NULL; + } + + /* get the memory we need & then keep a copy of deprecated rule info */ + if ((dlist = (dep_t *)realloc(dlist, (dcount+1)*sizeof(dep_t))) == NULL + || (dlist[dcount].name = strdup(name)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to deprecate rule %s", name); + return errmsg; + } + dlist[dcount].type = type; + dlist[dcount].version = version; + if (type == DEPRECATE_NORULE) + dlist[dcount].reason = drulestring; + else + dlist[dcount].reason = dverstring; + dcount++; + return NULL; +} + +/* + * makes list of deprecated rules available to caller (for warning message) + * nb: called following a pmiefile write to see what was deprecated during + * that write - subsequent writing of this pmiefile should not deprecate + * anything (deprecations done once & not again). caller must free list. + */ +int +fetch_deprecated(dep_t **list) +{ + int sts; + + *list = dlist; + sts = dcount; + dcount = 0; + return sts; +} + +/* merges local customisations back into the rules atom list */ +static char * +merge_local(unsigned int version, char *name, char *attrib, char *value) +{ + atom_t *aptr; + rule_t *rule; + int a; + + /* + first find the rule to which this local belongs, then figure + out what sort of attribute this really is, and finally merge + the customisation back into the values in the rules attribs. + */ + + if (find_rule(name, &rule) != NULL) /* in pmiefile but not rules */ + return NULL; /* this will be deprecated later */ + else if (rule->version != version) /* no rule for this version */ + return NULL; /* this will be deprecated later */ + + if ((a = is_attribute(attrib)) != -1) + return set_attribute(rule, &rule->self, a, value, 1); + else { /* search through this rules list of atoms */ + for (aptr = rule->self.next; aptr != NULL; aptr = aptr->next) { + if (strcmp(get_aname(rule, aptr), attrib) == 0) + return set_attribute(rule, aptr, ATTRIB_DEFAULT, value, 1); + } + for (aptr = globals->self.next; aptr != NULL; aptr = aptr->next) { + if (strcmp(get_aname(globals, aptr), attrib) == 0) { + /* promote global to become a local */ + if ((aptr = alloc_atom(rule, *aptr, 0)) == NULL) + return errmsg; + if ((aptr->name = strdup(get_aname(globals, aptr))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to change value"); + return errmsg; + } + return set_attribute(globals, aptr, ATTRIB_DEFAULT, value, 1); + } + } + } + snprintf(errmsg, sizeof(errmsg), "variable \"%s\" is undefined for rule %s", + attrib, name); + return errmsg; +} + + +/* + * #### produce pmie configuration file from rules ### + */ + +char * +action_string(int type) +{ + switch (type) { + case TYPE_PRINT: return "print"; + case TYPE_SHELL: return "shell"; + case TYPE_ALARM: return "alarm"; + case TYPE_SYSLOG: return "syslog"; + } + return NULL; +} + +static int +expand_action(FILE *f, int count, rule_t *rule, atom_t *atom) +{ + char *p; + char *str; + + if (IS_ACTION(atom->type) && atom->enabled) { + if ((str = dollar_expand(rule, " $holdoff$ ", 0)) == NULL) + return count; + if (count == 0) + fprintf(f, " -> "); + else + fprintf(f, "\n & "); + fprintf(f, "%s", action_string(atom->type)); + fprintf(f, "%s", str); + free(str); + if ((str = dollar_expand(rule, atom->data, 0)) == NULL) { + fprintf(stderr, "Warning - failed to expand action for rule %s\n" + " string: \"%s\"\n", rule->self.name, atom->data); + /* keep going - too late to bail out without file corruption */ + } +#ifdef PMIECONF_DEBUG + else { + fprintf(stderr, "expanded action= \"%s\"\n", str); + } +#endif + fputc('"', f); + for (p = str; p != NULL && *p; p++) { /* expand the '^' character */ + if (*p == '/' && *(p+1) == '^') { + fputc(*p, f); p++; + fputc(*p, f); p++; + } + else if (*p == '^') + fputs("\" \"", f); + else fputc(*p, f); + } + fputc('"', f); + if (str != NULL) + free(str); + return count + 1; + } + return count; +} + + +/* + * this struct and the enumerate function are used only in generate_rules() + * and the enumerate() routines, for enumeration of either a hostlist or an + * instlist + */ + +typedef struct { + atom_t *atom; + int nvalues; + char **valuelist; + char *restore; +} enumlist_t; + +static enumlist_t *list; +static int nlistitems; +static int writecount; + +/* + * expands and writes out a single rule, and optionally the delta + * note: in the single rule case (not enumerated), we absolutely + * must write out the delta every time + */ +static char * +write_rule(FILE *f, rule_t *rule) +{ + atom_t *aptr; + char *dgen = NULL; /* holds generated "delta" */ + char *pgen; /* holds generated "predicate" */ + int actions = 0; + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - writing rule %s\n", rule->self.name); +#endif + + if (writecount == 0 && (dgen = dollar_expand(rule, "$delta$", 0)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "\"$delta$\" variable expansion failed for rule %s", + rule->self.name); + return errmsg; + } + if ((pgen = dollar_expand(rule, rule->predicate, 0)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "\"$predicate$\" variable expansion failed " + "for rule %s", rule->self.name); + return errmsg; + } + if (writecount == 0) { + fprintf(f, "// %u %s\ndelta = %s;\n%s = \n", rule->version, + rule->self.name, dgen, rule->self.name); + free(dgen); + } + else /* we're enumerating, need to differentiate rule names */ + fprintf(f, "%s%u = \n", rule->self.name, writecount); + fputs(pgen, f); + free(pgen); + for (aptr = rule->self.next; aptr != NULL; aptr = aptr->next) + actions = expand_action(f, actions, rule, aptr); + for (aptr = globals->self.next; aptr != NULL; aptr = aptr->next) + actions = expand_action(f, actions, rule, aptr); + fprintf(f, ";\n\n"); + + writecount++; + return NULL; +} + +/* parses the "enumerate" value string passed in thru the rules file */ +char * +parse_enumerate(rule_t *rule) +{ + atom_t *ap; + char *p = rule->enumerate; + int needsave = 0; /* should we save this variable name yet? */ + int i = 0; + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - parse_enumerate called for %s\n", rule->self.name); +#endif + + nlistitems = 0; + list = NULL; + while (*p != '\0') { + if (!isspace((int)*p)) { + needsave = 1; + token[i++] = *p; + } + p++; + if ((isspace((int)*p) && needsave) || *p == '\0') { + token[i] = '\0'; + i = 0; + if (map_symbol(attribs, numattribs, token) != -1) { + snprintf(errmsg, sizeof(errmsg), "cannot enumerate rule %s using attribute" + " \"%s\"", rule->self.name, token); + return errmsg; + } + else { + for (ap = rule->self.next; ap != NULL; ap = ap->next) + if (strcmp(get_aname(rule, ap), token) == 0) + goto foundname; + for (ap = globals->self.next; ap != NULL; ap = ap->next) + if (strcmp(get_aname(globals, ap), token) == 0) + goto foundname; + snprintf(errmsg, sizeof(errmsg), "variable \"%s\" undefined for enumerated" + " rule %s", token, rule->self.name); + return errmsg; + } +foundname: + if (ap->type != TYPE_HOSTLIST && ap->type != TYPE_INSTLIST) { + snprintf(errmsg, sizeof(errmsg), "rules file error - \"$%s$\" in \"enumerate\" " + "clause of rule %s is not of type hostlist or instlist", + token, rule->self.name); + return errmsg; + } + /* increase size of list & keep a copy of the variable name */ + if ((list = realloc(list, (nlistitems+1)*sizeof(enumlist_t))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to write rules"); + return errmsg; + } + list[nlistitems].atom = ap; + list[nlistitems].nvalues = 0; + list[nlistitems].valuelist = NULL; + list[nlistitems].restore = NULL; +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - variable %s added to enum list (#%d)\n", + list[nlistitems].atom->name, nlistitems); +#endif + nlistitems++; + needsave = 0; + } + } + return NULL; +} + +/* + * converts a host/inst list into individual elements, overwrites liststr + * (turns all spaces to NULLs to mark string ends - reduces mallocing) + */ +char ** +get_listitems(char *liststr, int *count) +{ + char **result = NULL; + char *p = liststr; + int keepwhite = 0; + int startagain = 0; /* set to signify new list item has started */ + int ptrcount = 0; + + if ((result = realloc(result, (ptrcount+1) * sizeof(char *))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to get list elements"); + return NULL; + } + result[ptrcount++] = p; + while (*p != '\0') { + if (!isspace((int)*p) || keepwhite) { + if (startagain) { + result = realloc(result, (ptrcount+1) * sizeof(char *)); + if (result == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to get list elements"); + return NULL; + } + result[ptrcount++] = p; + startagain = 0; + } + if (*p == '\\') + p++; + else if (*p == '\'') + keepwhite = !keepwhite; + } + else { + *p = '\0'; + startagain = 1; + } + p++; + } +#ifdef PMIECONF_DEBUG + fputs("debug - instances are:", stderr); + for (keepwhite = 0; keepwhite < ptrcount; keepwhite++) + fprintf(stderr, " %s", result[keepwhite]); + fputs("\n", stderr); +#endif + *count = ptrcount; + return result; +} + +/* expands variables from the "enumerate" string in the rules file */ +char * +expand_enumerate(rule_t *rule) +{ + int i, j; + char *p; + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - expanding enum variables for rule %s\n", + rule->self.name); +#endif + + for (i = 0; i < nlistitems; i++) { + if ((p = dollar_expand(rule, list[i].atom->data, 0)) == NULL) + return errmsg; + if ((list[i].valuelist = realloc(list[i].valuelist, + sizeof(char *) * (list[i].nvalues + 1))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory for rule enumeration"); + free(p); + return errmsg; + } + if ((list[i].valuelist = get_listitems(p, &j)) == NULL) { + free(p); + return errmsg; + } + list[i].nvalues = j; +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - %s value list:", list[i].atom->name); + for (j = 0; j < list[i].nvalues; j++) + fprintf(stderr, " %s", list[i].valuelist[j]); + fprintf(stderr, "\n"); +#endif + } + return NULL; +} + +void +enumerate(FILE *f, rule_t *r, enumlist_t *listoffset, int wssize, char **wset) +{ + int i; + + if (wssize < nlistitems) { + for (i = 0; i < listoffset->nvalues; i++) { + /* add current word to word set, and move down a level */ + wset[wssize] = listoffset->valuelist[i]; + enumerate(f, r, &list[wssize+1], wssize+1, wset); + } + } + else { /* have a full set, generate rule */ +#ifdef PMIECONF_DEBUG + for (i = 0; i < wssize; i++) + printf("%s=%s ", list[i].atom->name, wset[i]); + printf("\n"); +#endif + for (i = 0; i < wssize; i++) { + list[i].restore = list[i].atom->data; + list[i].atom->data = wset[i]; + } + + write_rule(f, r); + + for (i = 0; i < wssize; i++) + list[i].atom->data = list[i].restore; + } +} + +/* generate pmie rules for rule, returns rule string/NULL */ +static char * +generate_rules(FILE *f, rule_t *rule) +{ + int i; + + if (rule->self.enabled == 0) + return NULL; + if (rule->enumerate == NULL) { + writecount = 0; + write_rule(f, rule); + } + else { + char **workingset; /* holds current variable values set */ + +#ifdef PMIECONF_DEBUG + fprintf(stderr, "debug - generating enumerated rule %s\n", + rule->self.name); +#endif + + /* "enumerate" attrib is a space-separated list of variables */ + /* 1.create a list of variable info structs (name->valuelist) */ + /* 2.recurse thru lists, when each set built, write out rule */ + + if ((parse_enumerate(rule)) != NULL) + return errmsg; + if ((expand_enumerate(rule)) != NULL) + return errmsg; + if ((workingset = malloc(nlistitems * sizeof(char*))) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to generate rules"); + return errmsg; + } + writecount = 0; + enumerate(f, rule, list, 0, workingset); + free(workingset); + for (i = 0; i < nlistitems; i++) + free(list[i].valuelist); /* alloc'd by dollar_expand */ + free(list); + } + + return NULL; +} + +/* generate local configuration changes, returns rule string/NULL */ +static char * +generate_pmiefile(FILE *f, rule_t *rule) +{ + atom_t *aptr; + + for (aptr = &rule->self; aptr != NULL; aptr = aptr->next) { + if (aptr->changed == 0) + continue; + if (IS_RULE(aptr->type)) { + fprintf(f, "// %u %s %s = %s\n", rule->version, + get_aname(rule, aptr), "enabled", + rule->self.enabled? "yes" : "no"); + } + else { + fprintf(f, "// %u %s %s = %s\n", rule->version, rule->self.name, + get_aname(rule, aptr), value_string(aptr, 1)); + } + } + return NULL; +} + +/* generate pmie rules and write to file, returns NULL/failure message */ +char * +write_pmiefile(char *program, int autocreate) +{ + time_t now = time(NULL); + char *p, *msg = NULL; + char buf[MAXPATHLEN+10]; + char *fname = get_pmiefile(); + FILE *fp; + int i; + + /* create full path to file if it doesn't exist */ + if ((p = strrchr(fname, '/')) != NULL) { + struct stat sbuf; + + *p = '\0'; /* p is the dirname of fname */ + if (stat(fname, &sbuf) < 0) { + snprintf(buf, sizeof(buf), "/bin/mkdir -p %s", fname); + if (system(buf) < 0) { + snprintf(errmsg, sizeof(errmsg), "failed to create directory \"%s\"", p); + return errmsg; + } + } + else if (!S_ISDIR(sbuf.st_mode)) { + snprintf(errmsg, sizeof(errmsg), "\"%s\" exists and is not a directory", p); + return errmsg; + } + fname[strlen(fname)] = '/'; /* stitch together */ + } + + if ((fp = fopen(fname, "w")) == NULL) { + snprintf(errmsg, sizeof(errmsg), "cannot write file %s: %s", fname, osstrerror()); + return errmsg; + } + else if (!gotpath) { + strcpy(token, fname); + if (realpath(token, pmiefile) == NULL) { + fclose(fp); + snprintf(errmsg, sizeof(errmsg), "failed to resolve %s realpath: %s", token, osstrerror()); + return errmsg; + } + gotpath = 1; + } + + fprintf(fp, "// %s %s %s\n", PMIE_FILE, PMIE_VERSION, get_rules()); + for (i = 0; i < rulecount; ++i) + if ((msg = generate_pmiefile(fp, &rulelist[i])) != NULL) + goto imouttahere; + fputs("// end\n//\n", fp); + + fprintf(fp, "%s// %sgenerated by %s on: %s//\n\n", + START_STRING, autocreate ? "Auto-" : " ", program, ctime(&now)); + for (i = 1; i < rulecount; ++i) /* 1: start _after_ globals */ + if ((msg = generate_rules(fp, &rulelist[i])) != NULL) + goto imouttahere; + + /* write user-modifications area */ + fprintf(fp, END_STRING); + /* finally any other local changes */ + if (save_area != NULL) + fputs(save_area, fp); + +imouttahere: + fclose(fp); + return msg; +} + + +/* + * #### pmiefile manipulation routines ### + */ + +/* + * skip leading white space and comments, return first character in next token + * or zero on end of file + */ +static int +prime_next_lread(FILE *f) +{ + int c; + + do { + c = getc(f); + if (c == EOF) + return 0; + if (c == '\n') { + linenum++; + if (getc(f) != '/') return 0; + if (getc(f) != '/') return 0; + } + } while (! isgraph(c)); + return c; +} + +/* read next input token; returns 1 ok, 0 eof, -1 error */ +static int +read_ltoken(FILE *f) +{ + int c; + int n = 0; + + switch (c = prime_next_lread(f)) { + case 0: /* EOF */ + return 0; + case '"': /* scan string */ + c = getc(f); + while (c != '"') { + if (c == '\\') + c = getc(f); + if (c == EOF || n == TOKEN_LENGTH) { + token[n] = '\0'; + parse_error("end-of-string", token); + return -1; + } + if (c == '\n') { + token[n] = '\0'; + parse_error("end-of-string", "end-of-line"); + return -1; + } + token[n++] = c; + c = getc(f); + } + break; + case '=': + token[n++] = c; /* single char token */ + break; + default: /* some other token */ + while (isgraph(c)) { + if (c == '=') { + ungetc(c, f); + break; + } + if (n == TOKEN_LENGTH) { + token[n] = '\0'; + parse_error("end-of-token", token); + return -1; + } + token[n++] = c; + c = getc(f); + } + if (c == '\n') { + linenum++; + if (strncmp(token, "end", 3) == 0) break; + if (getc(f) != '/') return 0; + if (getc(f) != '/') return 0; + } + break; + } + + token[n] = '\0'; + return 1; +} + + +/* allocates memory & appends a string to the save area */ +char * +save_area_append(char *str) +{ + int size = strlen(str); + + while ( (size+1) >= (sa_size-sa_mark) ) { + sa_size += 256; /* increase area by 256 bytes at a time */ + if ((save_area = (char *)realloc(save_area, sa_size)) == NULL) + return NULL; + } + if (sa_mark == 1) + save_area = strcpy(save_area, str); + else + save_area = strcat(save_area, str); + sa_mark += size; + return save_area; +} + +/* read and save text which is to be restored on pmiefile write */ +static char * +read_restore(FILE *f) +{ + unsigned int version; + rule_t *rule; + char buf[LINE_LENGTH]; + int saverule = 0; + int saveall = 0; + + do { + if (fgets(buf, LINE_LENGTH, f) == NULL) + break; + if (!saveall) { /* not yet at start of explicit "save" position */ + if (strcmp(buf, END_STRING) == 0) + saveall = 1; + else if (sscanf(buf, "// %u %s\n", &version, token) == 2) { + /* + * where the rule has disappeared or its version does not match + * the one in the pmiefile, add the rule name & version to list + * of rules to be deprecated (i.e. moved to the "save area") + */ + /* check that we still have this rule definition */ + if (find_rule(token, &rule) != NULL) { /* not found! */ + snprintf(buf, sizeof(buf), "// %u %s (deprecated, %s)\n", + version, token, drulestring); + deprecate_rule(token, version, DEPRECATE_NORULE); + saverule = 1; + } + else if (rule->version != version) { /* not supported! */ + snprintf(buf, sizeof(buf), "// %u %s (deprecated, %s)\n", + version, token, dverstring); + deprecate_rule(token, version, DEPRECATE_VERSION); + saverule = 1; + } + else + saverule = 0; + } + if (!saveall && saverule) { + if (save_area_append("// ") == NULL || + save_area_append(buf) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to deprecate a rule"); + return errmsg; + } + } + } + else if (save_area_append(buf) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory to preserve save area"); + return errmsg; + } + } while (!feof(f)); + return NULL; +} + + +/* read custom values, return NULL/failure message */ +static char * +read_locals(FILE *f) +{ + int sts; + char *rule; + char *attrib; + char *value; + unsigned int version; + + /* general pmiefile format: version rulename attribute = value */ + + for (;;) { + if ((sts = read_ltoken(f)) < 0) + return errmsg; + else if (sts == 0) { + parse_error("rule identifier or \"end\" symbol", "end-of-file"); + return errmsg; + } + if (strcmp("end", token) == 0) + break; + + /* read the version number for this rule */ + version = strtoul(token, &value, 10); + if (*value != '\0') { + parse_error("version number", token); + return errmsg; + } + + /* read the name of the rule */ + if ((sts = read_ltoken(f)) != 1 || + (rule = alloc_string(strlen(token)+1)) == NULL) { + if (sts == 0) + parse_error("rule name", token); + return errmsg; + } + strcpy(rule, token); + + /* read the rule attribute component */ + if ((sts = read_ltoken(f)) != 1 || + (attrib = alloc_string(strlen(token)+1)) == NULL) { + free(rule); + if (sts == 0) + parse_error("rule attribute", token); + return errmsg; + } + strcpy(attrib, token); + + if ((sts = read_ltoken(f)) != 1 || strcmp("=", token) != 0) { + free(rule); free(attrib); + if (sts == 0) + parse_error("'=' symbol", "end-of-file"); + return errmsg; + } + + /* read the modified value of this attribute */ + if ((sts = read_ltoken(f)) != 1 || + (value = alloc_string(strlen(token)+1)) == NULL) { + free(rule); free(attrib); + if (sts == 0) + parse_error("rule attribute value", "end-of-file"); + return errmsg; + } + strcpy(value, token); + + if (merge_local(version, rule, attrib, value) != NULL) { + free(rule); free(attrib); free(value); + return errmsg; + } + free(rule); free(attrib); free(value); /* no longer need these */ + } + return NULL; +} + +/* validate header of rule customizations file, return NULL/failure message */ +static char * +read_lheader(FILE *f, char **proot) +{ + if (read_ltoken(f) != 1 || strcmp(token, "//") || read_ltoken(f) != 1 + || strcmp(token, PMIE_FILE) || read_ltoken(f) != 1) { + snprintf(errmsg, sizeof(errmsg), "%s is not a rule customization file (bad header)", + filename); + return errmsg; + } + else if (strcmp(token, PMIE_VERSION) != 0) { /* one version only */ + snprintf(errmsg, sizeof(errmsg), "unknown version number in %s: \"%s\" (expected %s)", + filename, token, PMIE_VERSION); + return errmsg; + } + else if (read_ltoken(f) != 1) { + snprintf(errmsg, sizeof(errmsg), "no rules path specified in %s after version number", + filename); + return errmsg; + } + *proot = token; + return NULL; +} + + +/* + * read the pmiefile format into global data structures + */ +char * +read_pmiefile(char *warning, size_t warnlen) +{ + char *tmp = NULL; + char *p, *home; + FILE *f; + char *rule_path_sep; + + if ((f = fopen(get_pmiefile(), "r")) == NULL) { + if (oserror() == ENOENT) + return NULL; + snprintf(errmsg, sizeof(errmsg), "cannot open %s: %s", + get_pmiefile(), osstrerror()); + return errmsg; + } + + linenum = 1; + filename = get_pmiefile(); + if (read_lheader(f, &tmp) != NULL) { + fclose(f); + return errmsg; + } + + /* check that we have access to all components of the path */ + if ((home = strdup(tmp)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory for pmie file parsing"); + return errmsg; + } +#ifdef IS_MINGW + rule_path_sep = ";"; +#else + rule_path_sep = ":"; +#endif + p = strtok(home, rule_path_sep); + while (p != NULL) { + if (access(p, F_OK) < 0) { + free(home); + snprintf(errmsg, sizeof(errmsg), "cannot access rules path component: \"%s\"", p); + return errmsg; + } + p = strtok(NULL, rule_path_sep); + } + free(home); + + if (strcmp(get_rules(), tmp) != 0) + snprintf(warning, warnlen, "warning - pmie configuration file \"%s\"\n" + " may not have been built using rules path:\n\t\"%s\"\n" + " (originally built using \"%s\")", filename, get_rules(), tmp); + + tmp = NULL; + if (read_locals(f) != NULL || read_restore(f) != NULL) + tmp = errmsg; + fclose(f); + return tmp; +} + + +/* #### setup global data structures; return NULL/failure message #### */ +char * +initialise(char *in_rules, char *in_pmie, char *warning, size_t warnlen) +{ + char *p; + char *home; + rule_t global; + char *rule_path_sep; + + /* setup pointers to the configuration files */ +#ifdef IS_MINGW + if ((home = getenv("USERPROFILE")) == NULL) { + snprintf(errmsg, sizeof(errmsg), "USERPROFILE undefined in environment"); + return errmsg; + } + if (in_pmie == NULL) + snprintf(pmiefile, sizeof(pmiefile), "%s\\%s", home, DEFAULT_USER_PMIE); + else + strcpy(pmiefile, in_pmie); + rule_path_sep = ";"; +#else + if (getuid() == 0) { + if (in_pmie == NULL) + snprintf(pmiefile, sizeof(pmiefile), "%s%c%s", pmGetConfig("PCP_SYSCONF_DIR"), SEP, DEFAULT_ROOT_PMIE); + else if (realpath(in_pmie, pmiefile) == NULL && oserror() != ENOENT) { + snprintf(errmsg, sizeof(errmsg), "failed to resolve realpath for %s: %s", + in_pmie, osstrerror()); + return errmsg; + } + else if (oserror() != ENOENT) + gotpath = 1; + } + else { + if ((home = getenv("HOME")) == NULL) { + snprintf(errmsg, sizeof(errmsg), "$HOME undefined in environment"); + return errmsg; + } + if (in_pmie == NULL) + snprintf(pmiefile, sizeof(pmiefile), "%s%c%s", home, SEP, DEFAULT_USER_PMIE); + else + strcpy(pmiefile, in_pmie); + } + rule_path_sep = ":"; +#endif + + if (in_rules == NULL) { + if ((p = getenv("PMIECONF_PATH")) == NULL) + snprintf(rulepath, sizeof(rulepath), "%s%c%s", pmGetConfig("PCP_VAR_DIR"), SEP, DEFAULT_RULES); + else + strcpy(rulepath, p); + } + else + snprintf(rulepath, sizeof(rulepath), "%s", in_rules); + + memset(&global, 0, sizeof(rule_t)); + global.self.name = global_name; + global.self.data = global_data; + global.self.help = global_help; + global.self.global = 1; + if (alloc_rule(global) == NULL) { /* 1st rule holds global (fake rule) */ + snprintf(errmsg, sizeof(errmsg), "insufficient memory for global parameters"); + return errmsg; + } + + if ((home = strdup(rulepath)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory for rules path parsing"); + return errmsg; + } + p = strtok(home, rule_path_sep); + while (p != NULL) { + if (read_rule_subdir(p) != NULL) { + free(home); + return errmsg; + } + p = strtok(NULL, rule_path_sep); + } + free(home); + + if (read_pmiefile(warning, warnlen) != NULL) + return errmsg; + linenum = 0; /* finished all parsing */ + return NULL; +} + + +/* iterate through the pmie status directory and find running pmies */ +char * +lookup_processes(int *count, char ***processes) +{ + int fd; + int running = 0; + DIR *dirp; + void *ptr; + char proc[MAXPATHLEN+1]; + char **proc_list = NULL; + size_t size; + pmiestats_t *stats; + struct dirent *dp; + struct stat statbuf; + int sep = __pmPathSeparator(); + + snprintf(proc, sizeof(proc), "%s%c%s", + pmGetConfig("PCP_TMP_DIR"), sep, PMIE_SUBDIR); + if ((dirp = opendir(proc)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "cannot opendir %s: %s", + proc, osstrerror()); + return NULL; + } + while ((dp = readdir(dirp)) != NULL) { + /* bunch of checks to find valid pmie data files... */ + if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0) + continue; + snprintf(proc, sizeof(proc), "%s%c%s", + PROC_DIR, sep, dp->d_name); /* check /proc */ + if (access(proc, F_OK) < 0) + continue; /* process has exited */ + snprintf(proc, sizeof(proc), "%s%c%s%c%s", + pmGetConfig("PCP_TMP_DIR"), sep, PMIE_SUBDIR, sep, dp->d_name); + if (stat(proc, &statbuf) < 0) + continue; + if (statbuf.st_size != sizeof(pmiestats_t)) + continue; + if ((fd = open(proc, O_RDONLY)) < 0) + continue; + ptr = __pmMemoryMap(fd, statbuf.st_size, 0); + close(fd); + if (ptr == NULL) + continue; + stats = (pmiestats_t *)ptr; + if (strcmp(stats->config, get_pmiefile()) != 0) + continue; + + size = (1 + running) * sizeof(char *); + if ((proc_list = (char **)realloc(proc_list, size)) == NULL + || (proc_list[running] = strdup(dp->d_name)) == NULL) { + snprintf(errmsg, sizeof(errmsg), "insufficient memory for process search"); + if (proc_list) free(proc_list); + closedir(dirp); + close(fd); + return errmsg; + } + running++; + } + closedir(dirp); + *count = running; + *processes = proc_list; + return NULL; +} |