#define AB_VERSION "1.3e"

#if 'A' != 0x41

#define NOT_ASCII

#endif

#define BSD_COMP

#include "apr.h"

#include "apr_strings.h"

#include "apr_network_io.h"

#include "apr_file_io.h"

#include "apr_time.h"

#include "apr_getopt.h"

#include "apr_general.h"

#include <signal.h>

#include "apr_lib.h"

#define APR_WANT_STRFUNC

#include "apr_want.h"

#if APR_HAVE_STDIO_H

#include <stdio.h> /* for EOF */

#endif

#if APR_HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include "apr_base64.h"

#ifdef NOT_ASCII

#include "apr_xlate.h"

#endif

#if APR_HAVE_STDIO_H

#include <stdio.h>

#endif

#if APR_HAVE_STDLIB_H

#include <stdlib.h>

#ifdef USE_SSL

#if ((!(RSAREF)) && (!(SYSSSL)))

#include <openssl/rsa.h>

#include <openssl/crypto.h>

#include <openssl/x509.h>

#include <openssl/pem.h>

#include <openssl/err.h>

#include <openssl/ssl.h>

#else

#include <rsa.h>

#include <crypto.h>

#include <x509.h>

#include <pem.h>

#include <err.h>

#include <ssl.h>

#endif

#endif

#include <math.h>

#endif

#if APR_HAVE_CTYPE_H

#include <ctype.h>

#endif

#ifndef LLONG_MAX

#define AB_MAX APR_INT64_C(0x7fffffffffffffff)

#else

#define AB_MAX LLONG_MAX

#endif

#define MAX_REQUESTS 50000

#define STATE_UNCONNECTED 0

#define STATE_CONNECTING 1

#define STATE_READ 2

#define CBUFFSIZE (2048)

struct connection {

apr_socket_t *aprsock;

int state;

int read; /* amount of bytes read */

int bread; /* amount of body read */

int rwrite, rwrote; /* keep pointers in what we write - across

int length; /* Content-Length value used for keep-alive */

char cbuff[CBUFFSIZE]; /* a buffer to store server response header */

int cbx; /* offset in cbuffer */

int keepalive; /* non-zero if a keep-alive request */

int gotheader; /* non-zero if we have the entire header in

apr_time_t start, /* Start of connection */

connect, /* Connected, start writing */

endwrite, /* Request written */

beginread, /* First byte of input */

done; /* Connection closed */

int socknum;

#ifdef USE_SSL

SSL *ssl;

#endif

};

struct data {

#ifdef USE_SSL

/* XXXX insert SSL timings */

#endif

int read; /* number of bytes read */

apr_time_t starttime; /* start time of connection in seconds since

apr_interval_time_t waittime; /* Between writing request and reading

apr_interval_time_t ctime; /* time in ms to connect */

apr_interval_time_t time; /* time in ms for connection */

};

#define ap_min(a,b) ((a)<(b))?(a):(b)

#define ap_max(a,b) ((a)>(b))?(a):(b)

int verbosity = 0; /* no verbosity by default */

int posting = 0; /* GET by default */

int requests = 1; /* Number of requests to make */

int heartbeatres = 100; /* How often do we say we're alive */

int concurrency = 1; /* Number of multiple requests to make */

int percentile = 1; /* Show percentile served */

int confidence = 1; /* Show confidence estimator and warnings */

int tlimit = 0; /* time limit in cs */

int keepalive = 0; /* try and do keepalive connections */

char servername[1024]; /* name that server reports */

char *hostname; /* host name from URL */

char *host_field; /* value of "Host:" header field */

char path[1024]; /* path name */

char postfile[1024]; /* name of file containing post data */

char *postdata; /* *buffer containing data from postfile */

apr_size_t postlen = 0; /* length of data to be POSTed */

char content_type[1024]; /* content type to put in POST header */

char cookie[1024], /* optional cookie line */

auth[1024], /* optional (basic/uuencoded)

hdrs[4096]; /* optional arbitrary headers */

apr_port_t port; /* port number */

char proxyhost[1024]; /* proxy host name */

int proxyport = 0; /* proxy port */

char connecthost[1024];

int connectport;

char *gnuplot; /* GNUplot file */

char *csvperc; /* CSV Percentile file */

char url[1024];

char fullurl[1024];

int isproxy = 0;

apr_time_t aprtimeout = 30 * APR_USEC_PER_SEC; /* timeout value */

/*

int use_html = 0; /* use html in the report */

const char *tablestring;

const char *trstring;

const char *tdstring;

int doclen = 0; /* the length the document should be */

long started = 0; /* number of requests started, so no excess */

long totalread = 0; /* total number of bytes read */

long totalbread = 0; /* totoal amount of entity body read */

long totalposted = 0; /* total number of bytes posted, inc. headers */

long done = 0; /* number of requests we have done */

long doneka = 0; /* number of keep alive connections done */

long good = 0, bad = 0; /* number of good and bad requests */

long epipe = 0; /* number of broken pipe writes */

#ifdef USE_SSL

int ssl = 0;

SSL_CTX *ctx;

#endif

int err_length = 0, err_conn = 0, err_except = 0;

int err_response = 0;

apr_time_t start, endtime;

char _request[512];

char *request = _request;

apr_size_t reqlen;

char buffer[8192];

int percs[] = {50, 66, 75, 80, 90, 95, 98, 99, 100};

struct connection *con; /* connection array */

struct data *stats; /* date for each request */

apr_pool_t *cntxt;

apr_pollfd_t *readbits;

#ifdef NOT_ASCII

apr_xlate_t *from_ascii, *to_ascii;

#endif

static void close_connection(struct connection * c);

static void err(char *s)

{

fprintf(stderr, "%s", s);

exit(1);

}

static void apr_err(char *s, apr_status_t rv)

{

char buf[120];

fprintf(stderr,

"%s: %s (%d)\n",

s, apr_strerror(rv, buf, sizeof buf), rv);

exit(rv);

}

static void write_request(struct connection * c)

{

do {

apr_time_t tnow = apr_time_now();

apr_size_t l = c->rwrite;

apr_status_t e;

/*

if (c->rwrite == 0) {

apr_setsocketopt(c->aprsock, APR_SO_TIMEOUT, 0);

c->connect = tnow;

c->rwrite = reqlen;

c->rwrote = 0;

if (posting)

c->rwrite += postlen;

}

else if (tnow > c->connect + aprtimeout) {

printf("Send request timed out!\n");

close_connection(c);

return;

}

e = apr_send(c->aprsock, request + c->rwrote, &l);

/*

if (l == c->rwrite)

break;

if (e != APR_SUCCESS) {

/*

if (!APR_STATUS_IS_EAGAIN(e)) {

epipe++;

printf("Send request failed!\n");

close_connection(c);

}

return;

}

c->rwrote += l;

c->rwrite -= l;

} while (1);

totalposted += c->rwrite;

c->state = STATE_READ;

c->endwrite = apr_time_now();

apr_poll_socket_add(readbits, c->aprsock, APR_POLLIN);

}

static int compradre(struct data * a, struct data * b)

{

if ((a->ctime) < (b->ctime))

return -1;

if ((a->ctime) > (b->ctime))

return +1;

return 0;

}

static int comprando(struct data * a, struct data * b)

{

if ((a->time) < (b->time))

return -1;

if ((a->time) > (b->time))

return +1;

return 0;

}

static int compri(struct data * a, struct data * b)

{

apr_interval_time_t p = a->time - a->ctime;

apr_interval_time_t q = b->time - b->ctime;

if (p < q)

return -1;

if (p > q)

return +1;

return 0;

}

static int compwait(struct data * a, struct data * b)

{

if ((a->waittime) < (b->waittime))

return -1;

if ((a->waittime) > (b->waittime))

return 1;

return 0;

}

static void output_results(void)

{

apr_interval_time_t timetakenusec;

float timetaken;

endtime = apr_time_now();

timetakenusec = endtime - start;

timetaken = (float) timetakenusec / APR_USEC_PER_SEC;

printf("\r \r");

printf("Server Software: %s\n", servername);

printf("Server Hostname: %s\n", hostname);

printf("Server Port: %hd\n", port);

printf("\n");

printf("Document Path: %s\n", path);

printf("Document Length: %d bytes\n", doclen);

printf("\n");

printf("Concurrency Level: %d\n", concurrency);

printf("Time taken for tests: %" APR_TIME_T_FMT ".%03" APR_TIME_T_FMT " seconds\n",

(apr_interval_time_t) timetakenusec / APR_USEC_PER_SEC,

(apr_interval_time_t) timetakenusec % APR_USEC_PER_SEC);

printf("Complete requests: %ld\n", done);

printf("Failed requests: %ld\n", bad);

if (bad)

printf(" (Connect: %d, Length: %d, Exceptions: %d)\n",

err_conn, err_length, err_except);

printf("Write errors: %ld\n", epipe);

if (err_response)

printf("Non-2xx responses: %d\n", err_response);

if (keepalive)

printf("Keep-Alive requests: %ld\n", doneka);

printf("Total transferred: %ld bytes\n", totalread);

if (posting > 0)

printf("Total POSTed: %ld\n", totalposted);

printf("HTML transferred: %ld bytes\n", totalbread);

/* avoid divide by zero */

if (timetaken) {

printf("Requests per second: %.2f [#/sec] (mean)\n", done / timetaken);

printf("Time per request: %.3f [ms] (mean)\n", concurrency * timetaken / done);

printf("Time per request: %.3f [ms] (mean, across all concurrent requests)\n",

timetaken / done);

printf("Transfer rate: %.2f [Kbytes/sec] received\n",

totalread / 1024 / timetaken);

if (posting > 0) {

printf(" %.2f kb/s sent\n",

(float) totalposted / timetaken / 1024);

printf(" %.2f kb/s total\n",

(float) (totalread + totalposted) / timetaken / 1024);

}

}

if (requests) {

/* work out connection times */

long i;

double totalcon = 0, total = 0, totald = 0, totalwait = 0;

apr_interval_time_t mincon = AB_MAX, mintot = AB_MAX, mind = AB_MAX,

minwait = AB_MAX;

apr_interval_time_t maxcon = 0, maxtot = 0, maxd = 0, maxwait = 0;

apr_interval_time_t meancon = 0, meantot = 0, meand = 0, meanwait = 0;

double sdtot = 0, sdcon = 0, sdd = 0, sdwait = 0;

for (i = 0; i < requests; i++) {

struct data s = stats[i];

mincon = ap_min(mincon, s.ctime);

mintot = ap_min(mintot, s.time);

mind = ap_min(mind, s.time - s.ctime);

minwait = ap_min(minwait, s.waittime);

maxcon = ap_max(maxcon, s.ctime);

maxtot = ap_max(maxtot, s.time);

maxd = ap_max(maxd, s.time - s.ctime);

maxwait = ap_max(maxwait, s.waittime);

totalcon += s.ctime;

total += s.time;

totald += s.time - s.ctime;

totalwait += s.waittime;

}

totalcon /= requests;

total /= requests;

totald /= requests;

totalwait /= requests;

for (i = 0; i < requests; i++) {

struct data s = stats[i];

apr_interval_time_t a;

a = (s.time - total);

sdtot += a * a;

a = (s.ctime - totalcon);

sdcon += a * a;

a = (s.time - s.ctime - totald);

sdd += a * a;

a = (s.waittime - totalwait);

sdwait += a * a;

};

sdtot = (requests > 1) ? sqrt(sdtot / (requests - 1)) : 0;

sdcon = (requests > 1) ? sqrt(sdcon / (requests - 1)) : 0;

sdd = (requests > 1) ? sqrt(sdd / (requests - 1)) : 0;

sdwait = (requests > 1) ? sqrt(sdwait / (requests - 1)) : 0;

if (gnuplot) {

FILE *out = fopen(gnuplot, "w");

long i;

apr_time_t sttime;

char tmstring[1024];/* XXXX */

if (!out) {

perror("Cannot open gnuplot output file");

exit(1);

};

fprintf(out, "starttime\tseconds\tctime\tdtime\tttime\twait\n");

for (i = 0; i < requests; i++) {

sttime = stats[i].starttime;

(void) apr_ctime(tmstring, sttime);

tmstring[strlen(tmstring) - 1] = '\0'; /* ctime returns a

fprintf(out, "%s\t%" APR_TIME_T_FMT "\t%" APR_TIME_T_FMT "\t%" APR_TIME_T_FMT "\t%" APR_TIME_T_FMT "\t%" APR_TIME_T_FMT "\n",

tmstring,

sttime,

stats[i].ctime,

stats[i].time - stats[i].ctime,

stats[i].time,

stats[i].waittime);

}

fclose(out);

};

/*

qsort(stats, requests, sizeof(struct data),

(int (*) (const void *, const void *)) compradre);

if ((requests > 1) && (requests % 2))

meancon = (stats[requests / 2].ctime + stats[requests / 2 + 1].ctime) / 2;

else

meancon = stats[requests / 2].ctime;

qsort(stats, requests, sizeof(struct data),

(int (*) (const void *, const void *)) compri);

if ((requests > 1) && (requests % 2))

meand = (stats[requests / 2].time + stats[requests / 2 + 1].time \

-stats[requests / 2].ctime - stats[requests / 2 + 1].ctime) / 2;

else

meand = stats[requests / 2].time - stats[requests / 2].ctime;

qsort(stats, requests, sizeof(struct data),

(int (*) (const void *, const void *)) compwait);

if ((requests > 1) && (requests % 2))

meanwait = (stats[requests / 2].waittime + stats[requests / 2 + 1].waittime) / 2;

else

meanwait = stats[requests / 2].waittime;

qsort(stats, requests, sizeof(struct data),

(int (*) (const void *, const void *)) comprando);

if ((requests > 1) && (requests % 2))

meantot = (stats[requests / 2].time + stats[requests / 2 + 1].time) / 2;

else

meantot = stats[requests / 2].time;

printf("\nConnection Times (ms)\n");

if (confidence) {

#define CONF_FMT_STRING "%" APR_TIME_T_FMT " %5d %6.1f %" APR_TIME_T_FMT " %" APR_TIME_T_FMT "\n"

printf(" min mean[+/-sd] median max\n");

printf("Connect: " CONF_FMT_STRING,

mincon, (int) (totalcon + 0.5), sdcon, meancon, maxcon);

printf("Processing: " CONF_FMT_STRING,

mind, (int) (totald + 0.5), sdd, meand, maxd);

printf("Waiting: " CONF_FMT_STRING,

minwait, (int) (totalwait + 0.5), sdwait, meanwait, maxwait);

printf("Total: " CONF_FMT_STRING,

mintot, (int) (total + 0.5), sdtot, meantot, maxtot);

#undef CONF_FMT_STRING

#define SANE(what,avg,mean,sd) \

{ \

double d = avg - mean; \

if (d < 0) d = -d; \

if (d > 2 * sd ) \

printf("ERROR: The median and mean for " what " are more than twice the standard\n" \

" deviation apart. These results are NOT reliable.\n"); \

else if (d > sd ) \

printf("WARING: The median and mean for " what " are not within a normal deviation\n" \

" These results are propably not that reliable.\n"); \

}

SANE("the initial connection time", totalcon, meancon, sdcon);

SANE("the processing time", totald, meand, sdd);

SANE("the waiting time", totalwait, meanwait, sdwait);

SANE("the total time", total, meantot, sdtot);

}

else {

printf(" min avg max\n");

#define CONF_FMT_STRING "%5" APR_TIME_T_FMT " %5e %5" APR_TIME_T_FMT "\n"

printf("Connect: " CONF_FMT_STRING, mincon, totalcon / requests,

maxcon);

printf("Processing: " CONF_FMT_STRING, mintot - mincon,

(total / requests) - (totalcon / requests), maxtot - maxcon);

printf("Total: " CONF_FMT_STRING, mintot, total / requests,

maxtot);

#undef CONF_FMT_STRING

}

/* Sorted on total connect times */

if (percentile && (requests > 1)) {

printf("\nPercentage of the requests served within a certain time (ms)\n");

for (i = 0; i < sizeof(percs) / sizeof(int); i++)

if (percs[i] <= 0)

printf(" 0%% <0> (never)\n");

else if (percs[i] >= 100)

printf(" 100%% %5" APR_TIME_T_FMT " (longest request)\n",

stats[requests - 1].time);

else

printf(" %d%% %5" APR_TIME_T_FMT "\n",

percs[i], stats[(int) (requests * percs[i] / 100)].time);

};

if (csvperc) {

FILE *out = fopen(csvperc, "w");

int i;

if (!out) {

perror("Cannot open CSV output file");

exit(1);

};

fprintf(out, "" "Percentage served" "," "Time in ms" "\n");

for (i = 0; i < 100; i++) {

double d;

if (i == 0)

d = stats[0].time;

else if (i == 100)

d = stats[requests - 1].time;

else

d = stats[(int) (0.5 + requests * i / 100.0)].time;

fprintf(out, "%d,%e\n", i, d);

}

fclose(out);

};

}

}

static void output_html_results(void)

{

long timetaken;

endtime = apr_time_now();

timetaken = (endtime - start) / 1000;

printf("\n\n<table %s>\n", tablestring);

printf("<tr %s><th colspan=2 %s>Server Software:</th>"

"<td colspan=2 %s>%s</td></tr>\n",

trstring, tdstring, tdstring, servername);

printf("<tr %s><th colspan=2 %s>Server Hostname:</th>"

"<td colspan=2 %s>%s</td></tr>\n",

trstring, tdstring, tdstring, hostname);

printf("<tr %s><th colspan=2 %s>Server Port:</th>"

"<td colspan=2 %s>%hd</td></tr>\n",

trstring, tdstring, tdstring, port);

printf("<tr %s><th colspan=2 %s>Document Path:</th>"

"<td colspan=2 %s>%s</td></tr>\n",

trstring, tdstring, tdstring, path);

printf("<tr %s><th colspan=2 %s>Document Length:</th>"

"<td colspan=2 %s>%d bytes</td></tr>\n",

trstring, tdstring, tdstring, doclen);

printf("<tr %s><th colspan=2 %s>Concurrency Level:</th>"

"<td colspan=2 %s>%d</td></tr>\n",

trstring, tdstring, tdstring, concurrency);

printf("<tr %s><th colspan=2 %s>Time taken for tests:</th>"

"<td colspan=2 %s>%qd.%03qd seconds</td></tr>\n",

trstring, tdstring, tdstring, timetaken / APR_USEC_PER_SEC, timetaken % APR_USEC_PER_SEC);

printf("<tr %s><th colspan=2 %s>Complete requests:</th>"

"<td colspan=2 %s>%ld</td></tr>\n",

trstring, tdstring, tdstring, done);

printf("<tr %s><th colspan=2 %s>Failed requests:</th>"

"<td colspan=2 %s>%ld</td></tr>\n",

trstring, tdstring, tdstring, bad);

if (bad)

printf("<tr %s><td colspan=4 %s > (Connect: %d, Length: %d, Exceptions: %d)</td></tr>\n",

trstring, tdstring, err_conn, err_length, err_except);

if (err_response)

printf("<tr %s><th colspan=2 %s>Non-2xx responses:</th>"

"<td colspan=2 %s>%d</td></tr>\n",

trstring, tdstring, tdstring, err_response);

if (keepalive)

printf("<tr %s><th colspan=2 %s>Keep-Alive requests:</th>"

"<td colspan=2 %s>%ld</td></tr>\n",

trstring, tdstring, tdstring, doneka);

printf("<tr %s><th colspan=2 %s>Total transferred:</th>"

"<td colspan=2 %s>%ld bytes</td></tr>\n",

trstring, tdstring, tdstring, totalread);

if (posting > 0)

printf("<tr %s><th colspan=2 %s>Total POSTed:</th>"

"<td colspan=2 %s>%ld</td></tr>\n",

trstring, tdstring, tdstring, totalposted);

printf("<tr %s><th colspan=2 %s>HTML transferred:</th>"

"<td colspan=2 %s>%ld bytes</td></tr>\n",

trstring, tdstring, tdstring, totalbread);

/* avoid divide by zero */

if (timetaken) {

printf("<tr %s><th colspan=2 %s>Requests per second:</th>"

"<td colspan=2 %s>%.2f</td></tr>\n",

trstring, tdstring, tdstring, 1000 * (float) (done) / timetaken);

printf("<tr %s><th colspan=2 %s>Transfer rate:</th>"

"<td colspan=2 %s>%.2f kb/s received</td></tr>\n",

trstring, tdstring, tdstring, (float) (totalread) / timetaken);

if (posting > 0) {

printf("<tr %s><td colspan=2 %s>&nbsp;</td>"

"<td colspan=2 %s>%.2f kb/s sent</td></tr>\n",

trstring, tdstring, tdstring,

(float) (totalposted) / timetaken);

printf("<tr %s><td colspan=2 %s>&nbsp;</td>"

"<td colspan=2 %s>%.2f kb/s total</td></tr>\n",

trstring, tdstring, tdstring,

(float) (totalread + totalposted) / timetaken);

}

} {

/* work out connection times */

long i;

apr_interval_time_t totalcon = 0, total = 0;

apr_interval_time_t mincon = AB_MAX, mintot = AB_MAX;

apr_interval_time_t maxcon = 0, maxtot = 0;

for (i = 0; i < requests; i++) {

struct data s = stats[i];

mincon = ap_min(mincon, s.ctime);

mintot = ap_min(mintot, s.time);

maxcon = ap_max(maxcon, s.ctime);

maxtot = ap_max(maxtot, s.time);

totalcon += s.ctime;

total += s.time;

}

if (requests > 0) { /* avoid division by zero (if 0 requests) */

printf("<tr %s><th %s colspan=4>Connnection Times (ms)</th></tr>\n",

trstring, tdstring);

printf("<tr %s><th %s>&nbsp;</th> <th %s>min</th> <th %s>avg</th> <th %s>max</th></tr>\n",

trstring, tdstring, tdstring, tdstring, tdstring);

printf("<tr %s><th %s>Connect:</th>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td></tr>\n",

trstring, tdstring, tdstring, mincon, tdstring, totalcon / requests, tdstring, maxcon);

printf("<tr %s><th %s>Processing:</th>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td></tr>\n",

trstring, tdstring, tdstring, mintot - mincon, tdstring,

(total / requests) - (totalcon / requests), tdstring, maxtot - maxcon);

printf("<tr %s><th %s>Total:</th>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td>"

"<td %s>%5" APR_TIME_T_FMT "</td></tr>\n",

trstring, tdstring, tdstring, mintot, tdstring, total / requests, tdstring, maxtot);

}

printf("</table>\n");

}

}

static void start_connect(struct connection * c)

{

apr_status_t rv;

apr_sockaddr_t *destsa;

if (!(started < requests))

return;

c->read = 0;

c->bread = 0;

c->keepalive = 0;

c->cbx = 0;

c->gotheader = 0;

c->rwrite = 0;

if ((rv = apr_sockaddr_info_get(&destsa, connecthost, APR_UNSPEC, connectport, 0, cntxt))

!= APR_SUCCESS) {

char buf[120];

apr_snprintf(buf, sizeof(buf),

"apr_sockaddr_info_get() for %s", connecthost);

apr_err(buf, rv);

}

if ((rv = apr_socket_create(&c->aprsock, destsa->sa.sin.sin_family,

SOCK_STREAM, cntxt)) != APR_SUCCESS) {

apr_err("socket", rv);

}

c->start = apr_time_now();

if ((rv = apr_connect(c->aprsock, destsa)) != APR_SUCCESS) {

if (APR_STATUS_IS_EINPROGRESS(rv)) {

c->state = STATE_CONNECTING;

c->rwrite = 0;

apr_poll_socket_add(readbits, c->aprsock, APR_POLLOUT);

return;

}

else {

apr_poll_socket_remove(readbits, c->aprsock);

apr_socket_close(c->aprsock);

err_conn++;

if (bad++ > 10) {

fprintf(stderr,

"\nTest aborted after 10 failures\n\n");

apr_err("apr_connect()", rv);

}

c->state = STATE_UNCONNECTED;

start_connect(c);

return;

}

}

/* connected first time */

started++;

write_request(c);

}

static void close_connection(struct connection * c)

{

if (c->read == 0 && c->keepalive) {

/*

if (good)

good--; /* connection never happened */

}

else {

if (good == 1) {

/* first time here */

doclen = c->bread;

}

else if (c->bread != doclen) {

bad++;

err_length++;

}

/* save out time */

if (done < requests) {

struct data s;

if ((done) && heartbeatres && !(done % heartbeatres)) {

fprintf(stderr, "Completed %ld requests\n", done);

fflush(stderr);

}

c->done = apr_time_now();

s.read = c->read;

s.starttime = c->start;

s.ctime = (c->connect - c->start) / 1000;

s.time = (c->done - c->start) / 1000;

s.waittime = (c->beginread - c->endwrite) / 1000;

stats[done++] = s;

}

}

apr_poll_socket_remove(readbits, c->aprsock);

apr_socket_close(c->aprsock);

c->state = STATE_UNCONNECTED;

/* connect again */

start_connect(c);

return;

}

static void read_connection(struct connection * c)

{

apr_size_t r;

apr_status_t status;

char *part;

char respcode[4]; /* 3 digits and null */

r = sizeof(buffer);

apr_setsocketopt(c->aprsock, APR_SO_TIMEOUT, aprtimeout);

status = apr_recv(c->aprsock, buffer, &r);

if (r == 0 || (status != APR_SUCCESS && !APR_STATUS_IS_EAGAIN(status))) {

good++;

close_connection(c);

return;

}

if (APR_STATUS_IS_EAGAIN(status))

return;

totalread += r;

if (c->read == 0) {

c->beginread = apr_time_now();

};

c->read += r;

if (!c->gotheader) {

char *s;

int l = 4;

int space = CBUFFSIZE - c->cbx - 1; /* -1 to allow for 0

int tocopy = (space < r) ? space : r;

#ifdef NOT_ASCII

apr_size_t inbytes_left = space, outbytes_left = space;

status = apr_xlate_conv_buffer(from_ascii, buffer, &inbytes_left,

c->cbuff + c->cbx, &outbytes_left);

if (status || inbytes_left || outbytes_left) {

fprintf(stderr, "only simple translation is supported (%d/%u/%u)\n",

status, inbytes_left, outbytes_left);

exit(1);

}

#else

memcpy(c->cbuff + c->cbx, buffer, space);

#endif /* NOT_ASCII */

c->cbx += tocopy;

space -= tocopy;

c->cbuff[c->cbx] = 0; /* terminate for benefit of strstr */

if (verbosity >= 4) {

printf("LOG: header received:\n%s\n", c->cbuff);

}

s = strstr(c->cbuff, "\r\n\r\n");

/*

if (!s) {

s = strstr(c->cbuff, "\n\n");

l = 2;

}

if (!s) {

/* read rest next time */

if (space) {

return;

}

else {

/* header is in invalid or too big - close connection */

apr_poll_socket_remove(readbits, c->aprsock);

apr_socket_close(c->aprsock);

err_response++;

if (bad++ > 10) {

err("\nTest aborted after 10 failures\n\n");

}

start_connect(c);

}

}

else {

/* have full header */

if (!good) {

/*

char *p, *q;

p = strstr(c->cbuff, "Server:");

q = servername;

if (p) {

p += 8;

while (*p > 32)

*q++ = *p++;

}

*q = 0;

}

/*

/* check response code */

part = strstr(c->cbuff, "HTTP"); /* really HTTP/1.x_ */

strncpy(respcode, (part + strlen("HTTP/1.x_")), 3);

respcode[3] = '\0';

if (respcode[0] != '2') {

err_response++;

if (verbosity >= 2)

printf("WARNING: Response code not 2xx (%s)\n", respcode);

}

else if (verbosity >= 3) {

printf("LOG: Response code = %s\n", respcode);

}

c->gotheader = 1;

*s = 0; /* terminate at end of header */

if (keepalive &&

(strstr(c->cbuff, "Keep-Alive")

|| strstr(c->cbuff, "keep-alive"))) { /* for benefit of MSIIS */

char *cl;

cl = strstr(c->cbuff, "Content-Length:");

/* handle NCSA, which sends Content-length: */

if (!cl)

cl = strstr(c->cbuff, "Content-length:");

if (cl) {

c->keepalive = 1;

c->length = atoi(cl + 16);

}

}

c->bread += c->cbx - (s + l - c->cbuff) + r - tocopy;

totalbread += c->bread;

}

}

else {

/* outside header, everything we have read is entity body */

c->bread += r;

totalbread += r;

}

if (c->keepalive && (c->bread >= c->length)) {

/* finished a keep-alive connection */

good++;

doneka++;

/* save out time */

if (good == 1) {

/* first time here */

doclen = c->bread;

}

else if (c->bread != doclen) {

bad++;

err_length++;

}

if (done < requests) {

struct data s;

if (done && heartbeatres && !(done % heartbeatres)) {

fprintf(stderr, "Completed %ld requests\n", done);

fflush(stderr);

}

c->done = apr_time_now();

s.read = c->read;

s.starttime = c->start;

s.ctime = (c->connect - c->start) / 1000;

s.waittime = (c->beginread - c->endwrite) / 1000;

s.time = (c->done - c->start) / 1000;

stats[done++] = s;

}

c->keepalive = 0;

c->length = 0;

c->gotheader = 0;

c->cbx = 0;

c->read = c->bread = 0;

write_request(c);

c->start = c->connect; /* zero connect time with keep-alive */

}

}

static void test(void)

{

apr_time_t now;

apr_int16_t rv;

long i;

apr_status_t status;

#ifdef NOT_ASCII

apr_size_t inbytes_left, outbytes_left;

#endif

if (isproxy) {

strcpy(connecthost, proxyhost);

connectport = proxyport;

}

else {

strcpy(connecthost, hostname);

connectport = port;

}

if (!use_html) {

printf("Benchmarking %s ", hostname);

if (isproxy)

printf("[through %s:%d] ", proxyhost, proxyport);

printf("(be patient)%s",

(heartbeatres ? "\n" : "..."));

fflush(stdout);

}

now = apr_time_now();

con = malloc(concurrency * sizeof(struct connection));

memset(con, 0, concurrency * sizeof(struct connection));

stats = malloc(requests * sizeof(struct data));

apr_poll_setup(&readbits, concurrency, cntxt);

/* setup request */

if (!posting) {

sprintf(request, "%s %s HTTP/1.0\r\n"

"User-Agent: ApacheBench/%s\r\n"

"%s" "%s" "%s"

"Host: %s\r\n"

"Accept: */*\r\n"

"%s" "\r\n",

(posting == 0) ? "GET" : "HEAD",

(isproxy) ? fullurl : path,

AB_VERSION,

keepalive ? "Connection: Keep-Alive\r\n" : "",

cookie, auth, host_field, hdrs);

}

else {

sprintf(request, "POST %s HTTP/1.0\r\n"

"User-Agent: ApacheBench/%s\r\n"

"%s" "%s" "%s"

"Host: %s\r\n"

"Accept: */*\r\n"

"Content-length: %" APR_SIZE_T_FMT "\r\n"

"Content-type: %s\r\n"

"%s"

"\r\n",

(isproxy) ? fullurl : path,

AB_VERSION,

keepalive ? "Connection: Keep-Alive\r\n" : "",

cookie, auth,

host_field, postlen,

(content_type[0]) ? content_type : "text/plain", hdrs);

}

if (verbosity >= 2)

printf("INFO: POST header == \n---\n%s\n---\n", request);

reqlen = strlen(request);

/*

if (posting) {

char *buff = (char *) malloc(postlen + reqlen + 1);

strcpy(buff, request);

strcpy(buff + reqlen, postdata);

request = buff;

}

#ifdef NOT_ASCII

inbytes_left = outbytes_left = reqlen;

status = apr_xlate_conv_buffer(to_ascii, request, &inbytes_left,

request, &outbytes_left);

if (status || inbytes_left || outbytes_left) {

fprintf(stderr, "only simple translation is supported (%d/%u/%u)\n",

status, inbytes_left, outbytes_left);

exit(1);

}

#endif /* NOT_ASCII */

/* ok - lets start */

start = apr_time_now();

/* initialise lots of requests */

for (i = 0; i < concurrency; i++) {

con[i].socknum = i;

start_connect(&con[i]);

}

while (done < requests) {

apr_int32_t n;

apr_int32_t timed;

/* check for time limit expiry */

now = apr_time_now();

timed = (now - start) / APR_USEC_PER_SEC;

if (tlimit && timed > (tlimit * 1000)) {

requests = done; /* so stats are correct */

}

n = concurrency;

status = apr_poll(readbits, &n, aprtimeout);

if (status != APR_SUCCESS)

apr_err("apr_poll", status);

if (!n) {

err("\nServer timed out\n\n");

}

for (i = 0; i < concurrency; i++) {

/*

if (con[i].state == STATE_UNCONNECTED)

continue;

apr_poll_revents_get(&rv, con[i].aprsock, readbits);

/*

if ((rv & APR_POLLIN) || (rv & APR_POLLPRI) || (rv & APR_POLLHUP))

read_connection(&con[i]);

if ((rv & APR_POLLERR) || (rv & APR_POLLNVAL)) {

bad++;

err_except++;

start_connect(&con[i]);

continue;

}

if (rv & APR_POLLOUT)

write_request(&con[i]);

/*

if (con[i].state == STATE_READ || con[i].state == STATE_CONNECTING)

apr_poll_socket_add(readbits, con[i].aprsock, APR_POLLIN);

}

}

if (heartbeatres)

fprintf(stderr, "Finished %ld requests\n", done);

else

printf("..done\n");

if (use_html)

output_html_results();

else

output_results();

}

static void copyright(void)

{

if (!use_html) {

printf("This is ApacheBench, Version %s\n", AB_VERSION " <$Revision: 1.74 $> apache-2.0");

printf("Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/\n");

printf("Copyright (c) 1998-2001 The Apache Software Foundation, http://www.apache.org/\n");

printf("\n");

}

else {

printf("<p>\n");

printf(" This is ApacheBench, Version %s <i>&lt;%s&gt;</i> apache-2.0<br>\n", AB_VERSION, "$Revision: 1.74 $");

printf(" Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/<br>\n");

printf(" Copyright (c) 1998-2001 The Apache Software Foundation, http://www.apache.org/<br>\n");

printf("</p>\n<p>\n");

}

}

static void usage(const char *progname)

{

fprintf(stderr, "Usage: %s [options] [http"

#if USE_SSL

"[s]"

#endif

"://]hostname[:port]/path\n", progname);

fprintf(stderr, "Options are:\n");

fprintf(stderr, " -n requests Number of requests to perform\n");

fprintf(stderr, " -c concurrency Number of multiple requests to make\n");

fprintf(stderr, " -t timelimit Seconds to max. wait for responses\n");

fprintf(stderr, " -p postfile File containing data to POST\n");

fprintf(stderr, " -T content-type Content-type header for POSTing\n");

fprintf(stderr, " -v verbosity How much troubleshooting info to print\n");

fprintf(stderr, " -w Print out results in HTML tables\n");

fprintf(stderr, " -i Use HEAD instead of GET\n");

fprintf(stderr, " -x attributes String to insert as table attributes\n");

fprintf(stderr, " -y attributes String to insert as tr attributes\n");

fprintf(stderr, " -z attributes String to insert as td or th attributes\n");

fprintf(stderr, " -C attribute Add cookie, eg. 'Apache=1234. (repeatable)\n");

fprintf(stderr, " -H attribute Add Arbitrary header line, eg. 'Accept-Encoding: zop'\n");