
/*                          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; 
extern int optind, opterr, optopt;   
#endif

/*  -------------------------------------------------------------------- */

/* affects include files on Solaris */
#define BSD_COMP

#include <sys/time.h> 
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <errno.h>
#include <sys/ioctl.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 */
  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 cbuff */
  struct timeval start, connect, done; 
};

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 requests = 1;      /* Number of requests to make */
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 *machine;         /* Machine name */
char *file;            /* file name to use */
char server_name[80];  /* name that server reports */
int port = 80;         /* port 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 */
int good=0, bad=0;     /* number of good and bad requests */

/* store error cases */
int err_length = 0, err_conn = 0, err_except = 0;

struct timeval start, endtime;

/* global request (and its length) */
char request[512];
int reqlen;

/* one global throw-away buffer to read stuff into */
char buffer[4096];

struct connection *con;      /* connection array */
struct data *stats;          /* date for each request */

fd_set readbits, writebits;  /* bits for select */
struct sockaddr_in server;   /* server addr structure */

/* --------------------------------------------------------- */

/* simple little function to perror and exit */

static void err(char *s) 
{
  perror(s);
  exit(errno);
}

/* --------------------------------------------------------- */

/* 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);
  write(c->fd,request, reqlen);  
  c->state = STATE_READ;
  FD_SET(c->fd, &readbits);
  FD_CLR(c->fd, &writebits);
}

/* --------------------------------------------------------- */

/* make an fd non blocking */

void nonblock(int fd) 
{
  int i=1;
  ioctl(fd, FIONBIO, &i);
}

/* --------------------------------------------------------- */

/* returns the time in ms between two timevals */

int timedif(struct timeval a, struct timeval b)
{
  register int us,s;

  us = a.tv_usec - b.tv_usec;
  us /= 1000;
  s = a.tv_sec - b.tv_sec;
  s *= 1000;
  return s+us;
}

/* --------------------------------------------------------- */

/* calculate and output results and exit */

void output_results()
{
  int timetaken;
  
  gettimeofday(&endtime,0);
  timetaken = timedif(endtime, start);
  
  printf("\n---\n");
  printf("Server:                 %s\n", server_name);
  printf("Document Length:        %d\n", doclen);  
  printf("Concurency Level:       %d\n", concurrency);
  printf("Time taken for tests:   %d.%03d seconds\n", 
	 timetaken/1000, timetaken%1000);
  printf("Complete requests:      %d\n", done);
  printf("Failed requests:        %d\n", bad);
  if(bad) printf("   (Connect: %d, Length: %d, Exceptions: %d)\n",
		 err_conn, err_length, err_except);
  if(keepalive) printf("Keep-Alive requests:    %d\n", doneka);
  printf("Bytes transfered:       %d\n", totalread);
  printf("HTML transfered:        %d\n", totalbread);
  
  /* avoid divide by zero */
  if(timetaken) {
    printf("Requests per seconds:   %.2f\n", 1000*(float)(done)/timetaken);
    printf("Transfer rate:          %.2f kb/s\n", 
	   (float)(totalread)/timetaken);
  }

  {
    /* work out connection times */
    int i;
    int totalcon=0, total=0;
    int mincon=9999999, mintot=999999;
    int maxcon=0, maxtot=0;

    for(i=0; i<requests; i++) {
      struct data s = stats[i];
      mincon = min(mincon, s.ctime);
      mintot = min(mintot, s.time);
      maxcon = max(maxcon, s.ctime);
      maxtot = max(maxtot, s.time);
      totalcon += s.ctime;
      total += s.time;
    }
    printf("\nConnnection Times (ms)\n");
    printf("           min   avg   max\n");
    printf("Connect: %5d %5d %5d\n",mincon, totalcon/requests, maxcon );
    printf("Total:   %5d %5d %5d\n", mintot, total/requests, maxtot);
    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;

  c->fd = socket(AF_INET, SOCK_STREAM, 0);
  if(c->fd<0) err("socket");

  nonblock(c->fd);
  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 {
      close(c->fd);
      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)
{
  if(c->read == 0 && c->keepalive) {
    /* server has legitiamately shut down an idle keep alive request */
    good--;  /* connection never happend */
  } 
  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;
      gettimeofday(&c->done,0);
      s.read = c->read;
      s.ctime = timedif(c->connect, c->start);
      s.time = timedif(c->done, c->start);
      stats[done++] = s;
    }
  }

  close(c->fd);
  FD_CLR(c->fd, &readbits);
  FD_CLR(c->fd, &writebits);

  /* connect again */
  start_connect(c); 
  return;
}

/* --------------------------------------------------------- */

/* read data from connection */

void read_connection(struct connection *c)
{
  int r;
  
  r=read(c->fd,buffer,sizeof(buffer));
  if(r==0 || (r<0 && errno!=EAGAIN)) {
    good++;
    close_connection(c);
    return;
  } 
  
  if(r<0 && errno==EAGAIN) return;

  c->read += r;
  totalread += r;
  
  if(!c->gotheader) {
    char *s;
    int l=4;
    int space = CBUFFSIZE - c->cbx - 1; /* -1 to allow for 0 terminator */
    int tocopy = (space<r)?space:r;
    memcpy(c->cbuff+c->cbx, buffer, space);
    c->cbx += tocopy; space -= tocopy;
    c->cbuff[c->cbx] = 0; /* terminate for benefit of strstr */
    s = strstr(c->cbuff, "\r\n\r\n");
    /* this next line is so that we talk to NCSA 1.5 which blatantly breaks 
       the http specifaction */
    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 */
	close(c->fd);
	if(bad++>10) {
	  printf("\nTest aborted after 10 failures\n\n");
	  exit(1);
	} 
	FD_CLR(c->fd, &writebits);
	start_connect(c);
      }	
    }
    else {
      /* have full header */
      if(!good) {
	/* this is first time, extract some interesting info */
	char *p, *q;
	p = strstr(c->cbuff, "Server:");
	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 && 
	 (strstr(c->cbuff, "Keep-Alive") 
	  || strstr(c->cbuff, "keep-alive")))  /* for benefit of MSIIS */
	{
	char *cl;
	cl = strstr(c->cbuff, "Content-Length:");
	/* for cacky servers like NCSA which break the spec and send a 
	   lower case 'l' */
	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;
      gettimeofday(&c->done,0);
      s.read = c->read;
      s.ctime = timedif(c->connect, c->start);
      s.time = timedif(c->done, c->start);
      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 */
  }
}

/* --------------------------------------------------------- */

/* run the tests */

int test() 
{
  struct timeval timeout, now;
  fd_set sel_read, sel_except, sel_write;
  int i;
  
  {
    /* get server information */
    struct hostent *he;
    he = gethostbyname(machine);
    if (!he) err("gethostbyname");
    server.sin_family      = he->h_addrtype;
    server.sin_port        = htons(port);
    server.sin_addr.s_addr = ((unsigned long *)(he->h_addr_list[0]))[0];
  }

  con = malloc(concurrency*sizeof(struct connection));
  memset(con,0,concurrency*sizeof(struct connection));
  
  stats = malloc(requests * sizeof(struct data));

  FD_ZERO(&readbits);
  FD_ZERO(&writebits);

  /* setup request */
  sprintf(request,"GET %s HTTP/1.0\r\nUser-Agent: ZeusBench/1.0\r\n"
	  "%sHost: %s\r\nAccept: */*\r\n\r\n", file, 
	  keepalive?"Connection: Keep-Alive\r\n":"", machine );
    
  reqlen = strlen(request);

  /* ok - lets start */
  gettimeofday(&start,0);

  /* initialise lots of requests */
  for(i=0; i<concurrency; i++) start_connect(&con[i]);

  while(done<requests) {
    int n;
    /* setup bit arrays */
    memcpy(&sel_except, &readbits, sizeof(readbits));
    memcpy(&sel_read, &readbits, sizeof(readbits));
    memcpy(&sel_write, &writebits, sizeof(readbits));

    /* check for time limit expiry */
    gettimeofday(&now,0);
    if(tlimit && timedif(now,start) > (tlimit*1000)) {
      requests=done;   /* so stats are correct */
      output_results();
    }

    /* Timeout of 30 seconds. */
    timeout.tv_sec=30; timeout.tv_usec=0;
    n=select(256, &sel_read, &sel_write, &sel_except, &timeout);
    if(!n) {
      printf("\nServer timed out\n\n");
      exit(1);
    }
    if(n<1) err("select");

    for(i=0; i<concurrency; i++) {
      int s = con[i].fd;
      if(FD_ISSET(s, &sel_except)) {
	bad++; 
	err_except++;
	start_connect(&con[i]);
	continue;
      }
      if(FD_ISSET(s, &sel_read)) read_connection(&con[i]);
      if(FD_ISSET(s, &sel_write)) write_request(&con[i]);
    }
    if(done>=requests) output_results();
  }
  return 0;
}

/* ------------------------------------------------------- */

/* display usage information */

void usage(char *progname) {
  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");
  exit(EINVAL);
}

/* ------------------------------------------------------- */

/* sort out command-line args and call test */

int main(int argc, char **argv) {
  int c;
  if (argc < 3) usage(argv[0]);
  
  machine = argv[1]; 
  file = argv[2];
  optind = 3;
  while ((c = getopt(argc,argv,"p:n:c:d:t:d:k"))>0) {
    switch(c) {
    case 'd':
      break;
    case 'n': 
      requests = atoi(optarg);
      if(!requests) {
	printf("Invalid number of requests\n");
	exit(1);
      }
      break;
    case 'k':
      keepalive=1;
      break;
    case 'c':
      concurrency = atoi(optarg);
      break;
    case 'p':
      port = atoi(optarg);
      break;
    case 't':
      tlimit = atoi(optarg);
      requests = MAX_REQUESTS;  /* need to size data array on something */
      break;
    default:
      usage(argv[0]);
      break;
    }
  }   
  test();
  return 0;
}