zb.c revision b6832863054a2d09233ce92945e0faceb932a620
/* ZeusBench V1.01
===============
This program is Copyright (C) Zeus Technology Limited 1996.
This program may be used and copied freely providing this copyright notice
is not removed.
This software is provided "as is" and any express or implied waranties,
including but not limited to, the implied warranties of merchantability and
fitness for a particular purpose are disclaimed. In no event shall
Zeus Technology Ltd. be liable for any direct, indirect, incidental, special,
exemplary, or consequential damaged (including, but not limited to,
procurement of substitute good or services; loss of use, data, or profits;
or business interruption) however caused and on theory of liability. Whether
in contract, strict liability or tort (including negligence or otherwise)
arising in any way out of the use of this software, even if advised of the
possibility of such damage.
Written by Adam Twiss (adam@zeus.co.uk). March 1996
Thanks to the following people for their input:
Mike Belshe (mbelshe@netscape.com)
Michael Campanella (campanella@stevms.enet.dec.com)
*/
/* -------------------- Notes on compiling ------------------------------
This should compile unmodified using gcc on HP-UX, FreeBSD, Linux,
IRIX, Solaris, AIX and Digital Unix (OSF). On Solaris 2.x you will
need to compile with "-lnsl -lsocket" options. If you have any
difficulties compiling then let me know.
On SunOS 4.x.x you may need to compile with -DSUNOS4 to add the following
two lines of code which appear not to exist in my SunOS headers */
#ifdef SUNOS4
extern char *optarg;
#endif
/* -------------------------------------------------------------------- */
/* affects include files on Solaris */
#define BSD_COMP
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <netdb.h>
#include <errno.h>
#include <string.h>
/* ------------------- DEFINITIONS -------------------------- */
/* maximum number of requests on a time limited test */
#define MAX_REQUESTS 50000
/* good old state machine */
#define STATE_UNCONNECTED 0
#define STATE_CONNECTING 1
#define STATE_READ 2
#define CBUFFSIZE 512
struct connection
{
int fd;
int state;
int read; /* amount of bytes read */
int bread; /* amount of body read */
int length; /* Content-Length value used for keep-alive */
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 cbuff */
};
struct data
{
int read; /* number of bytes read */
int ctime; /* time in ms to connect */
int time; /* time in ms for connection */
};
#define min(a,b) ((a)<(b))?(a):(b)
#define max(a,b) ((a)>(b))?(a):(b)
/* --------------------- GLOBALS ---------------------------- */
int tlimit = 0; /* time limit in cs */
int keepalive = 0; /* try and do keepalive connections */
char *machine; /* Machine name */
char *file; /* file name to use */
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 done=0; /* number of requests we have done */
int doneka=0; /* number of keep alive connections done */
/* store error cases */
/* global request (and its length) */
char request[512];
int reqlen;
/* one global throw-away buffer to read stuff into */
char buffer[4096];
/* --------------------------------------------------------- */
/* simple little function to perror and exit */
static void err(char *s)
{
perror(s);
}
/* --------------------------------------------------------- */
/* write out request to a connection - assumes we can write
(small) request out in one go into our new socket buffer */
void write_request(struct connection *c)
{
gettimeofday(&c->connect,0);
c->state = STATE_READ;
}
/* --------------------------------------------------------- */
/* make an fd non blocking */
{
int i=1;
}
/* --------------------------------------------------------- */
/* returns the time in ms between two timevals */
{
register int us,s;
us /= 1000;
s *= 1000;
return s+us;
}
/* --------------------------------------------------------- */
/* calculate and output results and exit */
void output_results()
{
int timetaken;
gettimeofday(&endtime,0);
printf("\n---\n");
printf("Time taken for tests: %d.%03d seconds\n",
/* avoid divide by zero */
if(timetaken) {
printf("Transfer rate: %.2f kb/s\n",
}
{
/* work out connection times */
int i;
for(i=0; i<requests; i++) {
}
printf("\nConnnection Times (ms)\n");
printf(" min avg max\n");
printf("---\n\n");
}
exit(0);
}
/* --------------------------------------------------------- */
/* start asnchronous non-blocking connection */
void start_connect(struct connection *c)
{
c->read = 0;
c->bread = 0;
c->keepalive = 0;
c->cbx = 0;
c->gotheader = 0;
gettimeofday(&c->start,0);
if(errno==EINPROGRESS) {
c->state = STATE_CONNECTING;
return;
}
else {
err_conn++;
if(bad++>10) {
printf("\nTest aborted after 10 failures\n\n");
exit(1);
}
start_connect(c);
}
}
/* connected first time */
write_request(c);
}
/* --------------------------------------------------------- */
/* close down connection and save stats */
void close_connection(struct connection *c)
{
/* server has legitiamately shut down an idle keep alive request */
good--; /* connection never happend */
}
else {
if(good==1) {
/* first time here */
bad++;
err_length++;
}
/* save out time */
struct data s;
gettimeofday(&c->done,0);
}
}
/* connect again */
start_connect(c);
return;
}
/* --------------------------------------------------------- */
/* read data from connection */
void read_connection(struct connection *c)
{
int r;
good++;
close_connection(c);
return;
}
c->read += r;
totalread += r;
if(!c->gotheader) {
char *s;
int l=4;
/* this next line is so that we talk to NCSA 1.5 which blatantly breaks
the http specifaction */
if(!s) {
/* read rest next time */
if(space)
return;
else {
/* header is in invalid or too big - close connection */
if(bad++>10) {
printf("\nTest aborted after 10 failures\n\n");
exit(1);
}
start_connect(c);
}
}
else {
/* have full header */
if(!good) {
/* this is first time, extract some interesting info */
char *p, *q;
q = server_name;
if(p) { p+=8; while(*p>32) *q++ = *p++; }
*q = 0;
}
c->gotheader = 1;
*s = 0; /* terminate at end of header */
if(keepalive &&
{
char *cl;
/* for cacky servers like NCSA which break the spec and send a
lower case 'l' */
if(cl) {
c->keepalive=1;
}
}
totalbread += c->bread;
}
}
else {
/* outside header, everything we have read is entity body */
c->bread += r;
totalbread += r;
}
/* finished a keep-alive connection */
/* save out time */
if(good==1) {
/* first time here */
struct data s;
gettimeofday(&c->done,0);
}
write_request(c);
}
}
/* --------------------------------------------------------- */
/* run the tests */
int test()
{
int i;
{
/* get server information */
}
/* setup request */
"%sHost: %s\r\nAccept: */*\r\n\r\n", file,
/* ok - lets start */
gettimeofday(&start,0);
/* initialise lots of requests */
int n;
/* setup bit arrays */
/* check for time limit expiry */
gettimeofday(&now,0);
}
/* Timeout of 30 seconds. */
if(!n) {
printf("\nServer timed out\n\n");
exit(1);
}
for(i=0; i<concurrency; i++) {
if(FD_ISSET(s, &sel_except)) {
bad++;
err_except++;
start_connect(&con[i]);
continue;
}
}
}
return 0;
}
/* ------------------------------------------------------- */
/* display usage information */
printf("\nZeusBench v1.0\n\n");
printf("Usage: %s <machine> <file> [-k] [-n requests | -t timelimit (sec)]"
"\n\t\t[-c concurrency] [-p port] \n",progname);
printf("Filename should start with a '/' e.g. /index.html\n\n");
}
/* ------------------------------------------------------- */
/* sort out command-line args and call test */
int c;
optind = 3;
switch(c) {
case 'd':
break;
case 'n':
if(!requests) {
printf("Invalid number of requests\n");
exit(1);
}
break;
case 'k':
keepalive=1;
break;
case 'c':
break;
case 'p':
break;
case 't':
break;
default:
break;
}
}
test();
return 0;
}