void save_state(void) { char *tmpdir; char *fn; FILE *fd; int tidx; tmpdir = xgetenv("XYMONTMP"); if (!tmpdir) tmpdir = "/tmp"; fn = (char *)malloc(strlen(tmpdir) + 100); sprintf(fn, "%s/locator.servers.chk", tmpdir); fd = fopen(fn, "w"); if (fd == NULL) { errprintf("Cannot save state to %s: %s\n", fn, strerror(errno)); return; } for (tidx = 0; (tidx < ST_MAX); tidx++) { const char *tname = servicetype_names[tidx]; xtreePos_t handle; serverinfo_t *itm; for (handle = xtreeFirst(sitree[tidx]); (handle != xtreeEnd(sitree[tidx])); handle = xtreeNext(sitree[tidx], handle)) { itm = xtreeData(sitree[tidx], handle); fprintf(fd, "%s|%s|%d|%d|%d|%s\n", tname, itm->servername, itm->serverconfweight, itm->serveractualweight, ((itm->sticky == LOC_STICKY) ? 1 : 0), (itm->serverextras ? itm->serverextras : "")); } } fclose(fd); sprintf(fn, "%s/locator.hosts.chk", tmpdir); fd = fopen(fn, "w"); if (fd == NULL) { errprintf("Cannot save state to %s: %s\n", fn, strerror(errno)); return; } for (tidx = 0; (tidx < ST_MAX); tidx++) { const char *tname = servicetype_names[tidx]; xtreePos_t handle; hostinfo_t *itm; for (handle = xtreeFirst(hitree[tidx]); (handle != xtreeEnd(hitree[tidx])); handle = xtreeNext(hitree[tidx], handle)) { itm = xtreeData(hitree[tidx], handle); if (itm->server) { fprintf(fd, "%s|%s|%s\n", tname, itm->hostname, itm->server->servername); } } } fclose(fd); }
void print_oneprio(FILE *output, void * statetree, void * hoptree, void * rbcolumns, int prio) { xtreePos_t hhandle; static int firsthostever = 1; int firsthostthisprio = 1; char *curhost = ""; /* Then output each host and their column status */ for (hhandle = xtreeFirst(statetree); (hhandle != xtreeEnd(statetree)); hhandle = xtreeNext(statetree, hhandle)) { hstatus_t *itm; itm = (hstatus_t *)xtreeData(statetree, hhandle); if (itm->config->priority != prio) continue; if (strcmp(curhost, itm->hostname) == 0) continue; /* New host */ curhost = itm->hostname; print_hoststatus(output, itm, statetree, rbcolumns, prio, firsthostthisprio, firsthostever); xtreeAdd(hoptree, itm->hostname, itm); firsthostthisprio = 0; } /* If we did output any hosts, make some room for the next priority */ if (!firsthostthisprio) fprintf(output, "<TR><TD> </TD></TR>\n"); }
static void reset_holidays(void) { static int firsttime = 1; xtreePos_t handle; holidayset_t *hset; holiday_t *walk, *zombie; if (!firsttime) { for (handle = xtreeFirst(holidays); (handle != xtreeEnd(holidays)); handle = xtreeNext(holidays, handle)) { hset = (holidayset_t *)xtreeData(holidays, handle); xfree(hset->key); walk = hset->head; while (walk) { zombie = walk; walk = walk->next; xfree(zombie->desc); xfree(zombie); } } xtreeDestroy(holidays); } holidays_like_weekday = -1; firsttime = 0; holidays = xtreeNew(strcasecmp); }
void save_session_cookies(void) { FILE *fd = NULL; char cookiefn[PATH_MAX]; xtreePos_t h; hcookie_t *itm; sprintf(cookiefn, "%s/etc/cookies.session", xgetenv("XYMONHOME")); fd = fopen(cookiefn, "w"); if (fd == NULL) return; for (h=xtreeFirst(cookietree); (h != xtreeEnd(cookietree)); h = xtreeNext(cookietree, h)) { char *urlhost, *ckpath, *cknam; itm = (hcookie_t *)xtreeData(cookietree, h); urlhost = strtok(itm->key, "\t"); cknam = strtok(NULL, "\t"); ckpath = strtok(NULL, "\t"); fprintf(fd, "%s\tFALSE\t%s\tFALSE\t0\t%s\t%s\n", urlhost, ckpath, cknam, itm->val); } fclose(fd); }
void clean_all_active(void) { xtreePos_t handle; for (handle = xtreeFirst(hostnames); handle != xtreeEnd(hostnames); handle = xtreeNext(hostnames, handle)) { alertanchor_t *anchor = (alertanchor_t *)xtreeData(hostnames, handle); clean_active(anchor); } }
activealerts_t *alistBegin(void) { alisthandle = xtreeFirst(hostnames); alistwalk = NULL; while ((alisthandle != xtreeEnd(hostnames)) && (alistwalk == NULL)) { alertanchor_t *anchor = (alertanchor_t *)xtreeData(hostnames, alisthandle); alistwalk = anchor->head; if (alistwalk == NULL) alisthandle = xtreeNext(hostnames, alisthandle); } return alistwalk; }
void * columnlist(void * statetree) { void * rbcolumns; xtreePos_t hhandle; rbcolumns = xtreeNew(strcasecmp); for (hhandle = xtreeFirst(statetree); (hhandle != xtreeEnd(statetree)); hhandle = xtreeNext(statetree, hhandle)) { hstatus_t *itm; itm = (hstatus_t *)xtreeData(statetree, hhandle); xtreeAdd(rbcolumns, itm->testname, NULL); } return rbcolumns; }
void recalc_current(enum locator_servicetype_t stype) { /* Point our "last-used-server" pointer at the server with the most negative weight */ xtreePos_t handle, wantedserver; serverinfo_t *oneserver; int minweight = INT_MAX; wantedserver = xtreeEnd(sitree[stype]); for (handle = xtreeFirst(sitree[stype]); (handle != xtreeEnd(sitree[stype])); handle = xtreeNext(sitree[stype], handle)) { oneserver = (serverinfo_t *)xtreeData(sitree[stype], handle); if (oneserver->serveractualweight < minweight) { wantedserver = handle; minweight = oneserver->serveractualweight; } } sicurrent[stype] = wantedserver; }
void locator_flushcache(enum locator_servicetype_t svc, char *key) { xtreePos_t handle; if (!havecache[svc]) return; if (key) { handle = xtreeFind(locatorcache[svc], key); if (handle != xtreeEnd(locatorcache[svc])) { cacheitm_t *itm = (cacheitm_t *)xtreeData(locatorcache[svc], handle); itm->tstamp = 0; } } else { for (handle = xtreeFirst(locatorcache[svc]); (handle != xtreeEnd(locatorcache[svc])); handle = xtreeNext(locatorcache[svc], handle)) { cacheitm_t *itm = (cacheitm_t *)xtreeData(locatorcache[svc], handle); itm->tstamp = 0; } } }
serverinfo_t *downup_server(char *servername, enum locator_servicetype_t servicetype, char action) { xtreePos_t handle; serverinfo_t *itm = NULL; handle = xtreeFind(sitree[servicetype], servername); if (handle == xtreeEnd(sitree[servicetype])) return NULL; /* Update existing item */ itm = xtreeData(sitree[servicetype], handle); switch (action) { case 'F': /* Flag the hosts that point to this server as un-assigned */ for (handle = xtreeFirst(hitree[servicetype]); (handle != xtreeEnd(hitree[servicetype])); handle = xtreeNext(hitree[servicetype], handle)) { hostinfo_t *hitm = (hostinfo_t *)xtreeData(hitree[servicetype], handle); if (hitm->server == itm) hitm->server = NULL; } /* Fall through */ case 'D': dbgprintf("Downing server '%s' type %s\n", servername, servicetype_names[servicetype]); itm->serveractualweight = 0; itm->serverweightleft = 0; if (itm->serverconfweight < 0) recalc_current(servicetype); break; case 'U': dbgprintf("Upping server '%s' type %s to weight %d\n", servername, servicetype_names[servicetype], itm->serverconfweight); itm->serveractualweight = itm->serverconfweight; /* Dont mess with serverweightleft - this may just be an "i'm alive" message */ if (itm->serverconfweight < 0) recalc_current(servicetype); break; } return itm; }
void print_colheaders(FILE *output, void * rbcolumns) { int colcount; xtreePos_t 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 = xtreeFirst(rbcolumns); (colhandle != xtreeEnd(rbcolumns)); colhandle = xtreeNext(rbcolumns, colhandle)) { char *colname; colname = (char *)xtreeKey(rbcolumns, colhandle); 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); }
void send_test_results(listhead_t *head, char *collector, int issubmodule, char *location, int usebackfeed) { char msgline[4096]; listitem_t *walk; xtreePos_t handle; void *hostresults = xtreeNew(strcasecmp); if (usebackfeed) combo_start_local(); else combo_start(); for (walk = head->head; (walk); walk = walk->next) { hostresult_t *hres; myconn_t *rec = (myconn_t *)walk->data; char *s; if (rec->ignoreresult) continue; switch (rec->talkprotocol) { case TALK_PROTO_PING: if (!issubmodule && (rec->talkresult == TALK_OK)) { add_to_sub_queue(rec, "ping", location, NULL); continue; } break; #ifdef HAVE_LDAP case TALK_PROTO_LDAP: if (!issubmodule && (rec->talkresult == TALK_OK)) { char *creds = xmh_item(rec->hostinfo, XMH_LDAPLOGIN); add_to_sub_queue(rec, "ldap", location, creds, NULL); continue; } break; #endif case TALK_PROTO_EXTERNAL: if (!issubmodule && (rec->talkresult == TALK_OK)) { if (strncmp(rec->testspec, "rpc=", 4) == 0) add_to_sub_queue(rec, "rpc", location, NULL); else add_to_sub_queue(rec, rec->testspec, location, NULL); continue; } break; default: break; } handle = xtreeFind(hostresults, xmh_item(rec->hostinfo, XMH_HOSTNAME)); if (handle == xtreeEnd(hostresults)) { hres = (hostresult_t *)calloc(1, sizeof(hostresult_t)); hres->hinfo = rec->hostinfo; hres->txt = newstrbuffer(0); xtreeAdd(hostresults, xmh_item(rec->hostinfo, XMH_HOSTNAME), hres); snprintf(msgline, sizeof(msgline), "client/%s %s.netcollect netcollect\n", collector, xmh_item(rec->hostinfo, XMH_HOSTNAME)); addtobuffer(hres->txt, msgline); } else { hres = xtreeData(hostresults, handle); } switch (rec->talkprotocol) { case TALK_PROTO_DNSQUERY: snprintf(msgline, sizeof(msgline), "\n[dns=%s]\n", rec->testspec); addtobuffer(hres->txt, msgline); break; case TALK_PROTO_PING: snprintf(msgline, sizeof(msgline), "\n[ping=%s]\n", rec->netparams.destinationip); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "SourceSpec: %s\n", rec->testspec); addtobuffer(hres->txt, msgline); break; default: snprintf(msgline, sizeof(msgline), "\n[%s]\n", rec->testspec); addtobuffer(hres->txt, msgline); break; } snprintf(msgline, sizeof(msgline), "Handler: %s\n", talkproto_names[rec->talkprotocol]); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "StartTime: %d\nEndTime: %d\n", (int)rec->teststarttime, (int)rec->testendtime); addtobuffer(hres->txt, msgline); if (rec->netparams.lookupstring) { snprintf(msgline, sizeof(msgline), "TargetHostname: %s\n", rec->netparams.lookupstring); addtobuffer(hres->txt, msgline); } snprintf(msgline, sizeof(msgline), "TargetIP: %s\n", rec->netparams.destinationip); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "TargetPort: %d\n", rec->netparams.destinationport); addtobuffer(hres->txt, msgline); if (rec->netparams.sourceip) { snprintf(msgline, sizeof(msgline), "SourceIP: %s\n", rec->netparams.sourceip); addtobuffer(hres->txt, msgline); } if (location) { snprintf(msgline, sizeof(msgline), "Location: %s\n", location); addtobuffer(hres->txt, msgline); } if (rec->talkprotocol == TALK_PROTO_PING) s = "ICMP"; else { switch (rec->netparams.socktype) { case CONN_SOCKTYPE_STREAM: s = "TCP"; break; case CONN_SOCKTYPE_DGRAM: s = "UDP"; break; default: s = "UNKNOWN"; break; } } snprintf(msgline, sizeof(msgline), "Protocol: %s\n", s); addtobuffer(hres->txt, msgline); switch (rec->netparams.sslhandling) { case CONN_SSL_NO: s = "NO"; break; case CONN_SSL_YES: s = "YES"; break; case CONN_SSL_STARTTLS_CLIENT: s = "STARTTLS_CLIENT"; break; case CONN_SSL_STARTTLS_SERVER: s = "STARTTLS_SERVER"; break; default: s = "UNKNOWN"; break; } snprintf(msgline, sizeof(msgline), "SSL: %s\n", s); addtobuffer(hres->txt, msgline); switch (rec->talkresult) { case TALK_CONN_FAILED: s = "CONN_FAILED"; break; case TALK_CONN_TIMEOUT: s = "CONN_TIMEOUT"; break; case TALK_OK: s = "OK"; break; case TALK_BADDATA: s = "BADDATA"; break; case TALK_BADSSLHANDSHAKE: s = "BADSSLHANDSHAKE"; break; case TALK_INTERRUPTED: s = "INTERRUPTED"; break; case TALK_CANNOT_RESOLVE: s = "CANNOT_RESOLVE"; break; case TALK_MODULE_FAILED: s = "MODULE_FAILED"; break; default: s = "UNKNOWN"; break; } snprintf(msgline, sizeof(msgline), "Status: %s\n", s); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "TestID: %lu\nElapsedMS: %d.%02d\nDNSMS: %d.%02d\nTimeoutMS: %d\nIntervalMS: %d\n", rec->testid, (rec->elapsedus / 1000), (rec->elapsedus % 1000), (rec->dnselapsedus / 1000), (rec->dnselapsedus % 1000), rec->timeout*1000, rec->interval*1000); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "BytesRead: %u\nBytesWritten: %u\n", rec->bytesread, rec->byteswritten); addtobuffer(hres->txt, msgline); if (rec->peercertificate) { char exps[50]; addtobuffer(hres->txt, "PeerCertificateSubject: "); addtobuffer(hres->txt, rec->peercertificate); addtobuffer(hres->txt, "\n"); addtobuffer(hres->txt, "PeerCertificateIssuer: "); addtobuffer(hres->txt, rec->peercertificateissuer); addtobuffer(hres->txt, "\n"); strftime(exps, sizeof(exps), "%Y-%m-%d %H:%M:%S UTC", gmtime(&rec->peercertificatestart)); snprintf(msgline, sizeof(msgline), "PeerCertificateStart: %d %s\n", (int)rec->peercertificatestart, exps); addtobuffer(hres->txt, msgline); strftime(exps, sizeof(exps), "%Y-%m-%d %H:%M:%S UTC", gmtime(&rec->peercertificateexpiry)); snprintf(msgline, sizeof(msgline), "PeerCertificateExpiry: %d %s\n", (int)rec->peercertificateexpiry, exps); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "PeerCertificateKeysize: %d\n", (int)rec->peercertificatekeysize); addtobuffer(hres->txt, msgline); snprintf(msgline, sizeof(msgline), "PeerCertificateDetails: %d\n", (int)strlen(rec->peercertificatedetails)+1); addtobuffer(hres->txt, msgline); addtobuffer(hres->txt, rec->peercertificatedetails); addtobuffer(hres->txt, "\n"); } switch (rec->talkprotocol) { case TALK_PROTO_PLAIN: result_plain(rec, hres->txt); break; case TALK_PROTO_NTP: result_ntp(rec, hres->txt); break; case TALK_PROTO_HTTP: result_http(rec, hres->txt); break; case TALK_PROTO_DNSQUERY: result_dns(rec, hres->txt); break; case TALK_PROTO_PING: result_subqueue("PING", rec, hres->txt); break; #ifdef HAVE_LDAP case TALK_PROTO_LDAP: result_subqueue("LDAP", rec, hres->txt); break; #endif case TALK_PROTO_EXTERNAL: result_subqueue(rec->testspec, rec, hres->txt); break; default: break; } } for (handle = xtreeFirst(hostresults); handle != xtreeEnd(hostresults); handle = xtreeNext(hostresults, handle)) { hostresult_t *hres = xtreeData(hostresults, handle); combo_add(hres->txt); freestrbuffer(hres->txt); xtreeDelete(hostresults, xmh_item(hres->hinfo, XMH_HOSTNAME)); xfree(hres); } xtreeDestroy(hostresults); combo_end(); }
int main(int argc, char **argv) { char buf[1024], key[1024], data[1024]; void *th = NULL; xtreePos_t n; xtreeStatus_t stat; char *rec, *p; do { printf("New, Add, Find, Delete, dUmp, deStroy : "); fflush(stdout); if (fgets(buf, sizeof(buf), stdin) == NULL) return 0; switch (*buf) { case 'N': case 'n': th = xtreeNew(strcasecmp); break; case 'A': case 'a': printf("Key:");fflush(stdout); fgets(key, sizeof(key), stdin); p = strchr(key, '\n'); if (p) *p = '\0'; printf("Data:");fflush(stdout); fgets(data, sizeof(data), stdin); p = strchr(data, '\n'); if (p) *p = '\0'; stat = xtreeAdd(th, strdup(key), strdup(data)); printf("Result: %d\n", stat); break; case 'D': case 'd': printf("Key:");fflush(stdout); fgets(key, sizeof(key), stdin); p = strchr(key, '\n'); if (p) *p = '\0'; rec = xtreeDelete(th, key); if (rec) { printf("Existing record deleted: Data was '%s'\n", rec); } else { printf("No record\n"); } break; case 'F': case 'f': printf("Key:");fflush(stdout); fgets(key, sizeof(key), stdin); p = strchr(key, '\n'); if (p) *p = '\0'; n = xtreeFind(th, key); if (n != xtreeEnd(th)) { printf("Found record: Data was '%s'\n", (char *)xtreeData(th, n)); } else { printf("No record\n"); } break; case 'U': case 'u': n = xtreeFirst(th); while (n != xtreeEnd(th)) { printf("Key '%s', data '%s'\n", (char *)xtreeKey(th, n), (char *)xtreeData(th, n)); n = xtreeNext(th, n); } break; case 'S': case 's': xtreeDestroy(th); th = NULL; break; } } while (1); return 0; }
serverinfo_t *find_server_by_type(enum locator_servicetype_t servicetype) { serverinfo_t *nextserver = NULL; xtreePos_t endmarker = xtreeEnd(sitree[servicetype]); /* * We must do weight handling here. * * Some weights (the serveractualweight attribute) have special meaning: * Negative: Only one server receives requests. We should use the * server with the lowest weight. * 0 : This server is down and cannot receive any requests. * 1 : Server is up, but should only receive requests for hosts * that have been registered as resident on this server. * >1 : Server is up and handles any request. * * When looking for a server, we do a weighted round-robin of the * servers that are available. The idea is that each server has * "serveractualweight" tokens, and we use them one by one for each * request. "serveractualweightleft" tells how many tokens are left. * When a server has been used once, we go to the next server which * has any tokens left. When all tokens have been used, we replenish * the token counts from "serveractualweight" and start over. * * sicurrent[servicetype] points to the tree-handle of the last server * that was used. */ if (sicurrent[servicetype] != endmarker) { serverinfo_t *lastserver; /* We have a last-server-used for this request */ lastserver = xtreeData(sitree[servicetype], sicurrent[servicetype]); /* * See if our the last server used handles all requests. * If it does, then sicurrent[servicetype] will ALWAYS * contain the server we want to use (it is updated * whenever servers register or weights change). */ if (lastserver->serveractualweight < 0) return lastserver; /* OK, we have now used one token from this server. */ if (lastserver->serveractualweight > 1) lastserver->serverweightleft -= 1; /* Go to the next server with any tokens left */ do { sicurrent[servicetype] = xtreeNext(sitree[servicetype], sicurrent[servicetype]); if (sicurrent[servicetype] == endmarker) { /* Start from the beginning again */ sicurrent[servicetype] = xtreeFirst(sitree[servicetype]); } nextserver = xtreeData(sitree[servicetype], sicurrent[servicetype]); } while ((nextserver->serverweightleft == 0) && (nextserver != lastserver)); if ((nextserver == lastserver) && (nextserver->serverweightleft == 0)) { /* Could not find any servers with a token left for us to use */ nextserver = NULL; } } if (nextserver == NULL) { /* Restart server RR walk */ int totalweight = 0; xtreePos_t handle, firstok; serverinfo_t *srv; firstok = endmarker; /* Walk the list of servers, calculate total weight and find the first active server */ for (handle = xtreeFirst(sitree[servicetype]); ( (handle != endmarker) && (totalweight >= 0) ); handle = xtreeNext(sitree[servicetype], handle) ) { srv = xtreeData(sitree[servicetype], handle); if (srv->serveractualweight <= 1) continue; srv->serverweightleft = (srv->serveractualweight - 1); totalweight += srv->serverweightleft; if (firstok == endmarker) firstok = handle; } sicurrent[servicetype] = firstok; nextserver = (firstok != endmarker) ? xtreeData(sitree[servicetype], firstok) : NULL; } return nextserver; }
int main(int argc, char *argv[]) { int argi; char *envarea = NULL; char **critconfig = NULL; int cccount = 0; char *hffile = "critical"; critconfig = (char **)calloc(1, sizeof(char *)); for (argi = 1; (argi < argc); argi++) { if (argnmatch(argv[argi], "--env=")) { char *p = strchr(argv[argi], '='); loadenv(p+1, envarea); } else if (argnmatch(argv[argi], "--area=")) { char *p = strchr(argv[argi], '='); envarea = strdup(p+1); } else if (strcmp(argv[argi], "--debug") == 0) { debug = 1; } else if (strcmp(argv[argi], "--tooltips") == 0) { usetooltips = 1; } else if (argnmatch(argv[argi], "--acklevel=")) { char *p = strchr(argv[argi], '='); critacklevel = atoi(p+1); } else if (argnmatch(argv[argi], "--config=")) { char *p = strchr(argv[argi], '='); critconfig[cccount] = strdup(p+1); cccount++; critconfig = (char **)realloc(critconfig, (1 + cccount)*sizeof(char *)); critconfig[cccount] = NULL; } else if (argnmatch(argv[argi], "--hffile=")) { char *p = strchr(argv[argi], '='); hffile = strdup(p+1); } } if (!critconfig[0]) { critconfig = (char **)realloc(critconfig, 2*sizeof(char *)); critconfig[0] = (char *)malloc(strlen(xgetenv("XYMONHOME")) + strlen(DEFAULT_CRITCONFIGFN) + 2); sprintf(critconfig[0], "%s/%s", xgetenv("XYMONHOME"), DEFAULT_CRITCONFIGFN); critconfig[1] = NULL; } redirect_cgilog("criticalview"); setdocurl(hostsvcurl("%s", xgetenv("INFOCOLUMN"), 1)); parse_query(); load_hostnames(xgetenv("HOSTSCFG"), NULL, get_fqdn()); load_all_links(); fprintf(stdout, "Content-type: %s\n\n", xgetenv("HTMLCONTENTTYPE")); use_recentgifs = 1; if (getboard(mincolor) == 0) { int i; char *oneconfig, *onename; int *partcolor = NULL, *partprio = NULL; xtreePos_t hhandle; for (i=0; (critconfig[i]); i++) { oneconfig = strchr(critconfig[i], ':'); load_critconfig(oneconfig ? oneconfig+1 : critconfig[i]); loadstatus(maxprio, maxage, mincolor, wantacked); /* Determine background color and max. priority */ if (i == 0) { partcolor = (int *)malloc(sizeof(int)); partprio = (int *)malloc(sizeof(int)); } else { partcolor = (int *)realloc(partcolor, (i+1)*sizeof(int)); partprio = (int *)realloc(partprio, (i+1)*sizeof(int)); } partcolor[i] = COL_GREEN; partprio[i] = 0; for (hhandle = xtreeFirst(rbstate[i]); (hhandle != xtreeEnd(rbstate[i])); hhandle = xtreeNext(rbstate[i], hhandle)) { hstatus_t *itm; itm = (hstatus_t *)xtreeData(rbstate[i], hhandle); if (itm->color > partcolor[i]) partcolor[i] = itm->color; if (itm->config->priority > partprio[i]) partprio[i] = itm->config->priority; } if (partcolor[i] > pagecolor) pagecolor = partcolor[i]; } for (i=0; (critconfig[i]); i++) { oneconfig = strchr(critconfig[i], ':'); if (oneconfig) { *oneconfig = '\0'; oneconfig++; onename = (char *)malloc(strlen("DIVIDERTEXT=") + strlen(critconfig[i]) + 1); sprintf(onename, "DIVIDERTEXT=%s", critconfig[i]); putenv(onename); } else { oneconfig = critconfig[i]; putenv("DIVIDERTEXT="); } generate_critpage(rbstate[i], hostsonpage[i], stdout, (i == 0) ? (critconfig[1] ? "critmulti" : hffile) : "divider", (critconfig[i+1] == NULL) ? hffile : "divider", partcolor[i], partprio[i]); } } else { fprintf(stdout, "Cannot load Xymon status\n"); } return 0; }
int load_holidays(int year) { static void *configholidays = NULL; char fn[PATH_MAX]; FILE *fd; strbuffer_t *inbuf; holiday_t newholiday; xtreePos_t handle, commonhandle; char *setname = NULL; holidayset_t *commonhols; MEMDEFINE(fn); if (year == 0) { time_t tnow; struct tm *now; tnow = getcurrenttime(NULL); now = localtime(&tnow); year = now->tm_year; } else if (year > 1000) { year -= 1900; } sprintf(fn, "%s/etc/holidays.cfg", xgetenv("XYMONHOME")); /* First check if there were no modifications at all */ if (configholidays) { /* if the new year begins, the holidays have to be recalculated */ if (!stackfmodified(configholidays) && (year == current_year)){ dbgprintf("No files modified, skipping reload of %s\n", fn); MEMUNDEFINE(fn); return 0; } else { stackfclist(&configholidays); configholidays = NULL; } } reset_holidays(); fd = stackfopen(fn, "r", &configholidays); if (!fd) { errprintf("Cannot open configuration file %s\n", fn); MEMUNDEFINE(fn); return 0; } memset(&newholiday,0,sizeof(holiday_t)); inbuf = newstrbuffer(0); while (stackfgets(inbuf, NULL)) { char *p, *delim, *arg1, *arg2; sanitize_input(inbuf, 1, 0); if (STRBUFLEN(inbuf) == 0) continue; p = STRBUF(inbuf); if (strncasecmp(p, "HOLIDAYLIKEWEEKDAY=", 19) == 0) { p+=19; holidays_like_weekday = atoi(p); if (holidays_like_weekday < -1 || holidays_like_weekday > 6) { holidays_like_weekday = -1; errprintf("Invalid HOLIDAYLIKEWEEKDAY in %s\n", fn); } continue; } if (*p == '[') { /* New set of holidays */ if (setname) xfree(setname); delim = strchr(p, ']'); if (delim) *delim = '\0'; setname = strdup(p+1); continue; } delim = strchr(p, ':'); if (delim) { memset(&newholiday,0,sizeof(holiday_t)); if (delim == p) { newholiday.desc = "untitled"; } else { *delim = '\0'; newholiday.desc = p; p=delim+1; } } arg1 = strtok(p, "="); while (arg1) { arg2=strtok(NULL," ,;\t\n\r"); if (!arg2) break; if (strncasecmp(arg1, "TYPE", 4) == 0) { if (strncasecmp(arg2, "STATIC", 6) == 0) newholiday.holtype = HOL_ABSOLUTE; else if (strncasecmp(arg2, "EASTER", 6) == 0) newholiday.holtype = HOL_EASTER; else if (strncasecmp(arg2, "4ADVENT", 7) == 0) newholiday.holtype = HOL_ADVENT; else if (strncasecmp(arg2, "MON", 3) == 0) newholiday.holtype = HOL_MON; else if (strncasecmp(arg2, "TUE", 3) == 0) newholiday.holtype = HOL_TUE; else if (strncasecmp(arg2, "WED", 3) == 0) newholiday.holtype = HOL_WED; else if (strncasecmp(arg2, "THU", 3) == 0) newholiday.holtype = HOL_THU; else if (strncasecmp(arg2, "FRI", 3) == 0) newholiday.holtype = HOL_FRI; else if (strncasecmp(arg2, "SAT", 3) == 0) newholiday.holtype = HOL_SAT; else if (strncasecmp(arg2, "SUN", 3) == 0) newholiday.holtype = HOL_SUN; else if (strncasecmp(arg2, "+MON", 4) == 0) newholiday.holtype = HOL_MON_AFTER; else if (strncasecmp(arg2, "+TUE", 4) == 0) newholiday.holtype = HOL_TUE_AFTER; else if (strncasecmp(arg2, "+WED", 4) == 0) newholiday.holtype = HOL_WED_AFTER; else if (strncasecmp(arg2, "+THU", 4) == 0) newholiday.holtype = HOL_THU_AFTER; else if (strncasecmp(arg2, "+FRI", 4) == 0) newholiday.holtype = HOL_FRI_AFTER; else if (strncasecmp(arg2, "+SAT", 4) == 0) newholiday.holtype = HOL_SAT_AFTER; else if (strncasecmp(arg2, "+SUN", 4) == 0) newholiday.holtype = HOL_SUN_AFTER; } else if (strncasecmp(arg1, "MONTH", 5) == 0) { newholiday.month=atoi(arg2); } else if (strncasecmp(arg1, "DAY", 3) == 0) { newholiday.day=atoi(arg2); } else if (strncasecmp(arg1, "OFFSET", 6) == 0) { newholiday.day=atoi(arg2); } else if (strncasecmp(arg1, "YEAR", 4) == 0) { newholiday.year=atoi(arg2); if (newholiday.year > 1000) { newholiday.year -= 1900; } } arg1 = strtok(NULL,"="); } add_holiday((setname ? setname : ""), year, &newholiday); } stackfclose(fd); freestrbuffer(inbuf); commonhandle = xtreeFind(holidays, ""); commonhols = (commonhandle != xtreeEnd(holidays)) ? (holidayset_t *)xtreeData(holidays, commonhandle) : NULL; for (handle = xtreeFirst(holidays); (handle != xtreeEnd(holidays)); handle = xtreeNext(holidays, handle)) { holidayset_t *oneset = (holidayset_t *)xtreeData(holidays, handle); if (commonhols && (oneset != commonhols)) { /* Add the common holidays to this set */ holiday_t *walk; for (walk = commonhols->head; (walk); walk = walk->next) add_holiday(oneset->key, year, walk); } oneset->head = msort(oneset->head, record_compare, record_getnext, record_setnext); } MEMUNDEFINE(fn); current_year = year; return 0; }
void print_hoststatus(FILE *output, hstatus_t *itm, void * statetree, void * columns, int prio, int firsthost, int firsthostever) { char *key; time_t now; xtreePos_t colhandle; now = getcurrenttime(NULL); fprintf(output, "<TR>\n"); /* Print the priority */ fprintf(output, "<TD ALIGN=LEFT VALIGN=TOP WIDTH=10%% NOWRAP>"); if (firsthost) if (prio == 99) { if (firsthostever) /* Only non-prioritised hosts, so just drop that text */ fprintf(output, " "); else fprintf(output, "<FONT %s>No priority</FONT>", xgetenv("XYMONPAGEROWFONT")); } else { 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(1024); for (colhandle = xtreeFirst(columns); (colhandle != xtreeEnd(columns)); colhandle = xtreeNext(columns, colhandle)) { char *colname; xtreePos_t sthandle; fprintf(output, "<TD ALIGN=CENTER>"); colname = (char *)xtreeKey(columns, colhandle); key = (char *)realloc(key, 2 + strlen(itm->hostname) + strlen(colname)); sprintf(key, "%s|%s", itm->hostname, colname); sthandle = xtreeFind(statetree, key); if (sthandle == xtreeEnd(statetree)) { fprintf(output, "-"); } else { hstatus_t *column; char *htmlalttag; char *htmlackstr; column = (hstatus_t *)xtreeData(statetree, sthandle); 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"); }