** - POST and verbosity by Kurt Sussman <kls@merlot.com>, August 1998
** - HTML table output added by David N. Welton <davidw@prosa.it>, January 1999
** - Added Cookie, Arbitrary header and auth support. <dirkx@webweaving.org>, April 1999
+ ** Version 1.3d
+ ** - Increased version number - as some of the socket/error handling has
+ ** fundamentally changed - and will give fundamentally different results
+ ** in situations where a server is dropping requests. Therefore you can
+ ** no longer compare results of AB as easily. Hence the inc of the version.
+ ** They should be closer to the truth though. Sander & <dirkx@covalent.net>, End 2000.
+ ** - Fixed proxy functionality, added median/mean statistics, added gnuplot
+ ** output option, added _experimental/rudimentary_ SSL support. Added
+ ** confidence guestimators and warnings. Sander & <dirkx@covalent.net>, End 2000
+ ** - Fixed serious int overflow issues which would cause realistic (longer
+ ** than a few minutes) run's to have wrong (but believable) results. Added
+ ** trapping of connection errors which influenced measurements.
+ ** Contributed by Sander Temme - <sander@covalent.net>, Early 2001
**
*/
+ /*
+ * BUGS:
+ *
+ * - uses strcpy/etc.
+ * - has various other poor buffer attacks related to the lazy parsing of
+ * response headers from the server
+ * - doesn't implement much of HTTP/1.x, only accepts certain forms of
+ * responses
+ * - (performance problem) heavy use of strstr shows up top in profile
+ * only an issue for loopback usage
+ * - SSL implementation is a joke.
+ */
-/*
- * BUGS:
- *
- * - uses strcpy/etc.
- * - has various other poor buffer attacks related to the lazy parsing of
- * response headers from the server
- * - doesn't implement much of HTTP/1.x, only accepts certain forms of
- * responses
- * - (performance problem) heavy use of strstr shows up top in profile
- * only an issue for loopback usage
- */
-#define VERSION "1.3c"
+#define VERSION "1.3d"
-/* -------------------------------------------------------------------- */
+/* -------------------------------------------------------------------- */
/* affects include files on Solaris */
#define BSD_COMP
#include <errno.h>
#include <sys/ioctl.h>
#include <string.h>
+#include <signal.h>
#include <sys/types.h>
#include <sys/uio.h>
#include "ap_config.h"
#include "ap.h"
#ifdef CHARSET_EBCDIC
-#include "ap_ebcdic.h"
+#include "ebcdic.h"
#endif
#include <fcntl.h>
#ifndef MPE
#endif
#endif /* NO_APACHE_INCLUDES */
+
+#ifdef USE_SSL
+#if ((!(RSAREF)) && (!(SYSSSL)))
+/* Libraries on most systems.. */
+#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
+/* Libraries for RSAref and SYSSSL */
+#include <rsa.h>
+#include <crypto.h>
+#include <x509.h>
+#include <pem.h>
+#include <err.h>
+#include <ssl.h>
+#endif
+#endif
+
+#include <math.h>
/* ------------------- DEFINITIONS -------------------------- */
/* maximum number of requests on a time limited test */
int keepalive; /* non-zero if a keep-alive request */
int gotheader; /* non-zero if we have the entire header in
* cbuff */
- struct timeval start, connect, done;
+ struct timeval start, /* Start of connection */
+ connect, /* Connected, start writing */
+ endwrite, /* Request written */
+ beginread, /* First byte of input */
+ done; /* Connection closed */
+
+#ifdef USE_SSL
+ SSL *ssl;
+#endif
};
struct data {
+#ifdef USE_SSL
+ /* XXX insert timings for ssl */
+#endif
int read; /* number of bytes read */
- int ctime; /* time in ms to connect */
- int time; /* time in ms for connection */
+ long starttime; /* start time of connection in seconds since
+ * Jan. 1, 1970 */
+ long waittime; /* Between writing request and reading
+ * response */
+ long ctime; /* time in ms to connect */
+ long time; /* time in ms for connection */
};
#define ap_min(a,b) ((a)<(b))?(a):(b)
/* --------------------- GLOBALS ---------------------------- */
int verbosity = 0; /* no verbosity by default */
+int percentile = 1; /* Show percentile served */
+int confidence = 1; /* Show confidence estimator and warnings */
int posting = 0; /* GET by default */
-int requests = 1; /* Number of requests to make */
+long 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 tlimit = 0; /* time limit in cs */
int keepalive = 0; /* try and do keepalive connections */
char servername[1024]; /* name that server reports */
char hostname[1024]; /* host name */
+char proxyhost[1024]; /* proxy host name */
+int proxyport = 0; /* proxy port */
+int isproxy = 0;
char path[1024]; /* path name */
char postfile[1024]; /* name of file containing post data */
char *postdata; /* *buffer containing data from postfile */
+char *gnuplot; /* GNUplot file */
+char *csvperc; /* CSV Percentile file */
+char url[1024];
+char fullurl[1024];
int 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 */
char *tdstring;
int doclen = 0; /* the length the document should be */
-int totalread = 0; /* total number of bytes read */
-int totalbread = 0; /* totoal amount of entity body read */
-int totalposted = 0; /* total number of bytes posted, inc. headers */
-int done = 0; /* number of requests we have done */
-int doneka = 0; /* number of keep alive connections done */
-int good = 0, bad = 0; /* number of good and bad requests */
-
+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
/* store error cases */
int err_length = 0, err_conn = 0, err_except = 0;
int err_response = 0;
#define ab_write(a,b,c) send(a,b,c,0)
#endif
+static void close_connection(struct connection * c);
+static void s_write(struct connection * c, char *buff, int len);
/* --------------------------------------------------------- */
/* simple little function to perror and exit */
/* --------------------------------------------------------- */
-/* write out request to a connection - assumes we can write
- (small) request out in one go into our new socket buffer */
+/*
+ * write out request to a connection - assumes we can write (small) request
+ * out in one go into our new socket buffer
+ */
static void write_request(struct connection * c)
{
-#ifndef NO_WRITEV
- struct iovec out[2]; int outcnt = 1;
+/* XXX this sucks - SSL mode and writev() do not mix
+ * another artificial difference.
+ */
+#if !NO_WRITEV && !USE_SSL
+ struct iovec out[2];
+ int outcnt = 1;
#endif
gettimeofday(&c->connect, 0);
-#ifndef NO_WRITEV
+#if !NO_WRITEV && !USE_SSL
out[0].iov_base = request;
out[0].iov_len = reqlen;
- if (posting>0) {
+ if (posting > 0) {
out[1].iov_base = postdata;
out[1].iov_len = postlen;
outcnt = 2;
totalposted += (reqlen + postlen);
}
- writev(c->fd,out, outcnt);
+ writev(c->fd, out, outcnt);
#else
- ab_write(c->fd,request,reqlen);
- if (posting>0) {
- ab_write(c->fd,postdata,postlen);
- totalposted += (reqlen + postlen);
+ s_write(c, request, reqlen);
+ if (posting > 0) {
+ s_write(c, postdata, postlen);
+ totalposted += (reqlen + postlen);
}
#endif
c->state = STATE_READ;
FD_SET(c->fd, &readbits);
FD_CLR(c->fd, &writebits);
+ gettimeofday(&c->endwrite, 0);
+}
+
+/* --------------------------------------------------------- */
+
+/* Do actual data writing */
+
+static void s_write(struct connection * c, char *buff, int len)
+{
+ do {
+ int n;
+#if USE_SSL
+ if (ssl) {
+ n = SSL_write(c->ssl, buff, len);
+ if (n < 0) {
+ int e = SSL_get_error(c->ssl, n);
+ /* XXXX propably wrong !!! */
+ if ((e != SSL_ERROR_WANT_READ) && (e != SSL_ERROR_WANT_WRITE))
+ n = -1;
+ else
+ n = 0;
+ };
+ }
+ else
+#endif
+ n = ab_write(c->fd, buff, len);
+
+ if (n < 0) {
+ switch (errno) {
+ case EAGAIN:
+ break;
+ case EPIPE:
+ /* We've tried to write to a broken pipe. */
+ epipe++;
+ close_connection(c);
+ return;
+ default:
+ perror("write");
+ exit(1);
+ }
+ }
+ else if (n) {
+ if (verbosity >= 3)
+ printf(" --> write(%x) %d (%d)\n", (unsigned char) buff[0], n, len);
+ buff += n;
+ len -= n;
+ };
+ } while (len > 0);
}
/* --------------------------------------------------------- */
/* calculate and output results */
+int compradre(struct data * a, struct data * b)
+{
+ if ((a->ctime) < (b->ctime))
+ return -1;
+ if ((a->ctime) > (b->ctime))
+ return +1;
+ return 0;
+}
+
+int comprando(struct data * a, struct data * b)
+{
+ if ((a->time) < (b->time))
+ return -1;
+ if ((a->time) > (b->time))
+ return +1;
+ return 0;
+}
+
+int compri(struct data * a, struct data * b)
+{
+ int p = a->time - a->ctime;
+ int q = b->time - b->ctime;
+ if (p < q)
+ return -1;
+ if (p > q)
+ return +1;
+ return 0;
+}
+
+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)
{
- int timetaken;
+ long timetaken;
gettimeofday(&endtime, 0);
timetaken = timedif(endtime, start);
if (bad)
printf(" (Connect: %d, Length: %d, Exceptions: %d)\n",
err_conn, err_length, err_except);
+ printf("Broken pipe errors: %d\n", epipe);
if (err_response)
printf("Non-2xx responses: %d\n", err_response);
if (keepalive)
printf("Keep-Alive requests: %d\n", doneka);
printf("Total transferred: %d bytes\n", totalread);
- if (posting>0)
+ if (posting > 0)
printf("Total POSTed: %d\n", totalposted);
printf("HTML transferred: %d bytes\n", totalbread);
/* avoid divide by zero */
if (timetaken) {
- printf("Requests per second: %.2f\n", 1000 * (float) (done) / timetaken);
- printf("Transfer rate: %.2f kb/s received\n",
+ printf("Requests per second: %.2f [#/sec] (mean)\n", 1000 * (float) (done) / timetaken);
+ printf("Time per request: %.2f [ms] (mean)\n", concurrency * timetaken / (float) done);
+ printf("Time per request: %.2f [ms] (mean, across all concurent requests)\n", timetaken / (float) done);
+ printf("Transfer rate: %.2f [Kbytes/sec] received\n",
(float) (totalread) / timetaken);
- if (posting>0) {
+ if (posting > 0) {
printf(" %.2f kb/s sent\n",
(float) (totalposted) / timetaken);
printf(" %.2f kb/s total\n",
(float) (totalread + totalposted) / timetaken);
}
}
-
- {
+ if (requests) {
/* work out connection times */
- int i;
- int totalcon = 0, total = 0;
- int mincon = 9999999, mintot = 999999;
- int maxcon = 0, maxtot = 0;
+ long i;
+ double totalcon = 0, total = 0, totald = 0, totalwait = 0;
+ long mincon = 9999999, mintot = 999999, mind = 99999, minwait = 99999;
+ long maxcon = 0, maxtot = 0, maxd = 0, maxwait = 0;
+ long 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(mintot, 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];
+ int 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;
+ time_t sttime;
+ char *tmstring;
+ 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;
+ tmstring = ctime(&sttime);
+ tmstring[strlen(tmstring) - 1] = '\0'; /* ctime returns a
+ * string with a
+ * trailing newline */
+ fprintf(out, "%s\t%d\t%d\t%d\t%d\t%d\n",
+ tmstring,
+ sttime,
+ stats[i].ctime,
+ stats[i].time - stats[i].ctime,
+ stats[i].time,
+ stats[i].waittime);
+ }
+ fclose(out);
+ };
+
+ /*
+ * XXX: what is better; this hideous cast of the copare function; or
+ * the four warnings during compile ? dirkx just does not know and
+ * hates both/
+ */
+ 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 *)) comprando);
+ if ((requests > 1) && (requests % 2))
+ meantot = (stats[requests / 2].time + stats[requests / 2 + 1].time) / 2;
+ else
+ meantot = stats[requests / 2].time;
+
+ 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;
+
+ printf("\nConnnection Times (ms)\n");
+
+ if (confidence) {
+ printf(" min mean[+/-sd] median max\n");
+ printf("Connect: %5d %5d %6.1f %5d %5d\n",
+ mincon, (int) (totalcon + 0.5), sdcon, meancon, maxcon);
+ printf("Processing: %5d %5d %6.1f %5d %5d\n",
+ mind, (int) (totald + 0.5), sdd, meand, maxd);
+ printf("Waiting: %5d %5d %6.1f %5d %5d\n",
+ minwait, (int) (totalwait + 0.5), sdwait, meanwait, maxwait);
+ printf("Total: %5d %5d %6.1f %5d %5d\n", mintot, (int) (total + 0.5), sdtot, meantot, maxtot);
+
+#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);
}
- if (requests > 0) { /* avoid division by zero (if 0 requests) */
- printf("\nConnnection Times (ms)\n");
+ else {
printf(" min avg max\n");
- printf("Connect: %5d %5d %5d\n", mincon, totalcon / requests, maxcon);
- printf("Processing: %5d %5d %5d\n",
- mintot - mincon, (total / requests) - (totalcon / requests),
- maxtot - maxcon);
- printf("Total: %5d %5d %5d\n", mintot, total / requests, maxtot);
- }
+ printf("Connect: %5d %5d %5d\n", mincon, (int) (totalcon + 0.5), maxcon);
+ printf("Processing: %5d %5d %5d\n", mind, (int) (totald + 0.5), maxd);
+ printf("Total: %5d %5d %5d\n", mintot, (int) (0.5 + total), maxtot);
+ };
+
+ /* Sorted on total connect times */
+ if (percentile && (requests > 1)) {
+ printf("\nPercentage of the requests served within a certain time (ms)\n");
+ printf(" 50%% %5d\n", stats[(int) (requests * 0.50)].time);
+ printf(" 66%% %5d\n", stats[(int) (requests * 0.66)].time);
+ printf(" 75%% %5d\n", stats[(int) (requests * 0.75)].time);
+ printf(" 80%% %5d\n", stats[(int) (requests * 0.80)].time);
+ printf(" 90%% %5d\n", stats[(int) (requests * 0.90)].time);
+ printf(" 95%% %5d\n", stats[(int) (requests * 0.95)].time);
+ printf(" 98%% %5d\n", stats[(int) (requests * 0.98)].time);
+ printf(" 99%% %5d\n", stats[(int) (requests * 0.99)].time);
+ printf(" 100%% %5d (last request)\n", stats[(int) (requests - 1)].time);
+ \
+ };
+ if (csvperc) {
+ FILE *out = fopen(csvperc, "w");
+ long i;
+ time_t sttime;
+ char *tmstring;
+ 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,%d\n", i, d);
+ }
+ fclose(out);
+ };
}
}
static void output_html_results(void)
{
- int timetaken;
+ long timetaken;
gettimeofday(&endtime, 0);
timetaken = timedif(endtime, start);
printf("<tr %s><th colspan=2 %s>Total transferred:</th>"
"<td colspan=2 %s>%d bytes</td></tr>\n",
trstring, tdstring, tdstring, totalread);
- if (posting>0)
+ if (posting > 0)
printf("<tr %s><th colspan=2 %s>Total POSTed:</th>"
"<td colspan=2 %s>%d</td></tr>\n",
trstring, tdstring, tdstring, totalposted);
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) {
+ if (posting > 0) {
printf("<tr %s><td colspan=2 %s> </td>"
"<td colspan=2 %s>%.2f kb/s sent</td></tr>\n",
trstring, tdstring, tdstring,
trstring, tdstring, tdstring,
(float) (totalread + totalposted) / timetaken);
}
- }
-
- {
+ } {
/* work out connection times */
- int i;
- int totalcon = 0, total = 0;
- int mincon = 9999999, mintot = 999999;
- int maxcon = 0, maxtot = 0;
+ long i;
+ long totalcon = 0, total = 0;
+ long mincon = 9999999, mintot = 999999;
+ long maxcon = 0, maxtot = 0;
for (i = 0; i < requests; i++) {
struct data s = stats[i];
total += s.time;
}
- if (requests > 0) { /* avoid division by zero (if 0 requests) */
+ 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> </th> <th %s>min</th> <th %s>avg</th> <th %s>max</th></tr>\n",
static void start_connect(struct connection * c)
{
+ const char *what = "none";
+
c->read = 0;
c->bread = 0;
c->keepalive = 0;
c->gotheader = 0;
c->fd = socket(AF_INET, SOCK_STREAM, 0);
- if (c->fd < 0)
- err("socket");
+ if (c->fd < 0) {
+ what = "SOCKET";
+ goto bad;
+ };
+
+#if USE_SSL
+ /*
+ * XXXX move nonblocker - so that measnurement needs to have its OWN
+ * state engine OR cannot be compared to http.
+ */
+ if (!ssl)
+#endif
+ nonblock(c->fd);
- nonblock(c->fd);
+again:
gettimeofday(&c->start, 0);
-
if (connect(c->fd, (struct sockaddr *) & server, sizeof(server)) < 0) {
if (errno == EINPROGRESS) {
c->state = STATE_CONNECTING;
- FD_SET(c->fd, &writebits);
- return;
}
else {
- ab_close(c->fd);
- err_conn++;
- if (bad++ > 10) {
- err("\nTest aborted after 10 failures\n\n");
- }
- start_connect(c);
- }
+ what = "CONNECT";
+ goto bad;
+ };
+ }
+ else {
+ /* connected first time */
+ c->state = STATE_CONNECTING;
}
- /* connected first time */
- c->state = STATE_CONNECTING;
+#ifdef USE_SSL
+ /* XX no proper freeing in error's */
+ /*
+ * XXXX no proper choise of completely new connection or one which reuses
+ * (older) session keys. Fundamentally unrealistic.
+ */
+ if (ssl) {
+ int e;
+ if (!(c->ssl = SSL_new(ctx))) {
+ fprintf(stderr, "Failed to set up new SSL context ");
+ ERR_print_errors_fp(stderr);
+ goto bad;
+ };
+ SSL_set_connect_state(c->ssl);
+ if ((e = SSL_set_fd(c->ssl, c->fd)) == -1) {
+ fprintf(stderr, "SSL fd init failed ")l
+ ERR_print_errors_fp(stderr);
+ goto bad;
+ };
+ if ((e = SSL_connect(c->ssl)) == -1) {
+ fprintf(stderr, "SSL connect failed ");
+ ERR_print_errors_fp(stderr);
+ goto bad;
+ };
+ if (verbosity >= 1)
+ fprintf(stderr, "SSL connection OK: %s\n", SSL_get_cipher(c->ssl));
+ }
+#endif
+#if USE_SSL
+ if (ssl)
+ nonblock(c->fd);
+#endif
FD_SET(c->fd, &writebits);
+ return;
+
+bad:
+ ab_close(c->fd);
+ err_conn++;
+ if (bad++ > 10) {
+ err("\nTest aborted after 10 failures\n\n");
+ }
+ goto again;
}
/* --------------------------------------------------------- */
static void close_connection(struct connection * c)
{
if (c->read == 0 && c->keepalive) {
- /* server has legitimately shut down an idle keep alive request */
+ /*
+ * server has legitimately shut down an idle keep alive request
+ */
good--; /* connection never happend */
}
else {
bad++;
err_length++;
}
-
/* save out time */
if (done < requests) {
struct data s;
+ if ((done) && (!(done % heartbeatres))) {
+ fprintf(stderr, "Completed %d requests\n", done);
+ fflush(stderr);
+ }
gettimeofday(&c->done, 0);
s.read = c->read;
+ s.starttime = c->start.tv_sec;
s.ctime = timedif(c->connect, c->start);
+ s.waittime = timedif(c->beginread, c->endwrite);
s.time = timedif(c->done, c->start);
stats[done++] = s;
}
char *part;
char respcode[4]; /* 3 digits and null */
- r = ab_read(c->fd, buffer, sizeof(buffer));
+ gettimeofday(&c->beginread, 0);
+#if USE_SSL
+ if (ssl) {
+ r = SSL_read(c->ssl, buffer, sizeof(buffer));
+ /* XXX fundamwentally worng .. */
+ if (r < 0 && SSL_get_error(c->ssl, r) == SSL_ERROR_WANT_READ) {
+ r = -1;
+ errno = EAGAIN;
+ }
+ }
+ else
+#endif
+ r = ab_read(c->fd, buffer, sizeof(buffer));
if (r == 0 || (r < 0 && errno != EAGAIN)) {
good++;
close_connection(c);
return;
}
-
if (r < 0 && errno == EAGAIN)
return;
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 */
+ /*
+ * header is in invalid or too big - close connection
+ */
ab_close(c->fd);
if (bad++ > 10) {
err("\nTest aborted after 10 failures\n\n");
else {
/* have full header */
if (!good) {
- /* this is first time, extract some interesting info */
+ /*
+ * this is first time, extract some interesting info
+ */
char *p, *q;
p = strstr(c->cbuff, "Server:");
q = servername;
}
*q = 0;
}
-
/*
* XXX: this parsing isn't even remotely HTTP compliant... but in
* the interest of speed it doesn't totally have to be, it just
else if (verbosity >= 3) {
printf("LOG: Response code = %s\n", respcode);
}
-
c->gotheader = 1;
*s = 0; /* terminate at end of header */
if (keepalive &&
totalbread += r;
}
- /* cater for the case where we're using keepalives and doing HEAD requests */
+ /*
+ * cater for the case where we're using keepalives and doing HEAD
+ * requests
+ */
if (c->keepalive && ((c->bread >= c->length) || (posting < 0))) {
/* finished a keep-alive connection */
good++;
}
if (done < requests) {
struct data s;
+ if ((done) && (!(done % heartbeatres))) {
+ fprintf(stderr, "Completed %d requests\n", done);
+ fflush(stderr);
+ }
gettimeofday(&c->done, 0);
s.read = c->read;
+ s.starttime = c->start.tv_sec;
s.ctime = timedif(c->connect, c->start);
+ s.waittime = timedif(c->beginread, c->endwrite);
s.time = timedif(c->done, c->start);
stats[done++] = s;
}
/* --------------------------------------------------------- */
+/* Catch SIGPIPE signals */
+
+void pipehandler(int signal)
+{
+ int i; /* loop variable */
+
+ printf("Caught broken pipe signal after %d requests. ", done);
+
+ /* This means one of my connections is broken, but which one? */
+ /* The safe route: close all our connections. */
+ for (i = 0; i < concurrency; i++)
+ close_connection(&con[i]);
+
+ /* And start them back up */
+ for (i = 0; i < concurrency; i++)
+ start_connect(&con[i]);
+
+ printf("Continuing...\n");
+}
+
+/* --------------------------------------------------------- */
+
/* run the tests */
static void test(void)
{
struct timeval timeout, now;
fd_set sel_read, sel_except, sel_write;
- int i;
+ long i;
+ char connecthost[1024];
+ int connectport;
+
+ if (isproxy) {
+ strcpy(connecthost, proxyhost);
+ connectport = proxyport;
+ }
+ else {
+ strcpy(connecthost, hostname);
+ connectport = port;
+ }
if (!use_html) {
- printf("Benchmarking %s (be patient)...", hostname);
+ printf("Benchmarking %s (be patient)%s",
+ hostname, (heartbeatres ? "\n" : "..."));
fflush(stdout);
}
-
{
/* get server information */
struct hostent *he;
- he = gethostbyname(hostname);
- if (!he)
- err("bad hostname");
+ he = gethostbyname(connecthost);
+ if (!he) {
+ char theerror[1024];
+ sprintf(theerror, "Bad hostname: %s\n", connecthost);
+ err(theerror);
+ }
server.sin_family = he->h_addrtype;
- server.sin_port = htons(port);
+ server.sin_port = htons(connectport);
server.sin_addr.s_addr = ((unsigned long *) (he->h_addr_list[0]))[0];
}
"Accept: */*\r\n"
"%s" "\r\n",
(posting == 0) ? "GET" : "HEAD",
- path,
+ (isproxy) ? fullurl : path,
VERSION,
keepalive ? "Connection: Keep-Alive\r\n" : "",
- cookie, auth, hostname, hdrs);
+ cookie, auth, proxyhost, hdrs);
}
else {
sprintf(request, "POST %s HTTP/1.0\r\n"
"Content-type: %s\r\n"
"%s"
"\r\n",
- path,
+ (!isproxy) ? path : url,
VERSION,
keepalive ? "Connection: Keep-Alive\r\n" : "",
cookie, auth,
- hostname, postlen,
+ proxyhost, postlen,
(content_type[0]) ? content_type : "text/plain", hdrs);
}
if (tlimit && timedif(now, start) > (tlimit * 1000)) {
requests = done; /* so stats are correct */
}
-
/* Timeout of 30 seconds. */
- timeout.tv_sec = 30;
+ timeout.tv_sec = 120;
timeout.tv_usec = 0;
n = ap_select(FD_SETSIZE, &sel_read, &sel_write, &sel_except, &timeout);
if (!n) {
write_request(&con[i]);
}
}
+
+ if (heartbeatres)
+ fprintf(stderr, "Finished %d requests\n", done);
+ else
+ printf("..done\n");
+
if (use_html)
output_html_results();
else
static void copyright(void)
{
if (!use_html) {
- printf("This is ApacheBench, Version %s\n", VERSION " <$Revision: 1.45 $> apache-1.3");
+ printf("This is ApacheBench, Version %s\n", VERSION " <$Revision: 1.46 $> apache-1.3");
printf("Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/\n");
- printf("Copyright (c) 1998-2000 The Apache Group, http://www.apache.org/\n");
+ printf("Copyright (c) 1998-1999 The Apache Group, http://www.apache.org/\n");
printf("\n");
}
else {
printf("<p>\n");
- printf(" This is ApacheBench, Version %s <i><%s></i> apache-1.3<br>\n", VERSION, "$Revision: 1.45 $");
+ printf(" This is ApacheBench, Version %s <i><%s></i> apache-1.3<br>\n", VERSION, "$Revision: 1.46 $");
printf(" Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/<br>\n");
- printf(" Copyright (c) 1998-2000 The Apache Group, http://www.apache.org/<br>\n");
+ printf(" Copyright (c) 1998-1999 The Apache Group, http://www.apache.org/<br>\n");
printf("</p>\n<p>\n");
}
}
/* display usage information */
static void usage(char *progname)
{
- fprintf(stderr, "Usage: %s [options] [http://]hostname[:port]/path\n", 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, " -p postfile File containg 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, " Inserted after all normal header lines. (repeatable)\n");
fprintf(stderr, " -A attribute Add Basic WWW Authentication, the attributes\n");
fprintf(stderr, " are a colon separated username and password.\n");
- fprintf(stderr, " -p attribute Add Basic Proxy Authentication, the attributes\n");
+ fprintf(stderr, " -P attribute Add Basic Proxy Authentication, the attributes\n");
fprintf(stderr, " are a colon separated username and password.\n");
+ fprintf(stderr, " -X proxy:port Proxyserver and port number to use\n");
fprintf(stderr, " -V Print version number and exit\n");
fprintf(stderr, " -k Use HTTP KeepAlive feature\n");
+ fprintf(stderr, " -d Do not show percentiles served table.\n");
+ fprintf(stderr, " -S Do not show confidence estimators and warnings.\n");
+ fprintf(stderr, " -g filename Output collected data to gnuplot format file.\n");
+ fprintf(stderr, " -e filename Output CSV file with percentages served\n");
+#if USE_SSL
+ fprintf(stderr, " -s Use httpS instead of HTTP (SSL)\n");
+#endif
fprintf(stderr, " -h Display usage information (this message)\n");
exit(EINVAL);
}
if (strlen(url) > 7 && strncmp(url, "http://", 7) == 0)
url += 7;
+ else
+#if USE_SSL
+ if (strlen(url) > 8 && strncmp(url, "https://", 8) == 0) {
+ url += 8;
+ ssl = 1;
+ port = 443;
+ }
+#else
+ if (strlen(url) > 8 && strncmp(url, "https://", 8) == 0) {
+ fprintf(stderr, "SSL not compiled in; no https support\n");
+ exit(1);
+ }
+#endif
+
h = url;
if ((cp = strchr(url, ':')) != NULL) {
*cp++ = '\0';
/* sort out command-line args and call test */
int main(int argc, char **argv)
{
- int c, r,l;
+ int c, r, l;
char tmp[1024];
+ void *res; /* Result pointer for signal handler
+ * installation */
/* table defaults */
tablestring = "";
cookie[0] = '\0';
auth[0] = '\0';
hdrs[0] = '\0';
+ proxyhost[0] = '\0';
optind = 1;
- while ((c = getopt(argc, argv, "n:c:t:T:p:v:kVhwix:y:z:C:H:P:A:")) > 0) {
+ while ((c = getopt(argc, argv, "n:c:t:T:p:v:kVhwix:y:z:C:H:P:A:g:X:de:Sq"
+#if USE_SSL
+ "s"
+#endif
+ )) > 0) {
switch (c) {
+#if USE_SSL
+ case 's':
+ ssl = 1;
+ break;
+#endif
case 'n':
requests = atoi(optarg);
if (!requests) {
err("Invalid number of requests\n");
}
break;
+ case 'q':
+ heartbeatres = 0;
+ break;
case 'k':
keepalive = 1;
break;
case 'c':
concurrency = atoi(optarg);
break;
+ case 'g':
+ gnuplot = strdup(optarg);
+ break;
+ case 'd':
+ percentile = 0;
+ break;
+ case 'e':
+ csvperc = strdup(optarg);
+ break;
+ case 'S':
+ confidence = 0;
+ break;
case 'i':
- if (posting==1)
+ if (posting == 1)
err("Cannot mix POST and HEAD");
posting = -1;
break;
case 'p':
- if (posting!=0)
+ if (posting != 0)
err("Cannot mix POST and HEAD");
if (0 == (r = open_postfile(optarg))) {
case 'T':
strcpy(content_type, optarg);
break;
- case 'C':
+ case 'C':
strncat(cookie, "Cookie: ", sizeof(cookie));
strncat(cookie, optarg, sizeof(cookie));
strncat(cookie, "\r\n", sizeof(cookie));
break;
- case 'A':
- /* assume username passwd already to be in colon separated form. Ready
- * to be uu-encoded.
+ case 'A':
+ /*
+ * assume username passwd already to be in colon separated form.
+ * Ready to be uu-encoded.
*/
- while(isspace(*optarg))
+ while (isspace(*optarg))
optarg++;
- l=ap_base64encode(tmp,optarg,strlen(optarg));
- tmp[l]='\0';
+ l = ap_base64encode(tmp, optarg, strlen(optarg));
+ tmp[l] = '\0';
strncat(auth, "Authorization: Basic ", sizeof(auth));
strncat(auth, tmp, sizeof(auth));
/*
* assume username passwd already to be in colon separated form.
*/
- while(isspace(*optarg))
+ while (isspace(*optarg))
optarg++;
- l=ap_base64encode(tmp,optarg,strlen(optarg));
- tmp[l]='\0';
+ l = ap_base64encode(tmp, optarg, strlen(optarg));
+ tmp[l] = '\0';
strncat(auth, "Proxy-Authorization: Basic ", sizeof(auth));
strncat(auth, tmp, sizeof(auth));
strncat(auth, "\r\n", sizeof(auth));
break;
+ case 'X':
+ {
+ char *p;
+ /*
+ * assume proxy-name[:port]
+ */
+ if (p = index(optarg, ':')) {
+ *p = '\0';
+ p++;
+ proxyport = atoi(p);
+ };
+ strcpy(proxyhost, optarg);
+ isproxy = 1;
+ }
+ break;
case 'H':
strncat(hdrs, optarg, sizeof(hdrs));
strncat(hdrs, "\r\n", sizeof(hdrs));
fprintf(stderr, "%s: wrong number of arguments\n", argv[0]);
usage(argv[0]);
}
-
- if (parse_url(argv[optind++])) {
+ strcpy(url, argv[optind++]);
+ strcpy(fullurl, url);
+ if (parse_url(url)) {
fprintf(stderr, "%s: invalid URL\n", argv[0]);
usage(argv[0]);
}
+ if ((heartbeatres) && (requests > 150)) {
+ heartbeatres = requests / 10; /* Print line every 10% of requests */
+ if (heartbeatres < 100)
+ heartbeatres = 100; /* but never more often than once every 100
+ * connections. */
+ }
+ else
+ heartbeatres = 0;
+
+#ifdef USE_SSL
+ SSL_library_init();
+ if (!(ctx = SSL_CTX_new(SSLv2_client_method()))) {
+ fprintf(stderr, "Could not init SSL CTX");
+ ERR_print_errors_fp(stderr);
+ exit(1);
+ }
+#endif
+ res = signal(SIGPIPE, SIG_IGN); /* Ignore writes to connections that
+ * have been closed at the other end.
+ * These writes are dealt with in the
+ * s_write() function. */
+
copyright();
test();
projects / thirdparty / apache / httpd.git / commitdiff
