void add_http_test(testitem_t *t)
{
http_data_t *httptest;
char *dnsip = NULL;
ssloptions_t *sslopt = NULL;
char *sslopt_ciphers = NULL;
int sslopt_version = SSLVERSION_DEFAULT;
char *sslopt_clientcert = NULL;
int httpversion = HTTPVER_11;
cookielist_t *ck = NULL;
int firstcookie = 1;
char *decodedurl;
strbuffer_t *httprequest = newstrbuffer(0);
/* Allocate the private data and initialize it */
httptest = (http_data_t *) calloc(1, sizeof(http_data_t));
t->privdata = (void *) httptest;
decodedurl = decode_url(t->testspec, &httptest->weburl);
if (!decodedurl) {
errprintf("Invalid URL for http check: %s\n", t->testspec);
return;
}
httptest->url = strdup(decodedurl);
httptest->contlen = -1;
httptest->parsestatus = (httptest->weburl.proxyurl ? httptest->weburl.proxyurl->parseerror : httptest->weburl.desturl->parseerror);
/* If there was a parse error in the URL, dont run the test */
if (httptest->parsestatus) return;
if (httptest->weburl.proxyurl && (httptest->weburl.proxyurl->ip == NULL)) {
dnsip = dnsresolve(httptest->weburl.proxyurl->host);
if (dnsip) {
httptest->weburl.proxyurl->ip = strdup(dnsip);
}
else {
dbgprintf("Could not resolve URL hostname '%s'\n", httptest->weburl.proxyurl->host);
}
}
else if (httptest->weburl.desturl->ip == NULL) {
dnsip = dnsresolve(httptest->weburl.desturl->host);
if (dnsip) {
httptest->weburl.desturl->ip = strdup(dnsip);
}
else {
dbgprintf("Could not resolve URL hostname '%s'\n", httptest->weburl.desturl->host);
}
}
switch (httptest->weburl.testtype) {
case WEBTEST_PLAIN:
case WEBTEST_STATUS:
httptest->contentcheck = CONTENTCHECK_NONE;
break;
case WEBTEST_CONTENT:
{
FILE *contentfd;
char contentfn[PATH_MAX];
sprintf(contentfn, "%s/content/%s.substring", xgetenv("XYMONHOME"), commafy(t->host->hostname));
contentfd = fopen(contentfn, "r");
if (contentfd) {
char l[MAX_LINE_LEN];
char *p;
if (fgets(l, sizeof(l), contentfd)) {
p = strchr(l, '\n'); if (p) { *p = '\0'; };
httptest->weburl.expdata = strdup(l);
}
else {
httptest->contstatus = STATUS_CONTENTMATCH_NOFILE;
}
fclose(contentfd);
}
else {
httptest->contstatus = STATUS_CONTENTMATCH_NOFILE;
}
httptest->contentcheck = CONTENTCHECK_REGEX;
}
break;
case WEBTEST_CONT:
httptest->contentcheck = ((*httptest->weburl.expdata == '#') ? CONTENTCHECK_DIGEST : CONTENTCHECK_REGEX);
break;
case WEBTEST_NOCONT:
httptest->contentcheck = CONTENTCHECK_NOREGEX;
break;
case WEBTEST_POST:
case WEBTEST_SOAP:
if (httptest->weburl.expdata == NULL) {
httptest->contentcheck = CONTENTCHECK_NONE;
}
else {
httptest->contentcheck = ((*httptest->weburl.expdata == '#') ? CONTENTCHECK_DIGEST : CONTENTCHECK_REGEX);
}
break;
case WEBTEST_NOPOST:
case WEBTEST_NOSOAP:
if (httptest->weburl.expdata == NULL) {
httptest->contentcheck = CONTENTCHECK_NONE;
}
else {
httptest->contentcheck = CONTENTCHECK_NOREGEX;
}
break;
case WEBTEST_TYPE:
httptest->contentcheck = CONTENTCHECK_CONTENTTYPE;
break;
}
/* Compile the hashes and regex's for those tests that use it */
switch (httptest->contentcheck) {
case CONTENTCHECK_DIGEST:
{
char *hashfunc;
httptest->exp = (void *) strdup(httptest->weburl.expdata+1);
hashfunc = strchr(httptest->exp, ':');
if (hashfunc) {
*hashfunc = '\0';
httptest->digestctx = digest_init(httptest->exp);
*hashfunc = ':';
}
}
break;
case CONTENTCHECK_REGEX:
case CONTENTCHECK_NOREGEX:
{
int status;
httptest->exp = (void *) malloc(sizeof(regex_t));
status = regcomp((regex_t *)httptest->exp, httptest->weburl.expdata, REG_EXTENDED|REG_NOSUB);
if (status) {
errprintf("Failed to compile regexp '%s' for URL %s\n", httptest->weburl.expdata, httptest->url);
httptest->contstatus = STATUS_CONTENTMATCH_BADREGEX;
}
}
break;
case CONTENTCHECK_CONTENTTYPE:
httptest->exp = httptest->weburl.expdata;
break;
}
if (httptest->weburl.desturl->schemeopts) {
if (strstr(httptest->weburl.desturl->schemeopts, "3")) sslopt_version = SSLVERSION_V3;
else if (strstr(httptest->weburl.desturl->schemeopts, "2")) sslopt_version = SSLVERSION_V2;
if (strstr(httptest->weburl.desturl->schemeopts, "h")) sslopt_ciphers = ciphershigh;
else if (strstr(httptest->weburl.desturl->schemeopts, "m")) sslopt_ciphers = ciphersmedium;
if (strstr(httptest->weburl.desturl->schemeopts, "10")) httpversion = HTTPVER_10;
else if (strstr(httptest->weburl.desturl->schemeopts, "11")) httpversion = HTTPVER_11;
}
/* Get any cookies */
load_cookies();
/* Generate the request */
addtobuffer(httprequest, (httptest->weburl.postdata ? "POST " : "GET "));
switch (httpversion) {
case HTTPVER_10:
addtobuffer(httprequest, (httptest->weburl.proxyurl ? httptest->url : httptest->weburl.desturl->relurl));
addtobuffer(httprequest, " HTTP/1.0\r\n");
break;
case HTTPVER_11:
/*
* Experience shows that even though HTTP/1.1 says you should send the
* full URL, some servers (e.g. SunOne App server 7) choke on it.
* So just send the good-old relative URL unless we're proxying.
*/
addtobuffer(httprequest, (httptest->weburl.proxyurl ? httptest->url : httptest->weburl.desturl->relurl));
addtobuffer(httprequest, " HTTP/1.1\r\n");
addtobuffer(httprequest, "Connection: close\r\n");
break;
}
addtobuffer(httprequest, "Host: ");
addtobuffer(httprequest, httptest->weburl.desturl->host);
if ((httptest->weburl.desturl->port != 80) && (httptest->weburl.desturl->port != 443)) {
char hostporthdr[20];
sprintf(hostporthdr, ":%d", httptest->weburl.desturl->port);
addtobuffer(httprequest, hostporthdr);
}
addtobuffer(httprequest, "\r\n");
if (httptest->weburl.postdata) {
char hdr[100];
int contlen = strlen(httptest->weburl.postdata);
if (strncmp(httptest->weburl.postdata, "file:", 5) == 0) {
/* Load the POST data from a file */
FILE *pf = fopen(httptest->weburl.postdata+5, "r");
if (pf == NULL) {
errprintf("Cannot open POST data file %s\n", httptest->weburl.postdata+5);
xfree(httptest->weburl.postdata);
httptest->weburl.postdata = strdup("");
contlen = 0;
}
else {
struct stat st;
if (fstat(fileno(pf), &st) == 0) {
int n;
xfree(httptest->weburl.postdata);
httptest->weburl.postdata = (char *)malloc(st.st_size + 1); *(httptest->weburl.postdata) = '\0';
n = fread(httptest->weburl.postdata, 1, st.st_size, pf);
if (n == st.st_size) {
*(httptest->weburl.postdata+n) = '\0';
contlen = n;
}
else {
errprintf("Cannot read file %s: %s\n", httptest->weburl.postdata+5, strerror(errno));
contlen = 0;
}
}
else {
errprintf("Cannot stat file %s\n", httptest->weburl.postdata+5);
httptest->weburl.postdata = strdup("");
contlen = 0;
}
fclose(pf);
}
}
addtobuffer(httprequest, "Content-type: ");
if (httptest->weburl.postcontenttype)
addtobuffer(httprequest, httptest->weburl.postcontenttype);
else if ((httptest->weburl.testtype == WEBTEST_SOAP) || (httptest->weburl.testtype == WEBTEST_NOSOAP))
addtobuffer(httprequest, "application/soap+xml; charset=utf-8");
else
addtobuffer(httprequest, "application/x-www-form-urlencoded");
addtobuffer(httprequest, "\r\n");
sprintf(hdr, "Content-Length: %d\r\n", contlen);
addtobuffer(httprequest, hdr);
}
{
char useragent[100];
void *hinfo;
char *browser = NULL;
hinfo = hostinfo(t->host->hostname);
if (hinfo) browser = xmh_item(hinfo, XMH_BROWSER);
if (browser) {
sprintf(useragent, "User-Agent: %s\r\n", browser);
}
else {
sprintf(useragent, "User-Agent: Xymon xymonnet/%s\r\n", VERSION);
}
addtobuffer(httprequest, useragent);
}
if (httptest->weburl.desturl->auth) {
if (strncmp(httptest->weburl.desturl->auth, "CERT:", 5) == 0) {
sslopt_clientcert = httptest->weburl.desturl->auth+5;
}
else {
addtobuffer(httprequest, "Authorization: Basic ");
addtobuffer(httprequest, base64encode(httptest->weburl.desturl->auth));
addtobuffer(httprequest, "\r\n");
}
}
if (httptest->weburl.proxyurl && httptest->weburl.proxyurl->auth) {
addtobuffer(httprequest, "Proxy-Authorization: Basic ");
addtobuffer(httprequest, base64encode(httptest->weburl.proxyurl->auth));
addtobuffer(httprequest, "\r\n");
}
for (ck = cookiehead; (ck); ck = ck->next) {
int useit = 0;
if (ck->tailmatch) {
int startpos = strlen(httptest->weburl.desturl->host) - strlen(ck->host);
if (startpos > 0) useit = (strcmp(httptest->weburl.desturl->host+startpos, ck->host) == 0);
}
else useit = (strcmp(httptest->weburl.desturl->host, ck->host) == 0);
if (useit) useit = (strncmp(ck->path, httptest->weburl.desturl->relurl, strlen(ck->path)) == 0);
if (useit) {
if (firstcookie) {
addtobuffer(httprequest, "Cookie: ");
firstcookie = 0;
}
addtobuffer(httprequest, ck->name);
addtobuffer(httprequest, "=");
addtobuffer(httprequest, ck->value);
addtobuffer(httprequest, "\r\n");
}
}
/* Some standard stuff */
addtobuffer(httprequest, "Accept: */*\r\n");
addtobuffer(httprequest, "Pragma: no-cache\r\n");
if ((httptest->weburl.testtype == WEBTEST_SOAP) || (httptest->weburl.testtype == WEBTEST_NOSOAP)) {
/* Must provide a SOAPAction header */
addtobuffer(httprequest, "SOAPAction: ");
addtobuffer(httprequest, httptest->url);
addtobuffer(httprequest, "\r\n");
}
/* The final blank line terminates the headers */
addtobuffer(httprequest, "\r\n");
/* Post data goes last */
if (httptest->weburl.postdata) addtobuffer(httprequest, httptest->weburl.postdata);
/* Pickup any SSL options the user wants */
if (sslopt_ciphers || (sslopt_version != SSLVERSION_DEFAULT) || sslopt_clientcert){
sslopt = (ssloptions_t *) malloc(sizeof(ssloptions_t));
sslopt->cipherlist = sslopt_ciphers;
sslopt->sslversion = sslopt_version;
sslopt->clientcert = sslopt_clientcert;
}
/* Add to TCP test queue */
if (httptest->weburl.proxyurl == NULL) {
httptest->tcptest = add_tcp_test(httptest->weburl.desturl->ip,
httptest->weburl.desturl->port,
httptest->weburl.desturl->scheme,
sslopt, t->srcip,
t->testspec, t->silenttest, grabstrbuffer(httprequest),
httptest, tcp_http_data_callback, tcp_http_final_callback);
}
else {
httptest->tcptest = add_tcp_test(httptest->weburl.proxyurl->ip,
httptest->weburl.proxyurl->port,
httptest->weburl.proxyurl->scheme,
sslopt, t->srcip,
t->testspec, t->silenttest, grabstrbuffer(httprequest),
httptest, tcp_http_data_callback, tcp_http_final_callback);
}
}
int main(int argc, char *argv[])
{
int argi;
char *argp, *p;
testitem_t *thead = NULL;
int timeout = 0;
int concurrency = 0;
if (xgetenv("XYMONNETSVCS") == NULL) putenv("XYMONNETSVCS=");
init_tcp_services();
for (argi=1; (argi<argc); argi++) {
if (strcmp(argv[argi], "--debug") == 0) {
debug = 1;
}
else if (strncmp(argv[argi], "--timeout=", 10) == 0) {
p = strchr(argv[argi], '=');
timeout = atoi(p+1);
if (timeout < 0) timeout = 0;
}
else if (strncmp(argv[argi], "--concurrency=", 14) == 0) {
p = strchr(argv[argi], '=');
concurrency = atoi(p+1);
if (concurrency < 0) concurrency = 0;
}
else if (strcmp(argv[argi], "--help") == 0) {
printf("Run with\n~xymon/server/bin/xymoncmd ./contest --debug 172.16.10.2/25/smtp\n");
printf("I.e. IP/PORTNUMBER/TESTSPEC\n");
return 0;
}
else {
char *ip;
char *port;
char *srcip;
char *testspec;
argp = argv[argi]; ip = port = srcip = testspec = NULL;
ip = argp;
p = strchr(argp, '/');
if (p) {
*p = '\0'; argp = (p+1);
p = strchr(argp, '/');
if (p) {
port = argp; *p = '\0'; argp = (p+1);
}
else {
port = "0";
}
testspec = argp;
srcip = strchr(testspec, '@');
if (srcip) {
*srcip = '\0';
srcip++;
}
}
if (ip && port && testspec) {
if ( (strncmp(argp, "http", 4) == 0) ||
(strncmp(argp, "cont;", 5) == 0) ||
(strncmp(argp, "cont=", 5) == 0) ||
(strncmp(argp, "post;", 5) == 0) ||
(strncmp(argp, "post=", 5) == 0) ||
(strncmp(argp, "nocont;", 7) == 0) ||
(strncmp(argp, "nocont=", 7) == 0) ||
(strncmp(argp, "nopost;", 7) == 0) ||
(strncmp(argp, "nopost=", 7) == 0) ||
(strncmp(argp, "httpstatus;", 11) == 0) ||
(strncmp(argp, "httpstatus=", 11) == 0) ||
(strncmp(argp, "type;", 5) == 0) ||
(strncmp(argp, "type=", 5) == 0) ) {
testitem_t *testitem = calloc(1, sizeof(testitem_t));
testedhost_t *hostitem = calloc(1, sizeof(testedhost_t));
http_data_t *httptest;
hostitem->hostname = strdup("localhost");
testitem->host = hostitem;
testitem->testspec = testspec;
strcpy(hostitem->ip, ip);
add_url_to_dns_queue(testspec);
add_http_test(testitem);
testitem->next = NULL;
thead = testitem;
httptest = (http_data_t *)testitem->privdata;
if (httptest && httptest->tcptest) {
printf("TCP connection goes to %s:%d\n",
inet_ntoa(httptest->tcptest->addr.sin_addr),
ntohs(httptest->tcptest->addr.sin_port));
printf("Request:\n%s\n", httptest->tcptest->sendtxt);
}
}
else if (strncmp(argp, "dns=", 4) == 0) {
strbuffer_t *banner = newstrbuffer(0);
int result;
result = dns_test_server(ip, argp+4, banner);
printf("DNS test result=%d\nBanner:%s\n", result, STRBUF(banner));
}
else {
add_tcp_test(ip, atoi(port), testspec, NULL, srcip, NULL, 0, NULL, NULL, NULL, NULL);
}
}
else {
printf("Invalid testspec '%s'\n", argv[argi]);
}
}
}
do_tcp_tests(timeout, concurrency);
show_tcp_test_results();
return 0;
}
