char *knownhost(char *hostname, char *hostip, int ghosthandling)
{
/*
* ghosthandling = 0 : Default BB method (case-sensitive, no logging, keep ghosts)
* ghosthandling = 1 : Case-insensitive, no logging, drop ghosts
* ghosthandling = 2 : Case-insensitive, log ghosts, drop ghosts
*/
RbtIterator hosthandle;
namelist_t *walk = NULL;
static char *result = NULL;
void *k1, *k2;
time_t now = getcurrenttime(NULL);
if (result) xfree(result);
result = NULL;
/* Find the host in the normal hostname list */
hosthandle = rbtFind(rbhosts, hostname);
if (hosthandle != rbtEnd(rbhosts)) {
rbtKeyValue(rbhosts, hosthandle, &k1, &k2);
walk = (namelist_t *)k2;
}
else {
/* Not found - lookup in the client alias list */
hosthandle = rbtFind(rbclients, hostname);
if (hosthandle != rbtEnd(rbclients)) {
rbtKeyValue(rbclients, hosthandle, &k1, &k2);
walk = (namelist_t *)k2;
}
}
if (walk) {
/*
* Force our version of the hostname. Done here so CLIENT works always.
*/
strcpy(hostip, walk->ip);
result = strdup(walk->bbhostname);
}
else {
*hostip = '\0';
result = strdup(hostname);
}
/* If default method, just say yes */
if (ghosthandling == 0) return result;
/* Allow all summaries */
if (strcmp(hostname, "summary") == 0) return result;
if (walk && ( ((walk->notbefore > now) || (walk->notafter < now)) )) walk = NULL;
return (walk ? result : NULL);
}
void print_colheaders(FILE *output, RbtHandle rbcolumns)
{
int colcount;
RbtIterator colhandle;
colcount = 1; /* Remember the hostname column */
/* Group column headings */
fprintf(output, "<TR>");
fprintf(output, "<TD ROWSPAN=2> </TD>\n"); /* For the prio column - in both row headers+dash rows */
fprintf(output, "<TD ROWSPAN=2> </TD>\n"); /* For the host column - in both row headers+dash rows */
for (colhandle = rbtBegin(rbcolumns); (colhandle != rbtEnd(rbcolumns)); colhandle = rbtNext(rbcolumns, colhandle)) {
void *k1, *k2;
char *colname;
rbtKeyValue(rbcolumns, colhandle, &k1, &k2);
colname = (char *)k1;
colcount++;
fprintf(output, " <TD ALIGN=CENTER VALIGN=BOTTOM WIDTH=45>\n");
fprintf(output, " <A HREF=\"%s\"><FONT %s><B>%s</B></FONT></A> </TD>\n",
columnlink(colname), xgetenv("XYMONPAGECOLFONT"), colname);
}
fprintf(output, "</TR>\n");
fprintf(output, "<TR><TD COLSPAN=%d><HR WIDTH=\"100%%\"></TD></TR>\n\n", colcount);
}
/* io_addr is address of buff (&buf) */
int ofi_mr_retrieve_and_verify(struct ofi_util_mr * in_mr_h, ssize_t in_len,
uintptr_t *io_addr, uint64_t in_key,
uint64_t in_access, void **out_prov_mr)
{
int ret = 0;
void * itr;
struct fi_mr_attr * item;
void * key = &in_key;
itr = rbtFind(in_mr_h->map_handle, key);
if (!itr)
return -FI_EINVAL;
rbtKeyValue(in_mr_h->map_handle, itr, &key, (void **) &item);
/*return providers MR struct */
if (!item || !io_addr)
return -FI_EINVAL;
if (out_prov_mr)
(*out_prov_mr) = item->context;
/*offset for scalable */
if (in_mr_h->mr_type == FI_MR_SCALABLE)
*io_addr = (*io_addr) + item->offset;
ret = verify_addr(in_mr_h, item, in_access, *io_addr, in_len);
return ret;
}
void *gettreeitem(RbtHandle tree, RbtIterator handle)
{
void *k1, *k2;
rbtKeyValue(tree, handle, &k1, &k2);
return k2;
}
int ofi_mr_erase(struct ofi_util_mr * in_mr_h, uint64_t in_key)
{
void * itr;
struct fi_mr_attr * item;
if (!in_mr_h)
return -FI_EINVAL;
itr = rbtFind(in_mr_h->map_handle, &in_key);
if (!itr)
return -FI_ENOKEY;
/*release memory */
rbtKeyValue(in_mr_h->map_handle, itr, (void **)&in_key,
(void **) &item);
assert(item);
free((void *)item->mr_iov);
free(item);
rbtErase(in_mr_h->map_handle, itr);
return 0;
}
static RbtHandle findrec(char *key)
{
RbtHandle handle;
handle = rbtFind(rbconf, key);
if (handle == rbtEnd(rbconf)) {
/* Check if there's a clone pointer record */
char *clonekey, *p;
clonekey = strdup(key);
p = strchr(clonekey, '|');
if (p && *(p+1)) { *p = '='; *(p+1) = '\0'; }
handle = rbtFind(rbconf, clonekey);
xfree(clonekey);
if (handle != rbtEnd(rbconf)) {
void *k1, *k2;
char *pointsto;
char *service;
/* Get the origin record for this cloned record, using the same service name */
rbtKeyValue(rbconf, handle, &k1, &k2);
pointsto = (char *)k2;
service = strchr(key, '|'); if (service) service++;
clonekey = (char *)malloc(strlen(pointsto) + strlen(service) + 2);
sprintf(clonekey, "%s|%s", pointsto, service);
handle = rbtFind(rbconf, clonekey);
xfree(clonekey);
}
}
return handle;
}
int ofi_mr_verify(struct ofi_mr_map *map, uintptr_t *io_addr,
size_t len, uint64_t key, uint64_t access,
void **context)
{
struct fi_mr_attr *attr;
void *itr, *key_ptr, *addr;
itr = rbtFind(map->rbtree, &key);
if (!itr)
return -FI_EINVAL;
rbtKeyValue(map->rbtree, itr, &key_ptr, (void **) &attr);
assert(attr);
if ((access & attr->access) != access) {
FI_DBG(map->prov, FI_LOG_MR, "verify_addr: invalid access\n");
return -FI_EACCES;
}
addr = (void *) (*io_addr + (uintptr_t) attr->offset);
if ((addr < attr->mr_iov[0].iov_base) ||
(((char *) addr + len) > ((char *) attr->mr_iov[0].iov_base +
attr->mr_iov[0].iov_len))) {
return -FI_EACCES;
}
if (context)
*context = attr->context;
*io_addr = (uintptr_t) addr;
return 0;
}
void print_oneprio(FILE *output, RbtHandle rbstate, RbtHandle rbcolumns, int prio)
{
RbtIterator hhandle;
int firsthost = 1;
char *curhost = "";
/* Then output each host and their column status */
for (hhandle = rbtBegin(rbstate); (hhandle != rbtEnd(rbstate)); hhandle = rbtNext(rbstate, hhandle)) {
void *k1, *k2;
hstatus_t *itm;
rbtKeyValue(rbstate, hhandle, &k1, &k2);
itm = (hstatus_t *)k2;
if (itm->config->priority != prio) continue;
if (strcmp(curhost, itm->hostname) == 0) continue;
/* New host */
curhost = itm->hostname;
print_hoststatus(output, itm, rbcolumns, prio, firsthost);
firsthost = 0;
}
/* If we did output any hosts, make some room for the next priority */
if (!firsthost) fprintf(output, "<TR><TD> </TD></TR>\n");
}
int delete_nkconfig(char *dropkey, int evenifcloned)
{
RbtHandle handle;
void *k1, *k2;
handle = rbtFind(rbconf, dropkey);
if (handle == rbtEnd(rbconf)) return 0;
if (!evenifcloned) {
/* Check if this record has any clones attached to it */
char *hostname, *p;
hostname = strdup(dropkey);
p = strchr(hostname, '|'); if (p) *p = '\0';
handle = rbtBegin(rbconf);
while (handle != rbtEnd(rbconf)) {
void *k1, *k2;
char *key, *ptr;
rbtKeyValue(rbconf, handle, &k1, &k2);
key = (char *)k1; ptr = (char *)k2;
if ((*(key + strlen(key) - 1) == '=') && (strcmp(hostname, ptr) == 0)) {
xfree(hostname);
return 1;
}
handle = rbtNext(rbconf, handle);
}
xfree(hostname);
}
handle = rbtFind(rbconf, dropkey);
if (handle != rbtEnd(rbconf)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
rbtErase(rbconf, handle);
flushrec(k1, k2);
}
return 0;
}
static struct ofi_mr_entry *ofi_mr_rbt_storage_find(struct ofi_mr_storage *storage,
const struct iovec *key)
{
struct ofi_mr_entry *entry;
RbtIterator iter = rbtFind((RbtHandle)storage->storage, (void *)key);
if (OFI_UNLIKELY(!iter))
return iter;
rbtKeyValue(storage->storage, iter, (void *)&key, (void *)&entry);
return entry;
}
void *ofi_mr_get(struct ofi_mr_map *map, uint64_t key)
{
struct fi_mr_attr *attr;
void *itr, *key_ptr;
itr = rbtFind(map->rbtree, &key);
if (!itr)
return NULL;
rbtKeyValue(map->rbtree, itr, &key_ptr, (void **) &attr);
return attr->context;
}
struct psmx_fid_mr *psmx_mr_get(struct psmx_fid_domain *domain, uint64_t key)
{
RbtIterator it;
struct psmx_fid_mr *mr;
it = rbtFind(domain->mr_map, (void *)key);
if (!it)
return NULL;
rbtKeyValue(domain->mr_map, it, (void **)&key, (void **)&mr);
return mr;
}
struct sock_mr *sock_mr_get_entry(struct sock_domain *domain, uint64_t key)
{
RbtIterator it;
void *value;
void *mr_key = &key;
it = rbtFind(domain->mr_heap, mr_key);
if (!it)
return NULL;
rbtKeyValue(domain->mr_heap, it, &mr_key, &value);
return (struct sock_mr *) value;
}
static int psmx_ns_map_lookup(int *service, psm_epid_t *name_out)
{
RbtIterator it;
void *key;
it = rbtFind(psmx_ns_map, (void *)(uintptr_t)(*service));
if (!it)
return -FI_ENOENT;
rbtKeyValue(psmx_ns_map, it, &key, (void **)name_out);
if (*service == PSMX_ANY_SERVICE)
*service = (uintptr_t)key;
return 0;
}
int ofi_mr_remove(struct ofi_mr_map *map, uint64_t key)
{
struct fi_mr_attr *attr;
void *itr, *key_ptr;
itr = rbtFind(map->rbtree, &key);
if (!itr)
return -FI_ENOKEY;
rbtKeyValue(map->rbtree, itr, &key_ptr, (void **) &attr);
rbtErase(map->rbtree, itr);
free(attr);
return 0;
}
void * ofi_mr_retrieve(struct ofi_util_mr * in_mr_h, uint64_t in_key)
{
void * itr;
struct fi_mr_attr * item;
void * key = &in_key;
itr = rbtFind(in_mr_h->map_handle, key);
if (!itr)
return NULL;
rbtKeyValue(in_mr_h->map_handle, itr, (void **)&key,
(void **) &item);
return item->context;
}
void generate_critpage(FILE *output, char *hfprefix)
{
RbtIterator hhandle;
int color = COL_GREEN;
int maxprio = 0;
/* Determine background color and max. priority */
for (hhandle = rbtBegin(rbstate); (hhandle != rbtEnd(rbstate)); hhandle = rbtNext(rbstate, hhandle)) {
void *k1, *k2;
hstatus_t *itm;
rbtKeyValue(rbstate, hhandle, &k1, &k2);
itm = (hstatus_t *)k2;
if (itm->color > color) color = itm->color;
if (itm->config->priority > maxprio) maxprio = itm->config->priority;
}
headfoot(output, hfprefix, "", "header", color);
fprintf(output, "<center>\n");
if (color != COL_GREEN) {
RbtHandle rbcolumns;
int prio;
rbcolumns = columnlist(rbstate);
fprintf(output, "<TABLE BORDER=0 CELLPADDING=4 SUMMARY=\"Critical status display\">\n");
print_colheaders(output, rbcolumns);
for (prio = 1; (prio <= maxprio); prio++) {
print_oneprio(output, rbstate, rbcolumns, prio);
}
fprintf(output, "</TABLE>\n");
rbtDelete(rbcolumns);
}
else {
/* "All Monitored Systems OK */
fprintf(output, "%s", xgetenv("XYMONALLOKTEXT"));
}
fprintf(output, "</center>\n");
headfoot(output, hfprefix, "", "footer", color);
}
static int util_ns_map_lookup(struct util_ns *ns, void *service_in,
void *name_out)
{
RbtIterator it;
void *key, *name;
it = rbtFind(ns->ns_map, service_in);
if (!it)
return -FI_ENOENT;
rbtKeyValue(ns->ns_map, it, &key, (void **)&name);
memcpy(name_out, name, ns->name_len);
if (ns->is_service_wildcard && ns->is_service_wildcard(service_in))
memcpy(service_in, key, ns->service_len);
return FI_SUCCESS;
}
static void psmx_ns_map_del(int service, psm_epid_t name_in)
{
RbtIterator it;
void *key;
psm_epid_t name;
it = rbtFind(psmx_ns_map, (void *)(uintptr_t)service);
if (it) {
rbtKeyValue(psmx_ns_map, it, &key, (void **)&name);
if (name != name_in) {
FI_WARN(&psmx_prov, FI_LOG_CORE,
"failed to delete address for service %u: "
"expecting <%lx>, got <%lx>.\n",
service, name_in, name);
return;
}
rbtErase(psmx_ns_map, it);
}
}
void dropclone_nkconfig(char *drop)
{
RbtHandle handle;
char *key;
void *k1, *k2;
char *dropkey, *dropsrc;
key = (char *)malloc(strlen(drop) + 2);
sprintf(key, "%s=", drop);
handle = rbtFind(rbconf, key);
if (handle == rbtEnd(rbconf)) return;
rbtKeyValue(rbconf, handle, &k1, &k2);
dropkey = k1; dropsrc = k2;
rbtErase(rbconf, handle);
xfree(dropkey); xfree(dropsrc);
xfree(key);
}
RbtHandle columnlist(RbtHandle statetree)
{
RbtHandle rbcolumns;
RbtIterator hhandle;
rbcolumns = rbtNew(name_compare);
for (hhandle = rbtBegin(statetree); (hhandle != rbtEnd(statetree)); hhandle = rbtNext(statetree, hhandle)) {
void *k1, *k2;
hstatus_t *itm;
RbtStatus status;
rbtKeyValue(statetree, hhandle, &k1, &k2);
itm = (hstatus_t *)k2;
status = rbtInsert(rbcolumns, itm->testname, NULL);
}
return rbcolumns;
}
void *hostinfo(char *hostname)
{
RbtIterator hosthandle;
namelist_t *result = NULL;
time_t now = getcurrenttime(NULL);
if (!configloaded) load_hostnames(xgetenv("BBHOSTS"), NULL, get_fqdn());
hosthandle = rbtFind(rbhosts, hostname);
if (hosthandle != rbtEnd(rbhosts)) {
void *k1, *k2;
rbtKeyValue(rbhosts, hosthandle, &k1, &k2);
result = (namelist_t *)k2;
if ((result->notbefore > now) || (result->notafter < now)) return NULL;
}
return result;
}
static int util_ns_map_del(struct util_ns *ns, void *service_in,
void *name_in)
{
RbtIterator it;
int ret = -FI_ENOENT;
void *service, *name;
it = rbtFind(ns->ns_map, service_in);
if (it) {
rbtKeyValue(ns->ns_map, it, &service, &name);
if (memcmp(name, name_in, ns->name_len))
return ret;
free(service);
free(name);
rbtErase(ns->ns_map, it);
ret = FI_SUCCESS;
}
return ret;
}
void print_hoststatus(FILE *output, hstatus_t *itm, RbtHandle columns, int prio, int firsthost)
{
void *hinfo;
char *dispname, *ip, *key;
time_t now;
RbtIterator colhandle;
now = getcurrenttime(NULL);
hinfo = hostinfo(itm->hostname);
dispname = xmh_item(hinfo, XMH_DISPLAYNAME);
ip = xmh_item(hinfo, XMH_IP);
fprintf(output, "<TR>\n");
/* Print the priority */
fprintf(output, "<TD ALIGN=LEFT VALIGN=TOP WIDTH=25%% NOWRAP>");
if (firsthost)
fprintf(output, "<FONT %s>PRIO %d</FONT>", xgetenv("XYMONPAGEROWFONT"), prio);
else
fprintf(output, " ");
fprintf(output, "</TD>\n");
/* Print the hostname with a link to the critical systems info page */
fprintf(output, "<TD ALIGN=LEFT>%s</TD>\n", hostnamehtml(itm->hostname, NULL, usetooltips));
key = (char *)malloc(strlen(itm->hostname) + 1024);
for (colhandle = rbtBegin(columns); (colhandle != rbtEnd(columns)); colhandle = rbtNext(columns, colhandle)) {
void *k1, *k2;
char *colname;
RbtIterator sthandle;
fprintf(output, "<TD ALIGN=CENTER>");
rbtKeyValue(columns, colhandle, &k1, &k2);
colname = (char *)k1;
sprintf(key, "%s|%s", itm->hostname, colname);
sthandle = rbtFind(rbstate, key);
if (sthandle == rbtEnd(rbstate)) {
fprintf(output, "-");
}
else {
hstatus_t *column;
char *htmlalttag;
char *htmlackstr;
rbtKeyValue(rbstate, sthandle, &k1, &k2);
column = (hstatus_t *)k2;
if (column->config->priority != prio)
fprintf(output, "-");
else {
time_t age = now - column->lastchange;
char *htmlgroupstr;
char *htmlextrastr;
htmlalttag = alttag(colname, column->color, 0, 1, agestring(age));
htmlackstr = (column->ackmsg ? column->ackmsg : "");
htmlgroupstr = strdup(urlencode(column->config->ttgroup ? column->config->ttgroup : ""));
htmlextrastr = strdup(urlencode(column->config->ttextra ? column->config->ttextra : ""));
fprintf(output, "<A HREF=\"%s&NKPRIO=%d&NKTTGROUP=%s&NKTTEXTRA=%s\">",
hostsvcurl(itm->hostname, colname, 1),
prio,
htmlgroupstr, htmlextrastr);
fprintf(output, "<IMG SRC=\"%s/%s\" ALT=\"%s\" TITLE=\"%s %s\" HEIGHT=\"%s\" WIDTH=\"%s\" BORDER=0></A>",
xgetenv("XYMONSKIN"),
dotgiffilename(column->color, (column->acktime > 0), (age > oldlimit)),
colorname(column->color), htmlalttag, htmlackstr,
xgetenv("DOTHEIGHT"), xgetenv("DOTWIDTH"));
xfree(htmlgroupstr);
xfree(htmlextrastr);
}
}
fprintf(output, "</TD>\n");
}
xfree(key);
fprintf(output, "</TR>\n");
}
nkconf_t *get_nkconfig(char *key, int flags, char **resultkey)
{
static RbtHandle handle;
static char *realkey = NULL;
void *k1, *k2;
nkconf_t *result = NULL;
int isclone;
if (resultkey) *resultkey = NULL;
switch (flags) {
case NKCONF_TIMEFILTER:
handle = findrec(key);
/* We may have hit a cloned record, so use the real key for further searches */
if (handle != rbtEnd(rbconf)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
realkey = k1;
}
while (handle != rbtEnd(rbconf)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
result = (nkconf_t *)k2;
if (timecheck(result->starttime, result->endtime, result->nktime)) return result;
/* Go to the next */
handle = rbtNext(rbconf, handle);
if (handle != rbtEnd(rbconf)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
if (strncmp(realkey, ((nkconf_t *)k2)->key, strlen(realkey)) != 0) handle=rbtEnd(rbconf);
}
}
realkey = NULL;
break;
case NKCONF_FIRSTMATCH:
handle = findrec(key);
realkey = NULL;
if (handle != rbtEnd(rbconf)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
realkey = (char *)k1;
}
break;
case NKCONF_FIRST:
realkey = NULL;
handle = rbtBegin(rbconf);
if (handle == rbtEnd(rbconf)) return NULL;
do {
rbtKeyValue(rbconf, handle, &k1, &k2);
realkey = (char *)k1;
isclone = (*(realkey + strlen(realkey) - 1) == '=');
if (isclone) handle = rbtNext(rbconf, handle);
} while (isclone && (handle != rbtEnd(rbconf)));
break;
case NKCONF_NEXT:
if (!realkey || (handle == rbtEnd(rbconf))) return NULL;
isclone = 1;
while (isclone && (handle != rbtEnd(rbconf))) {
handle = rbtNext(rbconf, handle);
if (handle) {
rbtKeyValue(rbconf, handle, &k1, &k2);
realkey = (char *)k1;
isclone = (*(realkey + strlen(realkey) - 1) == '=');
}
}
break;
case NKCONF_RAW_FIRST:
handle = rbtBegin(rbconf);
realkey = NULL;
break;
case NKCONF_RAW_NEXT:
handle = rbtNext(rbconf, handle);
realkey = NULL;
break;
case NKCONF_FIRSTHOSTMATCH:
do {
int found = 0;
char *delim;
realkey = NULL;
handle = rbtBegin(rbconf);
while (!found && (handle != rbtEnd(rbconf))) {
rbtKeyValue(rbconf, handle, &k1, &k2);
realkey = (char *)k1;
delim = realkey + strlen(key); /* OK even if past end of realkey */
found = ((strncmp(realkey, key, strlen(key)) == 0) &&
((*delim == '|') || (*delim == '=')));
if (!found) { handle = rbtNext(rbconf, handle); realkey = NULL; }
}
if ((handle != rbtEnd(rbconf)) && (*(realkey + strlen(realkey) - 1) == '=')) {
key = (char *)k2;
isclone = 1;
}
else isclone = 0;
} while (isclone && (handle != rbtEnd(rbconf)));
break;
}
if (handle == rbtEnd(rbconf)) { realkey = NULL; return NULL; }
rbtKeyValue(rbconf, handle, &k1, &k2);
if (resultkey) *resultkey = (char *)k1;
result = (nkconf_t *)k2;
return result;
}
int update_nkconfig(nkconf_t *rec)
{
char *bakfn;
FILE *bakfd;
unsigned char buf[8192];
int n;
struct stat st;
struct utimbuf ut;
RbtHandle handle;
FILE *fd;
int result = 0;
/* First, copy the old file */
bakfn = (char *)malloc(strlen(configfn) + 5);
sprintf(bakfn, "%s.bak", configfn);
if (stat(configfn, &st) == 0) {
ut.actime = st.st_atime;
ut.modtime = st.st_mtime;
}
else ut.actime = ut.modtime = getcurrenttime(NULL);
fd = fopen(configfn, "r");
if (fd) {
bakfd = fopen(bakfn, "w");
if (bakfd) {
while ((n = fread(buf, 1, sizeof(buf), fd)) > 0) fwrite(buf, 1, n, bakfd);
fclose(bakfd);
utime(bakfn, &ut);
}
fclose(fd);
}
xfree(bakfn);
fd = fopen(configfn, "w");
if (fd == NULL) {
errprintf("Cannot open output file %s\n", configfn);
return 1;
}
if (rec) {
handle = rbtFind(rbconf, rec->key);
if (handle == rbtEnd(rbconf)) rbtInsert(rbconf, rec->key, rec);
}
handle = rbtBegin(rbconf);
while (handle != rbtEnd(rbconf)) {
void *k1, *k2;
char *onekey;
rbtKeyValue(rbconf, handle, &k1, &k2);
onekey = (char *)k1;
if (*(onekey + strlen(onekey) - 1) == '=') {
char *pointsto = (char *)k2;
char *hostname;
hostname = strdup(onekey);
*(hostname + strlen(hostname) - 1) = '\0';
fprintf(fd, "%s|=%s\n", hostname, pointsto);
}
else {
nkconf_t *onerec = (nkconf_t *)k2;
char startstr[20], endstr[20];
*startstr = *endstr = '\0';
if (onerec->starttime > 0) sprintf(startstr, "%d", (int)onerec->starttime);
if (onerec->endtime > 0) sprintf(endstr, "%d", (int)onerec->endtime);
fprintf(fd, "%s|%s|%s|%s|%d|%s|%s|%s\n",
onekey,
startstr, endstr,
(onerec->nktime ? onerec->nktime : ""),
onerec->priority,
(onerec->ttgroup ? onerec->ttgroup : ""),
(onerec->ttextra ? onerec->ttextra : ""),
(onerec->updinfo ? onerec->updinfo : ""));
}
handle = rbtNext(rbconf, handle);
}
fclose(fd);
return result;
}
int load_nkconfig(char *fn)
{
static void *configfiles = NULL;
static int firsttime = 1;
FILE *fd;
strbuffer_t *inbuf;
/* Setup the default configuration filename */
if (!fn) {
if (!defaultfn) {
char *bbhome = xgetenv("BBHOME");
defaultfn = (char *)malloc(strlen(bbhome) + strlen(DEFAULTCONFIG) + 2);
sprintf(defaultfn, "%s/%s", bbhome, DEFAULTCONFIG);
}
fn = defaultfn;
}
if (configfn) xfree(configfn);
configfn = strdup(fn);
/* First check if there were no modifications at all */
if (configfiles) {
if (!stackfmodified(configfiles)){
dbgprintf("No files modified, skipping reload of %s\n", fn);
return 0;
}
else {
stackfclist(&configfiles);
configfiles = NULL;
}
}
if (!firsttime) {
/* Clean up existing datatree */
RbtHandle handle;
void *k1, *k2;
for (handle = rbtBegin(rbconf); (handle != rbtEnd(rbconf)); handle = rbtNext(rbconf, handle)) {
rbtKeyValue(rbconf, handle, &k1, &k2);
flushrec(k1, k2);
}
rbtDelete(rbconf);
}
firsttime = 0;
rbconf = rbtNew(name_compare);
fd = stackfopen(fn, "r", &configfiles);
if (fd == NULL) return 1;
inbuf = newstrbuffer(0);
while (stackfgets(inbuf, NULL)) {
/* Full record : Host service START END TIMESPEC TTPrio TTGroup TTExtra */
/* Clone record: Host =HOST */
char *ehost, *eservice, *estart, *eend, *etime, *ttgroup, *ttextra, *updinfo;
int ttprio = 0;
nkconf_t *newitem;
RbtStatus status;
int idx = 0;
ehost = gettok(STRBUF(inbuf), "|\n"); if (!ehost) continue;
eservice = gettok(NULL, "|\n"); if (!eservice) continue;
if (*eservice == '=') {
char *key = (char *)malloc(strlen(ehost) + 2);
char *pointsto = strdup(eservice+1);
sprintf(key, "%s=", ehost);
status = rbtInsert(rbconf, key, pointsto);
}
else {
estart = gettok(NULL, "|\n"); if (!estart) continue;
eend = gettok(NULL, "|\n"); if (!eend) continue;
etime = gettok(NULL, "|\n"); if (!etime) continue;
ttprio = atoi(gettok(NULL, "|\n")); if (ttprio == 0) continue;
ttgroup = gettok(NULL, "|\n");
ttextra = gettok(NULL, "|\n");
updinfo = gettok(NULL, "|\n");
newitem = (nkconf_t *)malloc(sizeof(nkconf_t));
newitem->key = (char *)malloc(strlen(ehost) + strlen(eservice) + 15);
sprintf(newitem->key, "%s|%s", ehost, eservice);
newitem->starttime= ((estart && *estart) ? atoi(estart) : 0);
newitem->endtime = ((eend && *eend) ? atoi(eend) : 0);
newitem->nktime = ((etime && *etime) ? strdup(etime) : NULL);
newitem->priority = ttprio;
newitem->ttgroup = strdup(ttgroup);
newitem->ttextra = strdup(ttextra);
newitem->updinfo = strdup(updinfo);
status = rbtInsert(rbconf, newitem->key, newitem);
while (status == RBT_STATUS_DUPLICATE_KEY) {
idx++;
sprintf(newitem->key, "%s|%s|%d", ehost, eservice, idx);
status = rbtInsert(rbconf, newitem->key, newitem);
}
}
}
stackfclose(fd);
freestrbuffer(inbuf);
if (debug) {
RbtHandle handle;
handle = rbtBegin(rbconf);
while (handle != rbtEnd(rbconf)) {
void *k1, *k2;
rbtKeyValue(rbconf, handle, &k1, &k2);
printf("%s\n", (char *)k1);
handle = rbtNext(rbconf, handle);
}
}
return 0;
}