ACE/apps/JAWS/clients/WebSTONE/src/webmaster.c

   1 /**************************************************************************
   2  *                    *
   3  *     Copyright (C) 1995 Silicon Graphics, Inc.      *
   4  *                    *
   5  *  These coded instructions, statements, and computer programs were    *
   6  *  developed by SGI for public use.  If any changes are made to this code*
   7  *  please try to get the changes back to the author.  Feel free to make  *
   8  *  modifications and changes to the code and release it.     *
   9  *                    *
  10  **************************************************************************/
  11
  12 /* FUZZ: disable check_for_math_include */
  13 /* FUZZ: disable check_for_improper_main_declaration */
  14
  15 #include <stdio.h>
  16 #include <errno.h>
  17 #include <signal.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <time.h>
  21
  22 #ifndef WIN32
  23 #include <unistd.h>
  24 #endif /* WIN32 */
  25
  26 #include <math.h>
  27
  28 #ifndef WIN32
  29 #include <sys/param.h>
  30 #include <sys/types.h>
  31 #include <sys/errno.h>
  32 #include <sys/socket.h>
  33 #include <sys/time.h>
  34 #include <netinet/in.h>
  35 #include <netdb.h>
  36 #else
  37 #define FD_SETSIZE  1024 /* max size for select() - keep before <winsock.h>
  38         * and same size as MAXCLIENTS */
  39 #include <windows.h>
  40 #include <winsock.h>
  41 #include <io.h>
  42 #include <process.h>
  43 #endif /* WIN32 */
  44
  45 #include "sysdep.h"
  46 #include "bench.h"
  47
  48 /* command line options/data */
  49 int     savefile = 0;
  50 int     debug = 0;
  51 int     norexec = 0;
  52 int     haveproxyserver = 0;
  53 char      proxyserver[MAXHOSTNAMELEN];
  54 char      network_mask_str[30] = "255.255.255.0";
  55 unsigned    network_mask = 0;
  56 int     servaddrin_config = 0;
  57 int     dumpall = 0;
  58 int     testtime = 0;
  59 int     havewebserver = 0;
  60 int     numloops = 0;
  61 NETPORT     portnum = 0;
  62 int     redirect = 0;
  63 int     record_all_transactions = 0;
  64 int     uil_filelist_f = 0;
  65 int     verbose = 0;
  66 char      webserver[MAXHOSTNAMELEN];
  67 char      configfile[MAXPATHLEN];
  68 char      uil_filelist[NCCARGS];
  69
  70 char      filelist[256][MAXPATHLEN];
  71 fd_set      zerofdset;
  72
  73 /* other key data */
  74 long int    number_of_pages = 0;
  75 int     totalnumclients = 0;
  76 int     num_rexecs = 0;
  77 SOCKET      socknum[MAXCLIENTS];
  78 SOCKET      sockIO[MAXTOTALPROCS];
  79 SOCKET      sockErr[MAXTOTALPROCS];
  80 THREAD FILE *debugfile = stderr;
  81 struct hostent  *master_phe;   /* IP addresses for webmaster */
  82 struct timeval sumedh_start, sumedh_end;
  83
  84 void HostEntCpy(struct hostent *dest, struct hostent *src);
  85
  86 static void
  87 usage(const char *progname)
  88 {
  89
  90   fprintf(stderr, "Usage: %s [-a] [-d] -f config_file [-l numloops]\n",
  91     progname);
  92   fprintf(stderr, "          [-p port_num] [-r] [-s] [-t run_time] \n");
  93   fprintf(stderr, "\n");
  94         fprintf(stderr, "-w webserver URL [URL ...]\n\n");
  95         fprintf(stderr, "-a print timing information for all clients\n");
  96         fprintf(stderr, "-d turn on debug statements\n");
  97         fprintf(stderr, "-f config_file\tfile specifying clients\n");
  98         fprintf(stderr, "-l number of iterations to retrieve uils\n");
  99         fprintf(stderr, "-p port number of web server if not 80\n");
 100         fprintf(stderr, "-r redirect stdout of clients to /tmp/webstone.xxx\n");
 101         fprintf(stderr, "-s save client gets to /tmp/webstone.data.*\n");
 102         fprintf(stderr, "-t run_time\tduration of test in minutes\n");
 103         fprintf(stderr, "-w webserver\tname of webserver host to contact\n");
 104   fprintf(stderr, "-u URL file\tfilelist of URLs\n");
 105   fprintf(stderr, "-v verbose mode\n");
 106   fprintf(stderr, "-P servername\tuse proxy server for transactions\n");
 107   fprintf(stderr, "-W webserver addresses are in the config file\n");
 108   fprintf(stderr, "-R record all transactions\n");
 109   errexit("\n");
 110 }
 111
 112 static SOCKET
 113 passivesock(const NETPORT portnum, const char *protocol, const int qlen)
 114 {
 115   struct protoent    *ppe; /* pointer to protocol info entry */
 116   struct sockaddr_in sin;  /* Internet endpoint address */
 117   SOCKET    s;             /* socket descriptor */
 118   int    type;             /* socket type */
 119
 120   D_PRINTF( "Beginning passivesock with errno %d\n",errno );
 121
 122   D_PRINTF( "Zeroing address structure\n" );
 123   memset((char *)&sin, 0, sizeof(sin));
 124
 125   sin.sin_family = AF_INET;
 126   sin.sin_addr.s_addr = INADDR_ANY;
 127
 128   /* NOT USED: Map service name to portnumber */
 129   D_PRINTF( "Mapping portnum errno %d\n",errno );
 130   sin.sin_port = htons(portnum);
 131
 132   /* Map protocol name to number */
 133   D_PRINTF( "Mapping protocol name errno %d\n",errno );
 134   if ((ppe = getprotobyname(protocol)) == 0)
 135     {
 136     errexit("Can't get \"%s\" protocol entry\n", protocol);
 137     }
 138   errno = 0;
 139
 140   /* use protocol to choose socket type */
 141   D_PRINTF( "Changing socket type, errno %d\n",errno );
 142   if (strcmp(protocol, "udp") == 0)
 143     {
 144       type = SOCK_DGRAM;
 145   D_PRINTF( "Choosing SOCK_DGRAM\n" );
 146     }
 147   else
 148     {
 149       type = SOCK_STREAM;
 150   D_PRINTF( "Choosing SOCK_STREAM, errno %d\n",errno );
 151     }
 152
 153   /* allocate a socket */
 154   s = socket(PF_INET, type, ppe->p_proto);
 155   if (BADSOCKET(s))
 156     {
 157       D_PRINTF( "Socket PF_INET %d %d returned %d with %s\n",
 158   type, ppe->p_proto, s, neterrstr() );
 159       errexit("Can't create socket: %s\n", neterrstr());
 160     }
 161   D_PRINTF( "Socket %d created with errno %d\n",s,errno );
 162
 163   /* Bind the socket */
 164   if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
 165   {
 166     errexit("Can't bind to port %d: %s\n", portnum, neterrstr());
 167   }
 168   D_PRINTF( "Bind succeeded\n" );
 169
 170   /* If it's a stream, listen for connections */
 171   /* NOTE: ON NT, the listen() backlog parm is silently limited to 5 conns */
 172   if ((type == SOCK_STREAM) && BADSOCKET(listen(s, qlen)))
 173   {
 174       errexit("Can't listen on port %s: %s\n", portnum, neterrstr());
 175   }
 176   D_PRINTF( "Listen succeeded\n" );
 177
 178   /* all done, return socket descriptor */
 179   return(s);
 180 }
 181
 182
 183 /* abort clients -- called by SIGINT handler */
 184 static void abort_clients(void)
 185 {
 186     /* Not supposed to have fprintf in a signal handler, but... */
 187     fprintf(stdout, "Webmaster received SIGINT.  Terminating.\n");
 188     /* exit will close all open connections */
 189     exit(2);
 190 }
 191
 192 /* signal handler for SIGINT */
 193 static void sig_int(int sig) {
 194
 195     abort_clients();
 196 }
 197
 198 #ifdef WIN32
 199
 200 /* echo stdout/stderr from clients */
 201 void echo_client(void *stream)
 202 {
 203     SOCKET *sockarr;
 204     FILE *outfile;
 205     int which_stream = (int) stream;
 206     char buf[BUFSIZ];
 207     int i, len, rv;
 208     fd_set readfds;
 209
 210     /* This code which handles the timeout may need
 211        to be ifdef'ed for WIN32 */
 212     struct timeval timeout;
 213
 214     timeout.tv_sec = (long)5;
 215     timeout.tv_usec = (long)0;
 216
 217     if (which_stream) {
 218   sockarr = sockIO;
 219   outfile = stdout;
 220     } else {
 221   sockarr = sockErr;
 222   outfile = stderr;
 223     }
 224
 225     D_PRINTF( "echo_client running\n" );
 226     signal( SIGINT, SIG_DFL); /* restore default behavior
 227          for SIGINT */
 228
 229     while (1) {
 230   FD_ZERO(&readfds);
 231   for (i = 0; i < num_rexecs; i++)
 232       if (sockarr[i] != BADSOCKET_VALUE)
 233     FD_SET(sockarr[i], &readfds);
 234   rv = select(num_rexecs, &readfds, 0, 0, &timeout);
 235   if ( rv == 0)
 236     continue;
 237   if (rv < 0 && WSAGetLastError() == WSANOTINITIALISED)
 238       return;
 239   if (rv < 0)
 240       errexit("Error in echo_client(): select() returns %d: %s\n", rv, neterrstr());
 241
 242   /* loop over the sockets that are ready with data */
 243   for (i = 0; i < num_rexecs; i++) {
 244       if (sockarr[i] != BADSOCKET_VALUE && FD_ISSET(sockarr[i], &readfds)) {
 245     len = NETREAD(sockarr[i], buf, sizeof(buf));
 246     if (len <= 0) {
 247         /* mark connection closed */
 248         sockarr[i] = BADSOCKET_VALUE;
 249         if (len < 0 && WSAGetLastError() == WSANOTINITIALISED)
 250       return;
 251         if (len < 0)
 252       fprintf(stderr, "Error in echo_client() after NETREAD(): %s\n", neterrstr());
 253         continue;
 254     }
 255
 256     /* copy to stdout or stderr */
 257     fwrite(buf, sizeof(char), len, outfile);
 258       }
 259   }
 260     }
 261     D_PRINTF( "Exiting echo_client\n" );
 262 }
 263
 264 #else
 265 static int
 266 echo_client(char *hostname, const int fd)
 267 {
 268   /*
 269    * WRITE TEXT FROM FILE DESCRIPTOR INTO STDOUT
 270    */
 271   char buf[BUFSIZ];
 272   int  cc;
 273   D_PRINTF( "echo_client running\n" );
 274
 275   while (getppid() != 1)
 276     {
 277       cc = NETREAD(fd, buf, sizeof(buf));
 278       if (cc > 0)
 279       {
 280     write(STDOUT_FILENO, buf, cc);
 281       }
 282   }
 283   D_PRINTF( "Exiting echo_client\n" );
 284   NETCLOSE(fd);
 285 }
 286 #endif /* WIN32 */
 287
 288 /* Picks the appropriate webmaster IP address based on the address of the client.
 289  * This is significant only for hosts with multiple interfaces
 290  *
 291  * return value is a string with the IP address or hostname (or NULL)
 292  */
 293 char *pick_webmaster_IP_address(char *client_hostname, struct hostent *master_phe,
 294         unsigned netmask) {
 295 static char buf[20];
 296 unsigned char   addr[4];
 297 int client_addr;
 298 int i;
 299
 300     if (client_hostname[0] >= '0' && client_hostname[0] <= '9') {
 301   /* we have an IP address */
 302   client_addr = inet_addr(client_hostname);
 303   if (client_addr == INADDR_NONE)
 304       return 0;
 305     } else {
 306   /* we have a hostname, use the webserver hostname */
 307   return master_phe->h_name;
 308     }
 309
 310     for (i = 0; master_phe->h_addr_list[i] != 0; i++) {
 311   if ((*(int *)(master_phe->h_addr_list[i]) & netmask) ==
 312     (client_addr & netmask))
 313       goto gotit;
 314     }
 315     i = 0;  /* give up */
 316
 317 gotit:
 318     memcpy((char *)addr, master_phe->h_addr_list[i], sizeof(addr));  /* Internet specific */
 319     sprintf(buf, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
 320     return buf;
 321 }
 322
 323 /*
 324   Command line parsing
 325 */
 326
 327 void ParseCmdLine(int argc, char **argv )
 328 {
 329 char    getoptch;
 330 int   currarg;
 331 extern char *optarg;
 332 extern int  optind;
 333
 334     /*
 335      * PARSE THE COMMAND LINE OPTIONS
 336      */
 337     while((getoptch = getopt(argc,argv,"P:f:t:l:p:u:R:w:n:M:adrsvWX")) != (const char)EOF)
 338       {
 339         switch(getoptch)
 340     {
 341     case 'M':
 342       strcpy(network_mask_str, optarg);
 343       break;
 344     case 'P':
 345       haveproxyserver = 1;
 346       strcpy(proxyserver, optarg);
 347       break;
 348     case 'R':
 349       record_all_transactions = 1;
 350       break;
 351     case 'X':
 352       norexec = 1;
 353       break;
 354     case 'W':
 355       servaddrin_config = 1;
 356       break;
 357     case 'a':
 358       dumpall = 1;
 359       break;
 360     case 'd':
 361       debug = 1;
 362       break;
 363     case 'f':
 364       strcpy(configfile, optarg);
 365       break;
 366     case 'l':
 367       numloops = atoi(optarg);
 368       break;
 369     case 'p':
 370       portnum = atoi(optarg);
 371       break;
 372     case 'r':
 373       redirect = 1;
 374       break;
 375     case 's':
 376       savefile = 1;
 377       break;
 378     case 't':
 379       testtime = atoi(optarg);
 380       break;
 381     case 'u':
 382       uil_filelist_f = 1;
 383       strcpy(uil_filelist, optarg);
 384       break;
 385     case 'v':
 386       verbose = 1;
 387       break;
 388     case 'w':
 389       havewebserver = 1;
 390       strcpy(webserver, optarg);
 391       break;
 392     default:
 393       usage(argv[0]);
 394     } /* end switch */
 395       } /* end while */
 396
 397     if (numloops && testtime)
 398   errexit("Can't have both -l and -t\n");
 399
 400     if(!havewebserver && !servaddrin_config)
 401     {
 402         /*
 403          * THE SERVERS NAME MUST BE SPECIFIED
 404          */
 405
 406         fprintf(stderr,"No WWW Server specified\n");
 407         usage(argv[0]);
 408     }
 409
 410     if (havewebserver && servaddrin_config)
 411     {
 412   /*
 413    * CAN'T HAVE BOTH -w and -W
 414    */
 415   fprintf(stderr, "Can't have both -w and -W options\n");
 416   usage(argv[0]);
 417     }
 418
 419     network_mask = inet_addr(network_mask_str);
 420     if (network_mask == INADDR_NONE) {
 421   fprintf(stderr, "Invalid network mask (-M %s)\n", network_mask_str);
 422   usage(argv[0]);
 423     }
 424
 425     if(strlen(configfile) == 0)
 426     {
 427         /*
 428          * THE MASTER MUST HAVE A CONFIGURATION FILE TO READ.
 429          */
 430         fprintf(stderr,"No Configuration file specified\n");
 431         usage(argv[0]);
 432     }
 433     /* IF WE DO NOT HAVE A FILE LIST THEN THERE ARE UIL'S AT THE END OF THE
 434      * COMMAND LINE SO GRAB THEM.
 435      */
 436     if (uil_filelist_f == 0)
 437     {
 438   currarg = optind;
 439   number_of_pages = 0;
 440   while(currarg != argc)
 441   {
 442      /*
 443       * GET THE UILS TO RETRIEVE.
 444       */
 445
 446       sscanf(argv[currarg],"%s",filelist[number_of_pages]);
 447       number_of_pages++;
 448       currarg++;
 449   }
 450     }
 451     else
 452     {
 453   /* have filelist; take a stab at the number of valid URLs */
 454   D_PRINTF( "About to parse filelist %s\n", uil_filelist );
 455   number_of_pages = count_file_list(uil_filelist);
 456     }
 457     if (number_of_pages == 0)
 458     {
 459        /*
 460   * AT LEAST ONE FILE MUST BE SPECIFIED
 461   */
 462   fprintf(stderr,"No URL resources specified\n");
 463   usage(argv[0]);
 464     }
 465 }
 466
 467 /*
 468   This function sets up the socket we will use to synchronize with the
 469   clients.
 470   Returns the socket number if successful, doesn't return if it fails
 471 */
 472
 473 SOCKET SetupSyncSocket( serveraddr )
 474 struct sockaddr_in *serveraddr;
 475 {
 476   int sock,len;
 477
 478     /*
 479      * SET UP THE SOCKET WE ARE GOING TO USE TO SYNCHRONIZE WITH THE CLIENTS.
 480      */
 481     D_PRINTF( "About to call sock %d %d\n", portnum, MAXCLIENTS );
 482
 483     sock = passivesock(0, "tcp", MAXCLIENTS);
 484
 485     if (BADSOCKET(sock))
 486     {
 487         errexit("Couldn't open socket %d: %s\n", sock, neterrstr());
 488     }
 489   D_PRINTF( "The passivesock call succeeded\n" );
 490
 491     D_PRINTF( "calling getsockname\n" );
 492
 493     len = sizeof(struct sockaddr);
 494     if(getsockname(sock, (struct sockaddr *)serveraddr, &len) < 0)
 495     {
 496   errexit("Could not get socket informaton\n");
 497     }
 498
 499   return( sock );
 500 }
 501
 502 /*
 503   Function which generates a commandline for the webclients
 504 */
 505 void MakeCmdLine( commandline)
 506 char *commandline;
 507 {
 508     char tmpcommandline[NCCARGS];
 509     char hostname[MAXHOSTNAMELEN];
 510     char *webclient_path, *temp;
 511     int  cnt;
 512     struct hostent  *master_phe_tmp; /* temp. variable added by - Rajesh Shah*/
 513
 514     /*
 515      * BUILD THE PORTIONS OF THE cmdline FOR EACH CLIENT THAT WE CAN BUILD NOW.
 516      * WE WILL FILL IN THE NUMBER OF CLIENTS LATER WITH AN sprintf.
 517      */
 518     D_PRINTF( "Calling gethostname\n" );
 519
 520     if(gethostname(hostname,MAXHOSTNAMELEN) != 0)
 521     {
 522   errexit("Could not retrieve local host name");
 523     } else {
 524   /* convert hostname to address (to avoid DNS problems for webclients) */
 525   /* The following lines are add to copy the system
 526      buffer (output of gethostbyname()) into user area.
 527            This is because, there are very good chances that later
 528      on system buffer might be overwritten by some calls and
 529      still if your pointer is pointing to same addr. nothing
 530      but only trouble and trouble! Infact this is what
 531            happening when I tried to run webstone benchmark for more
 532            then one clients. It used to over write the webmaster name
 533      with the first client name and so remaining on client(s)
 534      the webclient process(es) were invoked with wrong webmaster
 535      name! This behaviour is observed Solaris 2.4 this bug
 536      can be hit in any OS.    - Rajesh Shah 5/18/96 */
 537
 538   /* master_phe = gethostbyname(hostname); */
 539   master_phe_tmp = gethostbyname(hostname);
 540   master_phe = (struct hostent *)malloc(sizeof(struct hostent));
 541   HostEntCpy(master_phe, master_phe_tmp);
 542     }
 543
 544     /* set up executable pathname */
 545 #ifndef WIN32
 546     temp = getenv("TMPDIR");
 547
 548     if ( temp && *temp ) {
 549       webclient_path = (char *)mymalloc( strlen(temp) + strlen("/webclient")
 550               + 1);
 551       strcpy(webclient_path, temp);
 552       strcat(webclient_path, "/webclient");
 553
 554     } else
 555 #else
 556     temp = temp;
 557 #endif /* WIN32 */
 558       webclient_path = PROGPATH;
 559
 560
 561     D_PRINTF( "Path to webclient is: %s\n", webclient_path );
 562
 563     sprintf(commandline,"%s", webclient_path);
 564
 565     if(haveproxyserver)
 566     {
 567         sprintf(tmpcommandline, " -P %s", proxyserver);
 568         strcat(commandline, tmpcommandline);
 569     }
 570     if (debug)
 571     {
 572        strcat(commandline," -d");
 573     }
 574     if (numloops != 0)
 575     {
 576         sprintf(tmpcommandline," -l %d", numloops);
 577         strcat(commandline,tmpcommandline);
 578     }
 579     if (portnum)
 580     {
 581         sprintf(tmpcommandline," -p %d", portnum);
 582         strcat(commandline,tmpcommandline);
 583     }
 584     if (redirect)
 585     {
 586         strcat(commandline," -r");
 587     }
 588     if (savefile)
 589     {
 590         strcat(commandline," -s");
 591     }
 592     if (uil_filelist_f)
 593     {
 594         strcat(commandline," -u ");
 595   strcat(commandline,uil_filelist);
 596     }
 597     if (record_all_transactions)
 598     {
 599   strcat(commandline," -R");
 600     }
 601     if (testtime != 0)
 602     {
 603         sprintf(tmpcommandline," -t %d", testtime);
 604         strcat(commandline,tmpcommandline);
 605     }
 606
 607     /*
 608      * SET UP A SPACE FOR THE NUMBER OF CLIENTS ON THE commandline.
 609      */
 610     sprintf(tmpcommandline,"%s -n %%d -w %%s -c %%s:%%d", commandline);
 611     strcpy(commandline,tmpcommandline);
 612
 613     if (uil_filelist_f == 0)
 614     {
 615   cnt = 0;
 616   while(cnt < number_of_pages)
 617   {
 618      /*
 619       * PUT THE FILES AT THE END OF THE LIST.
 620       */
 621       strcat(commandline," ");
 622       strcat(commandline,filelist[cnt]);
 623       cnt++;
 624   }
 625     }
 626     puts(commandline);
 627 }
 628
 629 /*
 630   rexec to the client hosts and start the webclients
 631 */
 632 int RexecClients( commandline, clienthostname, serveraddr)
 633 char *commandline;
 634 char  clienthostname[MAXCLIENTS][MAXHOSTNAMELEN];
 635 struct sockaddr_in  *serveraddr;
 636
 637 {
 638   int   tmpfd;
 639   int   numclients = 0;
 640   char    tmpcommandline[NCCARGS];
 641   struct servent *inetport;
 642   int   cnt;
 643   char    buffer[NCCARGS];
 644   char    login[MAXUSERNAME];
 645   char    password[MAXPASSWD];
 646   FILE    *fp;
 647   int   returnval;
 648   char    *tmphostname;
 649
 650   memset(buffer, 0, sizeof(buffer));
 651
 652     /*
 653      * OPEN UP THE CONFIG FILE. FOR EACH LINE IN THE CONFIG FILE, CHECK
 654      * ITS VALIDITY AND THEN rexec A COMMAND ON THE CLIENT.
 655      */
 656
 657     if ((fp = fopen(configfile,"r")) == 0)
 658     {
 659         errexit("Could not open config file %s\n", configfile);
 660     }
 661
 662     if ((inetport = getservbyname("exec","tcp")) == 0)
 663     {
 664         errexit("Could not get service name for exec/tcp\n");
 665     }
 666     D_PRINTF( "getservbyname returned %d\n", ntohs(inetport->s_port) );
 667
 668     cnt = 0;
 669
 670     D_PRINTF( "rexec loop\n" );
 671     while(1)
 672     {
 673   char webserver2[MAXHOSTNAMELEN];
 674   char linebuf[150];
 675   int num;
 676   char *primename;
 677
 678   if (0 == fgets(linebuf, sizeof(linebuf), fp))
 679       break;
 680   num = sscanf(linebuf,"%s %s %s %d %s",clienthostname[cnt],login,password,
 681               &numclients, webserver2);
 682   if (num < 4)
 683       break;
 684   if (servaddrin_config) {
 685       if (num == 4) {
 686     errexit("No webserver specified in config file for %s\n", clienthostname[cnt]);
 687       }
 688       strcpy(webserver, webserver2);
 689   }
 690
 691   if (numclients <= 0)
 692       errexit("Number of clients must be >= 0\n");
 693   if (numclients > MAXPROCSPERNODE)
 694   {
 695       errexit("Number of clients per node can't exceed %d\n", MAXPROCSPERNODE);
 696   }
 697         totalnumclients += numclients;
 698
 699   primename = pick_webmaster_IP_address(clienthostname[cnt], master_phe, network_mask);
 700   if (primename == 0) {
 701       errexit("Bad client address %s for Client %d\n", clienthostname[cnt], cnt);
 702   }
 703
 704         fprintf(stdout,"Client %d: %s \t# Processes: %d\n    Webserver: %s\tWebmaster: %s:%d\n",
 705     cnt, clienthostname[cnt], numclients, webserver, primename,
 706     ntohs(serveraddr->sin_port));
 707   fflush(stdout);
 708         sprintf(tmpcommandline, commandline, numclients, webserver, primename,
 709       ntohs(serveraddr->sin_port));
 710
 711         fprintf(stderr, "tmpcommandline: %s\n", tmpcommandline);
 712
 713   D_PRINTF( "%s rexec %s\n",&clienthostname[cnt],tmpcommandline );
 714   if (norexec) {
 715       sleep(30);  /* gives some time to start clients for debugging */
 716   } else {
 717
 718       tmphostname = &(clienthostname[cnt][0]);
 719       tmpfd = rexec(&tmphostname, inetport->s_port, login, password,
 720             tmpcommandline, &sockErr[cnt]);
 721       if((sockIO[cnt] = tmpfd) < 0)
 722       {
 723     errexit("Could not rexec: rexec to client %s, cmdline %s failed\n",
 724       clienthostname[cnt],tmpcommandline);
 725       }
 726   }
 727
 728
 729   returnval = NETREAD(tmpfd, buffer, OKSTRLEN);
 730   D_PRINTF( "read returns %d, %s\n", returnval, buffer );
 731
 732   if (returnval <= 0 || memcmp(buffer, OKSTR, OKSTRLEN) != 0)
 733   {
 734           errexit("rexec to client %s, cmdline %s received error %s\n",
 735       clienthostname[cnt],tmpcommandline, buffer);
 736   }
 737
 738
 739   cnt++;
 740   if (cnt > MAXCLIENTS || cnt > FD_SETSIZE)
 741   {
 742       errexit("Number of Clients can't exceed %d\n", MAXCLIENTS);
 743   }
 744     }
 745
 746     num_rexecs = cnt;
 747     if (totalnumclients > MAXTOTALPROCS)
 748     {
 749         errexit("Total number of processes can't exceed  %d\n",
 750     MAXTOTALPROCS);
 751     }
 752
 753 #ifndef WIN32
 754       /* NOW WE NEED TO HANDLE THE OUTPUT FROM THE REXEC.
 755        * TO DO THIS, WE FORK, THEN HAVE ONE PROCESS READ FROM TMPFD.
 756        * THE OTHER PROCESS CONTINUES WITH THE PROGRAM
 757        */
 758       D_PRINTF( "Forking webclient stderr/stdout processes\n" );
 759       switch (fork())
 760   {
 761   case -1:   /* ERROR */
 762     errexit("fork: %s\n", strerror(errno));
 763   case 0:    /* CHILD */
 764     exit(echo_client(clienthostname[cnt], tmpfd));
 765   default:   /* PARENT */
 766     break;
 767   }
 768 #else
 769     /* start threads to echo stdout/stderr from clients */
 770     _beginthread(echo_client, 0, (void *)0);
 771     _beginthread(echo_client, 0, (void *)1);
 772 #endif /* WIN32 */
 773
 774     fprintf(stdout,"\n");
 775     fprintf(stdout,"\n");
 776     fclose(fp);
 777
 778     return totalnumclients;
 779 }
 780
 781 void GetReady( fdset, totalnumclients, sock )
 782 fd_set *fdset;
 783 int totalnumclients;
 784 int sock;
 785 {
 786   int cnt,len;
 787   fd_set tmpfdset, leftfdset;
 788   char  buffer[NCCARGS];
 789
 790     /*
 791      * NOW WE NEED TO ACCEPT ALL THE CONNECTIONS FROM THE CLIENTS,
 792      * ACCEPT ALL THE READY MESSAGES
 793      */
 794
 795     D_PRINTF( "Beginning accept loop\n" );
 796     for (cnt = 0; cnt < totalnumclients; cnt++)
 797     {
 798   D_PRINTF( "Client %d:\t", cnt );
 799
 800   {
 801       fd_set readfds;
 802       struct timeval timeout;
 803       int rv;
 804
 805       timeout.tv_sec = MAX_ACCEPT_SECS;
 806       timeout.tv_usec = 0;
 807       FD_ZERO(&readfds);
 808       FD_SET(sock, &readfds);
 809
 810       /* if we're hung, quit */
 811       D_PRINTF("Before select() on listen() socket\n");
 812       if (!(rv = select(FD_SETSIZE, &readfds, 0, 0, &timeout)))  {
 813     fprintf(stdout,
 814         "Listen timeout after %d seconds (%d clients so far)\n",
 815         MAX_ACCEPT_SECS, cnt);
 816     D_PRINTF("select() timed out after %d seconds\n", MAX_ACCEPT_SECS);
 817     errexit("Webmaster terminating\n");
 818       }
 819   }
 820
 821         if(BADSOCKET(socknum[cnt] = accept(sock, 0, 0)))
 822         {
 823             /*
 824              * ERROR accepting FROM THE CLIENTS. WE NEED TO ISSUE AN
 825              * ABORT TO ALL.
 826              */
 827             abort_clients();
 828             errexit("Error accepting from one of the clients: %s", neterrstr());
 829         } else
 830         {
 831             /*
 832              * SET THE FD IN THE MASK
 833              */
 834             FD_SET(socknum[cnt],fdset);
 835         }
 836   D_PRINTF( "on socket %d\n",socknum[cnt] );
 837     }
 838     D_PRINTF( "\n" );
 839
 840     /*
 841      * WAIT FOR A READY.
 842      */
 843     sleep(1);
 844     fprintf(stdout,"Waiting for READY from %d clients\n",totalnumclients);
 845     fflush(stdout);
 846     leftfdset = *fdset;
 847 #ifndef WIN32
 848     while(memcmp(&leftfdset,&zerofdset,sizeof(fd_set)))
 849     {
 850         tmpfdset = leftfdset;
 851
 852         if(select(FD_SETSIZE,&tmpfdset,NULL,NULL,NULL) < 0)
 853         {
 854             /*
 855              * ERROR SELECTING. ABORT ALL.
 856              */
 857             abort_clients();
 858             errexit("Error accepting from one of the clients: %s\n",
 859       neterrstr());
 860             break;
 861         }
 862 #else
 863     /* I don't see why a select is needed at all--all clients must respond
 864      * and there is no synchronization/timing issue.
 865      */
 866     tmpfdset = leftfdset;
 867     {
 868 #endif /* WIN32 */
 869
 870         for (cnt = 0; cnt < totalnumclients; cnt++)
 871         {
 872             /*
 873              * SEE WHICH SOCKETS HAVE A INPUT ON THEM PENDING
 874              * AND RECEIVE IT.
 875              */
 876             if(!BADSOCKET(socknum[cnt]) && (FD_ISSET(socknum[cnt],&tmpfdset)))
 877             {
 878                 /*
 879                  * GET THE READY FROM THIS GUY.
 880                  * DON'T FORGET TO CLEAR HIS BIT IN THE tmpfdset
 881                  */
 882     len = NETREAD(socknum[cnt],buffer,READYSTRLEN);
 883                 if(len != READYSTRLEN)
 884                 {
 885                      abort_clients();
 886                      errexit("Error reading from client #%d\n", cnt);
 887                 }
 888                 if(memcmp(buffer, READYSTR, READYSTRLEN))
 889           {
 890                      abort_clients();
 891                      fprintf(stdout,"Received bad READY string: len %d, value %s\n",
 892             len,buffer);
 893                 }
 894                 FD_CLR(socknum[cnt],&leftfdset);
 895             }
 896         }
 897     }
 898     sleep(1);
 899     fprintf(stdout,"All READYs received\n");
 900     fflush(stdout);
 901 }
 902
 903 /*
 904   Start all the clients by sending them a GO signal
 905   totalnumclients is the total number of clients
 906   socknum is an int array with the filedescriptors for all the
 907      client connections
 908 */
 909 void SendGo( totalnumclients, socknum)
 910 int totalnumclients;
 911 int *socknum;
 912 {
 913   int cnt;
 914   fprintf(stdout,"Sending GO to all clients\n");
 915   for(cnt = 0; cnt < totalnumclients; cnt++)
 916     {
 917       if(socknum[cnt] > 0)
 918         {
 919     /*
 920      * SEND A GO
 921      */
 922     if(NETWRITE(socknum[cnt], GOSTR, GOSTRLEN) != GOSTRLEN)
 923             {
 924         abort_clients();
 925         errexit("Error sending GO to client %d: %s\n", cnt, neterrstr());
 926             }
 927         }
 928     }
 929 }
 930
 931 /*
 932   This function gathers statistics from all the clients
 933 */
 934
 935 void GetResults(fdset, page_stats, endtime, timestr, totalnumclients,
 936     statarray)
 937 fd_set *fdset;
 938 page_stats_t **page_stats;
 939 time_t *endtime;
 940 char *timestr;
 941 int totalnumclients;
 942 stats_t statarray[MAXCLIENTS];
 943 {
 944   fd_set leftfdset,tmpfdset;
 945   char *stats_as_text;
 946   char *page_stats_as_text;
 947   int returnval;
 948   int cnt,i;
 949
 950
 951   /* DOESN'T ACTUALLY PRINT UNTIL THE FIRST CLIENT REPORTS */
 952   fprintf(stdout,"Reading results ");
 953
 954   /*
 955    * COPY THE FILE DESCRIPTORS TO A TMP LIST,
 956    * ALLOCATE MEMORY FOR STATS, PAGESTATS IN TEXT FORM
 957    */
 958   leftfdset = *fdset;
 959   stats_as_text = (char *)mymalloc(SIZEOF_STATSTEXT+1);
 960   page_stats_as_text = (char *)mymalloc(SIZEOF_PAGESTATSTEXT+1);
 961
 962     /*
 963     * COPY THE FILE DESCRIPTORS TO A TMP LIST,
 964     * PLUS A LIST OF REMAINING FDs
 965     */
 966     leftfdset = *fdset;
 967     /*
 968      * LOOP UNTIL ALL CLIENTS HAVE REPORTED
 969      * AND tmpfdset IS EMPTY
 970      */
 971 #ifndef WIN32
 972     while(memcmp(&leftfdset,&zerofdset,sizeof(fd_set)))
 973     {
 974   tmpfdset = leftfdset;
 975   sleep(1);
 976   returnval = select(FD_SETSIZE,&tmpfdset,NULL,NULL,NULL);
 977   D_PRINTF( "Call to select returned %d, errno %d\n",
 978          returnval, errno );
 979         if(returnval < 0)
 980         {
 981             /*
 982              * ERROR SELECTING. ABORT ALL.
 983              */
 984     D_PRINTF( "select() error %s\n", neterrstr() );
 985             abort_clients();
 986             errexit("Error selecting from one of the clients\n");
 987         }
 988 #else
 989     /* I don't see why a select is needed at all */
 990     tmpfdset = leftfdset;
 991     {
 992 #endif /* WIN32 */
 993   for(cnt = 0; cnt < totalnumclients; cnt++)
 994   {
 995       /*
 996        * SEE WHICH SOCKETS HAVE A INPUT ON THEM PENDING AND
 997        * RECEIVE IT.
 998        */
 999
1000       /* IS THIS A VALID SOCKET? IS IT READY TO READ? */
1001       if(!BADSOCKET(socknum[cnt]) && (FD_ISSET(socknum[cnt],&tmpfdset)))
1002       {
1003     int len;
1004
1005     /*
1006      * GET THE TIMING DATA FROM THIS GUY
1007      * THEN REMOVE HIM FROM THE tmpfdset
1008      */
1009       /*
1010        * READ TIME STATS
1011        * DOES READ() RETURN THE CORRECT LENGTH?
1012        */
1013       D_PRINTF( "About to read timestats, count %d, errno %d\n",
1014       cnt, errno );
1015       len = SIZEOF_STATSTEXTBASE + number_of_pages*SIZEOF_DOUBLETEXT;
1016       returnval = recvdata(socknum[cnt], stats_as_text,
1017             len);
1018       D_PRINTF( "Read time stats %d\n", returnval );
1019       if (returnval != len) /* <= 0) */
1020         {
1021           D_PRINTF( "Error reading timing stats: %s\n",
1022           neterrstr() );
1023           fprintf(stderr, "Error reading timing stats: %s\nSocket number %d\n",
1024             neterrstr(),socknum[cnt]);
1025           abort_clients();
1026           errexit("");
1027         } /* end if */
1028
1029       /* convert text to stats */
1030       stats_as_text[returnval] = 0; /* add an end marker */
1031       statarray[cnt] = *text_to_stats(stats_as_text);
1032
1033     fputc('.', stdout); /* PROGRESS MARKER */
1034     fflush(stdout);
1035
1036     if(uil_filelist_f) /* READ PAGE STATS */
1037     {
1038       for (i = 0; i < number_of_pages; i++)
1039         {
1040           D_PRINTF( "On page_stats[%d][%d]\n", cnt, i );
1041           returnval = recvdata(socknum[cnt], page_stats_as_text,
1042           SIZEOF_PAGESTATSTEXT);
1043           D_PRINTF( "Read page stats %d\n", returnval );
1044
1045           if (returnval != SIZEOF_PAGESTATSTEXT) /* <= 0) */
1046       {
1047         D_PRINTF( "Error reading page_stats[%d][%d]: %s\n",
1048           cnt, i, neterrstr() );
1049         fprintf(stderr, "Error reading page_stats[%d][%d]: %s\n",
1050           cnt, i, neterrstr());
1051         abort_clients();
1052         errexit("");
1053       }
1054           D_PRINTF( "Page stats: read %d bytes\n",
1055         returnval );
1056
1057           page_stats_as_text[returnval] = 0;    /* add an end marker */
1058           D_PRINTF("strlen(page_stats_as_text) = %d\n",
1059           strlen(page_stats_as_text));
1060           page_stats[cnt][i] =
1061       *text_to_page_stats(page_stats_as_text);
1062
1063         } /* end for */
1064     } /* end if filelist */
1065
1066     FD_CLR(socknum[cnt],&leftfdset);
1067     NETCLOSE(socknum[cnt]);
1068     socknum[cnt] = BADSOCKET_VALUE;
1069       } /* end if socknum */
1070   } /* end for cnt */
1071     } /* end while memcmp fd */
1072
1073     /*
1074      * DONE READING RESULTS FROM CLIENTS
1075      */
1076
1077     *endtime = time(0);
1078     timestr = asctime(localtime(endtime));
1079     fprintf(stdout,"\nAll clients ended at %s\n",timestr);
1080     fflush(stdout);
1081
1082     /* FREE MEMORY ALLOCATED FOR CLIENT STATS, PAGESTATS AS TEXT */
1083     free(stats_as_text);
1084     free(page_stats_as_text);
1085
1086 }
1087
1088 /*
1089   Prints out all the results
1090 */
1091 void PrintResults( page_stats, endtime, timestr, totalnumclients, statarray,
1092       page_stats_total)
1093 page_stats_t **page_stats;
1094 time_t endtime;
1095 char *timestr;
1096 int totalnumclients;
1097 stats_t statarray[MAXCLIENTS];
1098 page_stats_t *page_stats_total;
1099 {
1100   stats_t masterstat;
1101   int cnt,i,j;
1102   double  thruput;
1103   struct timeval  dtime;
1104
1105     /*
1106      * PRINT EVERYTHING OUT
1107      */
1108     stats_init(&masterstat);
1109     for(cnt = 0; cnt < totalnumclients; cnt++)
1110     {
1111         if((statarray[cnt].rs.totalconnects > 0) && (dumpall))
1112         {
1113             fprintf(stdout,"----------------------------------\n");
1114             /* fprintf(stdout,"Test for host: %s\n",statarray[cnt].hostname); */
1115             fprintf(stdout,"Total number of pages retrieved from server: %u\n",
1116         statarray[cnt].totalpages);
1117
1118       rqstat_fprint(stdout, &(statarray[cnt].rs));
1119
1120           thruput = thruputpersec((double)(statarray[cnt].rs.totalbytes),
1121       &(statarray[cnt].rs.totalresponsetime));
1122
1123           fprintf(stdout, "Thruput average per connection: %.0f bytes/sec\n",
1124       thruput);
1125         }
1126         if(statarray[cnt].rs.totalconnects > 0)
1127         {
1128       D_PRINTF( "Summing stats for %d, with %ld total connections\n",
1129     cnt, statarray[cnt].rs.totalconnects );
1130             rqstat_sum(&masterstat.rs, &(statarray[cnt].rs));
1131         }
1132   else
1133   {
1134       masterstat.rs.totalerrs += statarray[cnt].rs.totalerrs;
1135   }
1136     }
1137
1138     for (i=0; i < totalnumclients; i++)
1139     {
1140   for (j=0; j < number_of_pages; j++)
1141   {
1142       D_PRINTF( "Summing page stats for %d, page %d, with %d connects\n",
1143         i, j, statarray[i].page_numbers[j] );
1144
1145       if (statarray[i].page_numbers[j] != 0)
1146       {
1147     rqst_stats_t *pst_rs;
1148     rqst_stats_t *ps_rs;
1149
1150     pst_rs = &(page_stats_total[j].rs);
1151     ps_rs =  &(page_stats[i][j].rs);
1152
1153     rqstat_sum(pst_rs, ps_rs);
1154
1155     page_stats_total[j].totalpages += page_stats[i][j].totalpages;
1156     masterstat.totalpages += page_stats[i][j].totalpages;
1157
1158     /* yes, this is assignment, not sum */
1159     page_stats_total[j].page_size = page_stats[i][j].page_size;
1160
1161     page_stats_total[j].page_valid = 1;
1162       }
1163   }
1164     }
1165
1166     /* print page statistics */
1167     if (verbose) {
1168   for (i = 0; i < number_of_pages; i++)
1169   {
1170       if (page_stats_total[i].page_valid == 1)
1171       {
1172     page_stats_t *pst;
1173
1174     pst = &(page_stats_total[i]);
1175
1176     printf ("===============================================================================\n");
1177     printf ("Page # %d\n\n", i);
1178     printf ("Total number of times page was hit %u\n",
1179           pst->totalpages);
1180
1181     rqstat_print(&(pst->rs));
1182
1183     printf ("Page size %u \n", pst->page_size);
1184     printf ("===============================================================================\n\n");
1185       }
1186   }
1187     }
1188
1189     fprintf(stdout,"===============================================================================\n");
1190
1191     /*
1192      * Validate run.
1193      */
1194     masterstat.total_num_of_files = statarray[0].total_num_of_files;
1195     for (i=1; i < totalnumclients; i++)
1196     {
1197         if ((statarray[i].rs.totalconnects > 0) &&
1198       (statarray[i].total_num_of_files != masterstat.total_num_of_files))
1199   {
1200       fprintf(stdout,"**********************************************************************\n");
1201       fprintf(stdout,"**** ERROR: number of files in each test configuration is not the same\n");
1202       fprintf(stdout,"**** ERROR: Check configuration file %s on each client\n", configfile);
1203       fprintf(stdout,"**********************************************************************\n");
1204       break;
1205   }
1206     }
1207
1208
1209     /*
1210      * Print summary statistics
1211      */
1212     fprintf(stdout, "WEBSTONE 2.0 results:\n");
1213
1214     fprintf(stdout, "Total number of clients: \t%d\n", totalnumclients);
1215     testtime = sumedh_end.tv_sec - sumedh_start.tv_sec;
1216     fprintf(stdout,"Test time: \t\t\t%d seconds\n", testtime);
1217
1218     fprintf(stdout, "Server connection rate: \t%3.2f connections/sec\n",
1219             (double)(masterstat.rs.totalconnects)/(testtime));
1220
1221     fprintf(stdout, "Server error rate: \t\t%4.4f err/sec\n",
1222             (double)(masterstat.rs.totalerrs)/(testtime));
1223
1224     fprintf(stdout, "Server thruput: \t\t%2.2f Mbit/sec\n",
1225             (double)(8*masterstat.rs.totalbytes)/(testtime*1024*1024));
1226
1227     fprintf(stdout, "Little's Load Factor: \t\t%3.2f \n",
1228             (double)(masterstat.rs.totalresponsetime.tv_sec)
1229             /(testtime));
1230     avgtime(&masterstat.rs.totalresponsetime,
1231           masterstat.rs.totalconnects, &dtime);
1232
1233     fprintf(stdout, "Average response time: \t\t%4.4f millisec\n",
1234   (double)1000*(dtime.tv_sec + (double)dtime.tv_usec / 1000000));
1235
1236     fprintf(stdout, "Error Level:\t\t\t%4.4f %%\n",
1237       (double)(100 * masterstat.rs.totalerrs)/(masterstat.rs.totalconnects));
1238
1239     /* so much for the key metrics */
1240
1241     thruput = 8 * thruputpersec((double)(masterstat.rs.totalbytes),
1242       &(masterstat.rs.totalresponsetime));
1243
1244     fprintf(stdout, "Average client thruput: \t%4.4f Mbit/sec\n",
1245       thruput/(1024*1024));
1246
1247     fprintf(stdout,"Sum of client response times:\t%u.%u sec\n",
1248       masterstat.rs.totalresponsetime.tv_sec,
1249       masterstat.rs.totalresponsetime.tv_usec);
1250
1251     fprintf(stdout,"Total number of pages read:\t%u\n\n",
1252         masterstat.totalpages);
1253
1254     /* Remaining stats are the same as usual */
1255
1256     rqstat_fprint(stdout, &(masterstat.rs));
1257     fflush(stdout);
1258
1259 }
1260
1261 #ifdef WIN32
1262 /* close socket library */
1263 void sock_cleanup(void) {
1264
1265     WSACleanup();
1266 }
1267 #endif /* WIN32 */
1268
1269 void
1270 main(const int argc, char *argv[])
1271 {
1272
1273     int   sync_sock;
1274     int   i;
1275     int   j;
1276     char  buffer[NCCARGS];
1277     char  commandline[NCCARGS];
1278     char  *timestr;
1279     time_t  starttime;
1280     time_t  endtime;
1281     fd_set  fdset;
1282     /* make the big arrays static to avoid stack overflow */
1283     static char   clienthostname[MAXCLIENTS][MAXHOSTNAMELEN];
1284     static stats_t  statarray[MAXCLIENTS];
1285     page_stats_t **page_stats;
1286     page_stats_t *page_stats_total;
1287     struct sockaddr_in  serveraddr;
1288
1289
1290 #ifdef WIN32
1291     WSADATA WSAData;
1292     COORD dwSize;
1293
1294     if ((WSAStartup(MAKEWORD(1,1), &WSAData)) != 0) {
1295   errexit("Error in WSAStartup()\n");
1296     }
1297     atexit(sock_cleanup);
1298
1299     /* increase size of output window */
1300     dwSize.X = 80;
1301     dwSize.Y = 500;
1302     SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), dwSize);
1303 #endif /* WIN32 */
1304
1305
1306     /* Initalization of variables. */
1307     debugfile = stdout;
1308     memset(buffer, 0, NCCARGS);
1309     memset(webserver, 0, MAXHOSTNAMELEN);
1310     memset(configfile, 0, MAXPATHLEN);
1311     FD_ZERO(&zerofdset);
1312     FD_ZERO(&fdset);
1313
1314     for(i = 0; i < MAXCLIENTS; i++)
1315     {
1316         socknum[i] = BADSOCKET_VALUE;
1317         statarray[i].rs.totalconnects = 0;
1318     }
1319
1320     signal(SIGINT, sig_int);
1321
1322     ParseCmdLine( argc, argv);
1323
1324     sync_sock = SetupSyncSocket( &serveraddr );
1325
1326     MakeCmdLine( commandline);
1327
1328     totalnumclients = RexecClients( commandline, clienthostname, &serveraddr);
1329
1330     /* Initalization of variables. */
1331     page_stats =
1332       (page_stats_t **)
1333       mymalloc(totalnumclients*sizeof(page_stats_t *));
1334     for (i=0; i < totalnumclients; i++)
1335       {
1336   page_stats[i] = (page_stats_t *)
1337     mymalloc(number_of_pages*sizeof(page_stats_t));
1338       }
1339     page_stats_total =
1340       (page_stats_t *)mymalloc(number_of_pages*sizeof(page_stats_t));
1341
1342     for (i=0; i < totalnumclients; i++) {
1343         stats_init(&(statarray[i]));
1344     }
1345     for (i=0; i < totalnumclients; i++) {
1346         for (j=0; j < number_of_pages; j++) {
1347             page_stats_init(&(page_stats[i][j]));
1348   }
1349     }
1350     for (i=0; i < number_of_pages; i++) {
1351         page_stats_init(&(page_stats_total[i]));
1352     }
1353
1354     for(i = 0; i < totalnumclients; i++)
1355     {
1356         socknum[i] = BADSOCKET_VALUE;
1357         statarray[i].rs.totalconnects = 0;
1358     }
1359
1360     GetReady( &fdset, totalnumclients, sync_sock );
1361     NETCLOSE(sync_sock);
1362
1363     /*
1364      * START ALL OF THE CLIENTS BY SENDING THEM A GO SIGNAL.
1365      */
1366
1367
1368     gettimeofday (&sumedh_start, 0);
1369     SendGo( totalnumclients, socknum);
1370
1371     /*
1372      * WAIT FOR ALL OF THE CLIENTS TO COMPLETE.  WE SHOULD GET A REPLY
1373      * FOR EACH SOCKET WE HAVE OPEN.  THE REPLY WILL BE THE TIMING
1374      * INFORMATION WE USE.
1375      */
1376
1377     starttime = time(0);
1378     timestr = asctime(localtime(&starttime));
1379     fprintf(stdout,"All clients started at %s\n",timestr);
1380     fprintf(stdout,"Waiting for clients completion\n");
1381     fflush(stdout);
1382
1383     /* IF THIS IS A TIMED TEST, WE MIGHT AS WELL SNOOZE */
1384     if (testtime) {
1385       sleep(testtime * 60);
1386     }
1387
1388     GetResults( &fdset, page_stats, &endtime, timestr, totalnumclients,
1389          statarray);
1390
1391     gettimeofday (&sumedh_end, 0);
1392     PrintResults( page_stats, endtime, timestr, totalnumclients, statarray,
1393      page_stats_total);
1394
1395     /* free memory */
1396     for (i = 0; i < totalnumclients; i++)
1397       {
1398   free(page_stats[i]);
1399       }
1400     free(page_stats);
1401     free(page_stats_total);
1402
1403     exit(0);
1404 }
1405
1406 /* Added by Rajesh Shah 5/18/96 */
1407 void
1408 HostEntCpy(struct hostent *dest, struct hostent *src)
1409 {
1410
1411   dest->h_name = (char *)malloc(strlen(src->h_name)+1);
1412   strcpy(dest->h_name, src->h_name);
1413   printf("WebMaster name = %s\n", dest->h_name);
1414   dest->h_aliases = src->h_aliases;
1415   dest->h_addrtype = src->h_addrtype;
1416   dest->h_length = src->h_length;
1417   dest->h_addr_list = src->h_addr_list;
1418 }