#ifdef lint
#define WANT_UNIX
#define DIRTY
#define WANT_INTERVALS
#endif /* lint */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef WIN32
#error Unix Domain Sockets are not available under Windows
#endif

#ifdef WANT_UNIX
char	nettest_unix_id[]="\
@(#)nettest_unix.c (c) Copyright 1994-2012 Hewlett-Packard Co. Version 2.6.0";

/****************************************************************/
/*								*/
/*	nettest_bsd.c						*/
/*								*/
/*      the BSD sockets parsing routine...                      */
/*                                                              */
/*      scan_unix_args()                                        */
/*                                                              */
/*	the actual test routines...				*/
/*								*/
/*	send_stream_stream()  perform a stream stream test	*/
/*	recv_stream_stream()					*/
/*	send_stream_rr()      perform a stream request/response	*/
/*	recv_stream_rr()					*/
/*	send_dg_stream()      perform a dg stream test	        */
/*	recv_dg_stream()					*/
/*	send_dg_rr()	      perform a dg request/response	*/
/*	recv_dg_rr()						*/
/*	loc_cpu_rate()	      determine the local cpu maxrate   */
/*	rem_cpu_rate()	      find the remote cpu maxrate	*/
/*								*/
/****************************************************************/

 /* at some point, I might want to go-in and see if I really need all
    these includes, but for the moment, we'll let them all just sit
    there. raj 8/94 */
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/socket.h>
#include <errno.h>
#include <signal.h>
#include <sys/un.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>

#ifdef NOSTDLIBH
#include <malloc.h>
#else /* NOSTDLIBH */
#include <stdlib.h>
#endif /* NOSTDLIBH */

#include <sys/stat.h>


#include "netlib.h"
#include "netsh.h"
#include "nettest_unix.h"



/* these variables are specific to the UNIX sockets tests. declare
    them static to make them global only to this file. */

#define UNIX_PRFX "netperf."
#define UNIX_LENGTH_MAX 0xFFFF - 28

static char
  path_prefix[32];

static int
  rss_size,		/* remote socket send buffer size */
  rsr_size,		/* remote socket recv buffer size	*/
  lss_size_req,		/* requested local socket send buffer size */
  lsr_size_req,		/* requested local socket recv buffer size */
  lss_size,		/* local  socket send buffer size 	*/
  lsr_size,		/* local  socket recv buffer size 	*/
  req_size = 1,		/* request size                   	*/
  rsp_size = 1,		/* response size			*/
  send_size,		/* how big are individual sends		*/
  recv_size;		/* how big are individual receives	*/

 /* different options for the sockets				*/


char unix_usage[] = "\n\
Usage: netperf [global options] -- [test options] \n\
\n\
STREAM/DG UNIX Sockets Test Options:\n\
    -h                Display this text\n\
    -m bytes          Set the send size (STREAM_STREAM, DG_STREAM)\n\
    -M bytes          Set the recv size (STREAM_STREAM, DG_STREAM)\n\
    -p dir            Set the directory where pipes are created\n\
    -r req,res        Set request,response size (STREAM_RR, DG_RR)\n\
    -s send[,recv]    Set local socket send/recv buffer sizes\n\
    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
\n\
For those options taking two parms, at least one must be specified;\n\
specifying one value without a comma will set both parms to that\n\
value, specifying a value with a leading comma will set just the second\n\
parm, a value with a trailing comma will set just the first. To set\n\
each parm to unique values, specify both and separate them with a\n\
comma.\n";

/* this routing initializes all the test specific variables */

static void
init_test_vars()
{
  rss_size  = 0;
  rsr_size  = 0;
  lss_size_req = -1;
  lsr_size_req = -1;
  lss_size  = 0;
  lsr_size  = 0;
  req_size  = 1;
  rsp_size  = 1;
  send_size = 0;
  recv_size = 0;

  strcpy(path_prefix,"/tmp");

}

/* This routine will create a data (listen) socket with the apropriate
   options set and return it to the caller. this replaces all the
   duplicate code in each of the test routines and should help make
   things a little easier to understand. since this routine can be
   called by either the netperf or netserver programs, all output
   should be directed towards "where." family is generally AF_UNIX,
   and type will be either SOCK_STREAM or SOCK_DGRAM */
SOCKET
create_unix_socket(int family, int type)
{

  SOCKET temp_socket;

  /*set up the data socket                        */
  temp_socket = socket(family,
		       type,
		       0);

  if (temp_socket == INVALID_SOCKET){
    fprintf(where,
	    "netperf: create_unix_socket: socket: %d\n",
	    errno);
    fflush(where);
    exit(1);
  }

  if (debug) {
    fprintf(where,"create_unix_socket: socket %d obtained...\n",temp_socket);
    fflush(where);
  }

  /* Modify the local socket size. The reason we alter the send buffer
     size here rather than when the connection is made is to take care
     of decreases in buffer size. Decreasing the window size after
     connection establishment is a STREAM no-no. Also, by setting the
     buffer (window) size before the connection is established, we can
     control the STREAM MSS (segment size). The MSS is never more that
     1/2 the minimum receive buffer size at each half of the
     connection.  This is why we are altering the receive buffer size
     on the sending size of a unidirectional transfer. If the user has
     not requested that the socket buffers be altered, we will try to
     find-out what their values are. If we cannot touch the socket
     buffer in any way, we will set the values to -1 to indicate
     that.  */

  set_sock_buffer(temp_socket, SEND_BUFFER, lss_size_req, &lss_size);
  set_sock_buffer(temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size);

  return(temp_socket);

}


/* This routine implements the STREAM unidirectional data transfer
   test (a.k.a. stream) for the sockets interface. It receives its
   parameters via global variables from the shell and writes its
   output to the standard output. */


void
send_stream_stream(char remote_host[])
{

  char *tput_title = "\
Recv   Send    Send                          \n\
Socket Socket  Message  Elapsed              \n\
Size   Size    Size     Time     Throughput  \n\
bytes  bytes   bytes    secs.    %s/sec  \n\n";

  char *tput_fmt_0 =
    "%7.2f\n";

  char *tput_fmt_1 =
    "%5d  %5d  %6d    %-6.2f   %7.2f   \n";

  char *cpu_title = "\
Recv   Send    Send                          Utilization    Service Demand\n\
Socket Socket  Message  Elapsed              Send   Recv    Send    Recv\n\
Size   Size    Size     Time     Throughput  local  remote  local   remote\n\
bytes  bytes   bytes    secs.    %-8.8s/s  %%      %%       us/KB   us/KB\n\n";

  char *cpu_fmt_0 =
    "%6.3f\n";

  char *cpu_fmt_1 =
    "%5d  %5d  %6d    %-6.2f     %7.2f   %-6.2f %-6.2f  %-6.3f  %-6.3f\n";

  char *ksink_fmt = "\n\
Alignment      Offset         %-8.8s %-8.8s    Sends   %-8.8s Recvs\n\
Local  Remote  Local  Remote  Xfered   Per                 Per\n\
Send   Recv    Send   Recv             Send (avg)          Recv (avg)\n\
%5d   %5d  %5d   %5d %6.4g  %6.2f     %6d %6.2f   %6d\n";


  float			elapsed_time;

#ifdef WANT_INTERVALS
  int interval_count;
#endif

  /* what we want is to have a buffer space that is at least one
     send-size greater than our send window. this will insure that we
     are never trying to re-use a buffer that may still be in the
     hands of the transport. This buffer will be malloc'd after we
     have found the size of the local senc socket buffer. We will want
     to deal with alignment and offset concerns as well. */

#ifdef DIRTY
  int	*message_int_ptr;
#endif
#include <sys/stat.h>

  struct ring_elt *send_ring;

  int	len = 0;
  int	nummessages;
  SOCKET send_socket;
  int	bytes_remaining;
  /* with links like fddi, one can send > 32 bits worth of bytes
     during a test... ;-) */
  double	bytes_sent;

#ifdef DIRTY
  int	i;
#endif /* DIRTY */

  float	local_cpu_utilization;
  float	local_service_demand;
  float	remote_cpu_utilization;
  float	remote_service_demand;
  double	thruput;

  struct	sockaddr_un	server;

  struct	stream_stream_request_struct	*stream_stream_request;
  struct	stream_stream_response_struct	*stream_stream_response;
  struct	stream_stream_results_struct	*stream_stream_result;

  stream_stream_request  =
    (struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
  stream_stream_response =
    (struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
  stream_stream_result   =
    (struct stream_stream_results_struct *)netperf_response.content.test_specific_data;

  /* since we are now disconnected from the code that established the
     control socket, and since we want to be able to use different
     protocols and such, we are passed the name of the remote host and
     must turn that into the test specific addressing information. */

  bzero((char *)&server,
	sizeof(server));
  server.sun_family = AF_UNIX;


  if ( print_headers ) {
    fprintf(where,"STREAM STREAM TEST\n");
    if (local_cpu_usage || remote_cpu_usage)
      fprintf(where,cpu_title,format_units());
    else
      fprintf(where,tput_title,format_units());
  }

  /* initialize a few counters */

  nummessages	=	0;
  bytes_sent	=	0.0;
  times_up 	= 	0;

  /*set up the data socket                        */
  send_socket = create_unix_socket(AF_UNIX,
				   SOCK_STREAM);

  if (send_socket == INVALID_SOCKET){
    perror("netperf: send_stream_stream: stream stream data socket");
    exit(1);
  }

  if (debug) {
    fprintf(where,"send_stream_stream: send_socket obtained...\n");
  }

  /* at this point, we have either retrieved the socket buffer sizes,
     or have tried to set them, so now, we may want to set the send
     size based on that (because the user either did not use a -m
     option, or used one with an argument of 0). If the socket buffer
     size is not available, we will set the send size to 4KB - no
     particular reason, just arbitrary... */
  if (send_size == 0) {
    if (lss_size > 0) {
      send_size = lss_size;
    }
    else {
      send_size = 4096;
    }
  }

  /* set-up the data buffer ring with the requested alignment and
     offset.  note also that we have allocated a quantity of memory
     that is at least one send-size greater than our socket buffer
     size. We want to be sure that there are at least two buffers
     allocated - this can be a bit of a problem when the send_size is
     bigger than the socket size, so we must check... the user may
     have wanted to explicitly set the "width" of our send buffers, we
     should respect that wish... */
  if (send_width == 0) {
    send_width = (lss_size/send_size) + 1;
    if (send_width == 1) send_width++;
  }

  send_ring = allocate_buffer_ring(send_width,
				   send_size,
				   local_send_align,
				   local_send_offset);

  /* If the user has requested cpu utilization measurements, we must
     calibrate the cpu(s). We will perform this task within the tests
     themselves. If the user has specified the cpu rate, then
     calibrate_local_cpu will return rather quickly as it will have
     nothing to do. If local_cpu_rate is zero, then we will go through
     all the "normal" calibration stuff and return the rate back.*/

  if (local_cpu_usage) {
    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
  }

  /* Tell the remote end to do a listen. The server alters the socket
     paramters on the other side at this point, hence the reason for
     all the values being passed in the setup message. If the user did
     not specify any of the parameters, they will be passed as 0,
     which will indicate to the remote that no changes beyond the
     system's default should be used. Alignment is the exception, it
     will default to 1, which will be no alignment alterations. */

  netperf_request.content.request_type	=	DO_STREAM_STREAM;
  stream_stream_request->send_buf_size	=	rss_size;
  stream_stream_request->recv_buf_size	=	rsr_size;
  stream_stream_request->receive_size	=	recv_size;
  stream_stream_request->recv_alignment	=	remote_recv_align;
  stream_stream_request->recv_offset	=	remote_recv_offset;
  stream_stream_request->measure_cpu	=	remote_cpu_usage;
  stream_stream_request->cpu_rate	=	remote_cpu_rate;
  if (test_time) {
    stream_stream_request->test_length	=	test_time;
  }
  else {
    stream_stream_request->test_length	=	test_bytes;
  }
#ifdef DIRTY
  stream_stream_request->dirty_count    =       rem_dirty_count;
  stream_stream_request->clean_count    =       rem_clean_count;
#endif /* DIRTY */


  if (debug > 1) {
    fprintf(where,
	    "netperf: send_stream_stream: requesting STREAM stream test\n");
  }

  send_request();

  /* The response from the remote will contain all of the relevant
     socket parameters for this test type. We will put them back into
     the variables here so they can be displayed if desired.  The
     remote will have calibrated CPU if necessary, and will have done
     all the needed set-up we will have calibrated the cpu locally
     before sending the request, and will grab the counter value right
     after the connect returns. The remote will grab the counter right
     after the accept call. This saves the hassle of extra messages
     being sent for the STREAM tests.  */

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rsr_size	        =	stream_stream_response->recv_buf_size;
    rss_size	        =	stream_stream_response->send_buf_size;
    remote_cpu_usage    =	stream_stream_response->measure_cpu;
    remote_cpu_rate     = 	stream_stream_response->cpu_rate;
    strcpy(server.sun_path,stream_stream_response->unix_path);
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: send_stream_stream: remote error");
    exit(1);
  }

  /*Connect up to the remote port on the data socket  */
  if (connect(send_socket,
	      (struct sockaddr *)&server,
	      sizeof(server)) == INVALID_SOCKET){
    perror("netperf: send_stream_stream: data socket connect failed");
    printf(" path: %s\n",server.sun_path);
    exit(1);
  }

  /* Data Socket set-up is finished. If there were problems, either
     the connect would have failed, or the previous response would
     have indicated a problem. I failed to see the value of the extra
     message after the accept on the remote. If it failed, we'll see
     it here. If it didn't, we might as well start pumping data. */

  /* Set-up the test end conditions. For a stream test, they can be
     either time or byte-count based. */

  if (test_time) {
    /* The user wanted to end the test after a period of time. */
    times_up = 0;
    bytes_remaining = 0;
    start_timer(test_time);
  }
  else {
    /* The tester wanted to send a number of bytes. */
    bytes_remaining = test_bytes;
    times_up = 1;
  }

  /* The cpu_start routine will grab the current time and possibly
     value of the idle counter for later use in measuring cpu
     utilization and/or service demand and thruput. */

  cpu_start(local_cpu_usage);

  /* We use an "OR" to control test execution. When the test is
     controlled by time, the byte count check will always return
     false.  When the test is controlled by byte count, the time test
     will always return false. When the test is finished, the whole
     expression will go false and we will stop sending data. */

#ifdef DIRTY
  /* initialize the random number generator for putting dirty stuff
     into the send buffer. raj */
  srand((int) getpid());
#endif

  while ((!times_up) || (bytes_remaining > 0)) {

#ifdef DIRTY
    /* we want to dirty some number of consecutive integers in the
       buffer we are about to send. we may also want to bring some
       number of them cleanly into the cache. The clean ones will
       follow any dirty ones into the cache. at some point, we might
       want to replace the rand() call with something from a table to
       reduce our call overhead during the test, but it is not a high
       priority item. */
    message_int_ptr = (int *)(send_ring->buffer_ptr);
    for (i = 0; i < loc_dirty_count; i++) {
      *message_int_ptr = rand();
      message_int_ptr++;
    }
    for (i = 0; i < loc_clean_count; i++) {
      loc_dirty_count = *message_int_ptr;
      message_int_ptr++;
    }
#endif /* DIRTY */

    if((len=send(send_socket,
		 send_ring->buffer_ptr,
		 send_size,
		 0)) != send_size) {
      if ((len >=0) || (errno == EINTR)) {
	/* the test was interrupted, must be the end of test */
	break;
      }
      perror("netperf: data send error");
      printf("len was %d\n",len);
      exit(1);
    }
#ifdef WANT_INTERVALS
    for (interval_count = 0;
	 interval_count < interval_wate;
	 interval_count++);
#endif

    /* now we want to move our pointer to the next position in the
       data buffer...we may also want to wrap back to the "beginning"
       of the bufferspace, so we will mod the number of messages sent
       by the send width, and use that to calculate the offset to add
       to the base pointer. */
    nummessages++;
    send_ring = send_ring->next;
    if (bytes_remaining) {
      bytes_remaining -= send_size;
    }
  }

  /* The test is over. Flush the buffers to the remote end. We do a
     graceful release to insure that all data has been taken by the
     remote. */

  if (close(send_socket) == -1) {
    perror("netperf: send_stream_stream: cannot close socket");
    exit(1);
  }

  /* this call will always give us the elapsed time for the test, and
     will also store-away the necessaries for cpu utilization */

  cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being measured
					      and how long did we
					      really run? */

  /* Get the statistics from the remote end. The remote will have
     calculated service demand and all those interesting things. If it
     wasn't supposed to care, it will return obvious values. */

  recv_response();
  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote results obtained\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /* We now calculate what our thruput was for the test. In the
     future, we may want to include a calculation of the thruput
     measured by the remote, but it should be the case that for a
     STREAM stream test, that the two numbers should be *very*
     close... We calculate bytes_sent regardless of the way the test
     length was controlled.  If it was time, we needed to, and if it
     was by bytes, the user may have specified a number of bytes that
     wasn't a multiple of the send_size, so we really didn't send what
     he asked for ;-) */

  bytes_sent	= ((double) send_size * (double) nummessages) + len;
  thruput	= calc_thruput(bytes_sent);

  if (local_cpu_usage || remote_cpu_usage) {
    /* We must now do a little math for service demand and cpu
       utilization for the system(s) Of course, some of the
       information might be bogus because there was no idle counter in
       the kernel(s). We need to make a note of this for the user's
       benefit...*/
    if (local_cpu_usage) {
      if (local_cpu_rate == 0.0) {
	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
	fprintf(where,"Local CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      local_cpu_utilization	= calc_cpu_util(0.0);
      local_service_demand	= calc_service_demand(bytes_sent,
						      0.0,
						      0.0,
						      0);
    }
    else {
      local_cpu_utilization	= -1.0;
      local_service_demand	= -1.0;
    }

    if (remote_cpu_usage) {
      if (remote_cpu_rate == 0.0) {
	fprintf(where,"DANGER   DANGER  DANGER   DANGER   DANGER  DANGER   DANGER!\n");
	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      remote_cpu_utilization	= stream_stream_result->cpu_util;
      remote_service_demand	= calc_service_demand(bytes_sent,
						      0.0,
						      remote_cpu_utilization,
						      stream_stream_result->num_cpus);
    }
    else {
      remote_cpu_utilization = -1.0;
      remote_service_demand  = -1.0;
    }

    /* We are now ready to print all the information. If the user has
       specified zero-level verbosity, we will just print the local
       service demand, or the remote service demand. If the user has
       requested verbosity level 1, he will get the basic "streamperf"
       numbers. If the user has specified a verbosity of greater than
       1, we will display a veritable plethora of background
       information from outside of this block as it it not
       cpu_measurement specific...  */

    switch (verbosity) {
    case 0:
      if (local_cpu_usage) {
	fprintf(where,
		cpu_fmt_0,
		local_service_demand);
      }
      else {
	fprintf(where,
		cpu_fmt_0,
		remote_service_demand);
      }
      break;
    case 1:
    case 2:
      fprintf(where,
	      cpu_fmt_1,		/* the format string */
	      rsr_size,		        /* remote recvbuf size */
	      lss_size,		        /* local sendbuf size */
	      send_size,		/* how large were the sends */
	      elapsed_time,		/* how long was the test */
	      thruput, 		        /* what was the xfer rate */
	      local_cpu_utilization,	/* local cpu */
	      remote_cpu_utilization,	/* remote cpu */
	      local_service_demand,	/* local service demand */
	      remote_service_demand);	/* remote service demand */
      break;
    }
  }
  else {
    /* The tester did not wish to measure service demand. */
    switch (verbosity) {
    case 0:
      fprintf(where,
	      tput_fmt_0,
	      thruput);
      break;
    case 1:
    case 2:
      fprintf(where,
	      tput_fmt_1,    /* the format string */
	      rsr_size,      /* remote recvbuf size */
	      lss_size,      /* local sendbuf size */
	      send_size,     /* how large were the sends */
	      elapsed_time,  /* how long did it take */
	      thruput);      /* how fast did it go */
      break;
    }
  }

  /* it would be a good thing to include information about some of the
     other parameters that may have been set for this test, but at the
     moment, I do not wish to figure-out all the formatting, so I will
     just put this comment here to help remind me that it is something
     that should be done at a later time. */

  if (verbosity > 1) {
    /* The user wanted to know it all, so we will give it to him.
       This information will include as much as we can find about
       STREAM statistics, the alignments of the sends and receives and
       all that sort of rot... */

    fprintf(where,
	    ksink_fmt,
	    "Bytes",
	    "Bytes",
	    "Bytes",
	    local_send_align,
	    remote_recv_align,
	    local_send_offset,
	    remote_recv_offset,
	    bytes_sent,
	    bytes_sent / (double)nummessages,
	    nummessages,
	    bytes_sent / (double)stream_stream_result->recv_calls,
	    stream_stream_result->recv_calls);
  }

}


/* This is the server-side routine for the stream stream test. It is
   implemented as one routine. I could break things-out somewhat, but
   didn't feel it was necessary. */

void
recv_stream_stream()
{

  struct sockaddr_un myaddr_un, peeraddr_un;
  SOCKET s_listen,s_data;
  netperf_socklen_t addrlen;
  int	len;
  int	receive_calls = 0;
  float	elapsed_time;
  int   bytes_received;

  struct ring_elt *recv_ring;

#ifdef DIRTY
  char	*message_ptr;
  int   *message_int_ptr;
  int   dirty_count;
  int   clean_count;
  int   i;
#endif

  struct	stream_stream_request_struct	*stream_stream_request;
  struct	stream_stream_response_struct	*stream_stream_response;
  struct	stream_stream_results_struct	*stream_stream_results;

  stream_stream_request	=
    (struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
  stream_stream_response	=
    (struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
  stream_stream_results	=
    (struct stream_stream_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_stream_stream: entered...\n");
    fflush(where);
  }

  /* We want to set-up the listen socket with all the desired
     parameters and then let the initiator know that all is ready. If
     socket size defaults are to be used, then the initiator will have
     sent us 0's. If the socket sizes cannot be changed, then we will
     send-back what they are. If that information cannot be
     determined, then we send-back -1's for the sizes. If things go
     wrong for any reason, we will drop back ten yards and punt. */

  /* If anything goes wrong, we want the remote to know about it. It
     would be best if the error that the remote reports to the user is
     the actual error we encountered, rather than some bogus
     unexpected response type message. */

  if (debug) {
    fprintf(where,"recv_stream_stream: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = STREAM_STREAM_RESPONSE;

  if (debug) {
    fprintf(where,"recv_stream_stream: the response type is set...\n");
    fflush(where);
  }

  /* We now alter the message_ptr variable to be at the desired
     alignment with the desired offset. */

  if (debug) {
    fprintf(where,"recv_stream_stream: requested alignment of %d\n",
	    stream_stream_request->recv_alignment);
    fflush(where);
  }

  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
     can put in OUR values !-) At some point, we may want to nail this
     socket to a particular network-level address, but for now,
     INADDR_ANY should be just fine. */

  bzero((char *)&myaddr_un,
	sizeof(myaddr_un));
  myaddr_un.sun_family      = AF_UNIX;

  /* Grab a socket to listen on, and then listen on it. */

  if (debug) {
    fprintf(where,"recv_stream_stream: grabbing a socket...\n");
    fflush(where);
  }

  /* create_unix_socket expects to find some things in the global
     variables, so set the globals based on the values in the request.
     once the socket has been created, we will set the response values
     based on the updated value of those globals. raj 7/94 */
  lss_size_req = stream_stream_request->send_buf_size;
  lsr_size_req = stream_stream_request->recv_buf_size;

  s_listen = create_unix_socket(AF_UNIX,
				SOCK_STREAM);

  if (s_listen == INVALID_SOCKET) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  /* Let's get an address assigned to this socket so we can tell the
     initiator how to reach the data socket. There may be a desire to
     nail this socket to a specific IP address in a multi-homed,
     multi-connection situation, but for now, we'll ignore the issue
     and concentrate on single connection testing. */

  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
  if (debug) {
    fprintf(where,"selected a path of %s\n",myaddr_un.sun_path);
    fflush(where);
  }
  if (bind(s_listen,
	   (struct sockaddr *)&myaddr_un,
	   sizeof(myaddr_un)) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    fprintf(where,"could not bind to path\n");
    close(s_listen);
    send_response();

    exit(1);
  }

  chmod(myaddr_un.sun_path, 0666);

  /* what sort of sizes did we end-up with? */
  if (stream_stream_request->receive_size == 0) {
    if (lsr_size > 0) {
      recv_size = lsr_size;
    }
    else {
      recv_size = 4096;
    }
  }
  else {
    recv_size = stream_stream_request->receive_size;
  }

  /* we want to set-up our recv_ring in a manner analagous to what we
     do on the sending side. this is more for the sake of symmetry
     than for the needs of say copy avoidance, but it might also be
     more realistic - this way one could conceivably go with a
     double-buffering scheme when taking the data an putting it into
     the filesystem or something like that. raj 7/94 */

  if (recv_width == 0) {
    recv_width = (lsr_size/recv_size) + 1;
    if (recv_width == 1) recv_width++;
  }

  recv_ring = allocate_buffer_ring(recv_width,
				   recv_size,
				   stream_stream_request->recv_alignment,
				   stream_stream_request->recv_offset);

  if (debug) {
    fprintf(where,"recv_stream_stream: receive alignment and offset set...\n");
    fflush(where);
  }

  /* Now, let's set-up the socket to listen for connections */
  if (listen(s_listen, 5) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    close(s_listen);
    send_response();

    exit(1);
  }

  /* now get the port number assigned by the system  */
  addrlen = sizeof(myaddr_un);
  if (getsockname(s_listen,
		  (struct sockaddr *)&myaddr_un,
		  &addrlen) == SOCKET_ERROR){
    netperf_response.content.serv_errno = errno;
    close(s_listen);
    send_response();

    exit(1);
  }

  /* Now myaddr_un contains the path returned to the sender also
     implicitly telling the sender that the socket buffer sizing has
     been done. */
  strcpy(stream_stream_response->unix_path,myaddr_un.sun_path);
  netperf_response.content.serv_errno   = 0;

  /* But wait, there's more. If the initiator wanted cpu measurements,
     then we must call the calibrate routine, which will return the
     max rate back to the initiator. If the CPU was not to be
     measured, or something went wrong with the calibration, we will
     return a -1 to the initiator. */

  stream_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
  if (stream_stream_request->measure_cpu) {
    stream_stream_response->measure_cpu = 1;
    stream_stream_response->cpu_rate =
      calibrate_local_cpu(stream_stream_request->cpu_rate);
  }

  /* before we send the response back to the initiator, pull some of
     the socket parms from the globals */
  stream_stream_response->send_buf_size = lss_size;
  stream_stream_response->recv_buf_size = lsr_size;
  stream_stream_response->receive_size = recv_size;

  send_response();

  addrlen = sizeof(peeraddr_un);

  if ((s_data=accept(s_listen,
		     (struct sockaddr *)&peeraddr_un,
		     &addrlen)) == INVALID_SOCKET) {
    /* Let's just punt. The remote will be given some information */
    close(s_listen);
    exit(1);
  }

  /* Now it's time to start receiving data on the connection. We will
     first grab the apropriate counters and then start grabbing. */

  cpu_start(stream_stream_request->measure_cpu);

  /* The loop will exit when the sender does a shutdown, which will
     return a length of zero  */

#ifdef DIRTY
  /* we want to dirty some number of consecutive integers in the
     buffer we are about to recv. we may also want to bring some
     number of them cleanly into the cache. The clean ones will follow
     any dirty ones into the cache. */

  dirty_count = stream_stream_request->dirty_count;
  clean_count = stream_stream_request->clean_count;
  message_int_ptr = (int *)recv_ring->buffer_ptr;
  for (i = 0; i < dirty_count; i++) {
    *message_int_ptr = rand();
    message_int_ptr++;
  }
  for (i = 0; i < clean_count; i++) {
    dirty_count = *message_int_ptr;
    message_int_ptr++;
  }
#endif /* DIRTY */
  bytes_received = 0;

  while ((len = recv(s_data, recv_ring->buffer_ptr, recv_size, 0)) != 0) {
    if (len == SOCKET_ERROR) {
      netperf_response.content.serv_errno = errno;
      send_response();
      exit(1);
    }
    bytes_received += len;
    receive_calls++;

    /* more to the next buffer in the recv_ring */
    recv_ring = recv_ring->next;

#ifdef DIRTY
    message_int_ptr = (int *)(recv_ring->buffer_ptr);
    for (i = 0; i < dirty_count; i++) {
      *message_int_ptr = rand();
      message_int_ptr++;
    }
    for (i = 0; i < clean_count; i++) {
      dirty_count = *message_int_ptr;
      message_int_ptr++;
    }
#endif /* DIRTY */
  }

  /* The loop now exits due to zero bytes received. we will have
     counted one too many messages received, so decrement the
     receive_calls counter by one. raj 7/94 */
  receive_calls--;

  /* perform a shutdown to signal the sender that we have received all
     the data sent. raj 4/93 */

  if (shutdown(s_data,1) == SOCKET_ERROR) {
      netperf_response.content.serv_errno = errno;
      send_response();
      exit(1);
    }

  cpu_stop(stream_stream_request->measure_cpu,&elapsed_time);

  /* send the results to the sender			*/

  if (debug) {
    fprintf(where,
	    "recv_stream_stream: got %d bytes\n",
	    bytes_received);
    fprintf(where,
	    "recv_stream_stream: got %d recvs\n",
	    receive_calls);
    fflush(where);
  }

  stream_stream_results->bytes_received	= bytes_received;
  stream_stream_results->elapsed_time	= elapsed_time;
  stream_stream_results->recv_calls	= receive_calls;

  if (stream_stream_request->measure_cpu) {
    stream_stream_results->cpu_util	= calc_cpu_util(0.0);
  };

  if (debug > 1) {
    fprintf(where,
	    "recv_stream_stream: test complete, sending results.\n");
    fflush(where);
  }

  send_response();
  unlink(myaddr_un.sun_path);
}


/* this routine implements the sending (netperf) side of the STREAM_RR
   test. */

void
send_stream_rr(char remote_host[])
{

  char *tput_title = "\
Local /Remote\n\
Socket Size   Request  Resp.   Elapsed  Trans.\n\
Send   Recv   Size     Size    Time     Rate         \n\
bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";

  char *tput_fmt_0 =
    "%7.2f\n";

  char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
  char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";

  char *cpu_title = "\
Local /Remote\n\
Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";

  char *cpu_fmt_0 =
    "%6.3f\n";

  char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";

  char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";

  char *ksink_fmt = "\
Alignment      Offset\n\
Local  Remote  Local  Remote\n\
Send   Recv    Send   Recv\n\
%5d  %5d   %5d  %5d\n";


  int			timed_out = 0;
  float			elapsed_time;

  int	len;
  char	*temp_message_ptr;
  int	nummessages;
  SOCKET send_socket;
  int	trans_remaining;
  double	bytes_xferd;

  struct ring_elt *send_ring;
  struct ring_elt *recv_ring;

  int	rsp_bytes_left;
  int	rsp_bytes_recvd;

  float	local_cpu_utilization;
  float	local_service_demand;
  float	remote_cpu_utilization;
  float	remote_service_demand;
  double	thruput;

  struct	sockaddr_un	server;

  struct	stream_rr_request_struct	*stream_rr_request;
  struct	stream_rr_response_struct	*stream_rr_response;
  struct	stream_rr_results_struct	*stream_rr_result;

  stream_rr_request =
    (struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
  stream_rr_response=
    (struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
  stream_rr_result	=
    (struct stream_rr_results_struct *)netperf_response.content.test_specific_data;

  /* since we are now disconnected from the code that established the
     control socket, and since we want to be able to use different
     protocols and such, we are passed the name of the remote host and
     must turn that into the test specific addressing information. */

  bzero((char *)&server,
	sizeof(server));

  server.sun_family = AF_UNIX;


  if ( print_headers ) {
    fprintf(where,"STREAM REQUEST/RESPONSE TEST\n");
    if (local_cpu_usage || remote_cpu_usage)
      fprintf(where,cpu_title,format_units());
    else
      fprintf(where,tput_title,format_units());
  }

  /* initialize a few counters */

  nummessages	=	0;
  bytes_xferd	=	0.0;
  times_up 	= 	0;

  /* set-up the data buffers with the requested alignment and offset.
     since this is a request/response test, default the send_width and
     recv_width to 1 and not two raj 7/94 */

  if (send_width == 0) send_width = 1;
  if (recv_width == 0) recv_width = 1;

  send_ring = allocate_buffer_ring(send_width,
				   req_size,
				   local_send_align,
				   local_send_offset);

  recv_ring = allocate_buffer_ring(recv_width,
				   rsp_size,
				   local_recv_align,
				   local_recv_offset);

  /*set up the data socket                        */
  send_socket = create_unix_socket(AF_UNIX,
				   SOCK_STREAM);

  if (send_socket == INVALID_SOCKET){
    perror("netperf: send_stream_rr: stream stream data socket");
    exit(1);
  }

  if (debug) {
    fprintf(where,"send_stream_rr: send_socket obtained...\n");
  }

  /* If the user has requested cpu utilization measurements, we must
     calibrate the cpu(s). We will perform this task within the tests
     themselves. If the user has specified the cpu rate, then
     calibrate_local_cpu will return rather quickly as it will have
     nothing to do. If local_cpu_rate is zero, then we will go through
     all the "normal" calibration stuff and return the rate back.*/

  if (local_cpu_usage) {
    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
  }

  /* Tell the remote end to do a listen. The server alters the socket
     paramters on the other side at this point, hence the reason for
     all the values being passed in the setup message. If the user did
     not specify any of the parameters, they will be passed as 0,
     which will indicate to the remote that no changes beyond the
     system's default should be used. Alignment is the exception, it
     will default to 8, which will be no alignment alterations. */

  netperf_request.content.request_type	=	DO_STREAM_RR;
  stream_rr_request->recv_buf_size	=	rsr_size;
  stream_rr_request->send_buf_size	=	rss_size;
  stream_rr_request->recv_alignment=	remote_recv_align;
  stream_rr_request->recv_offset	=	remote_recv_offset;
  stream_rr_request->send_alignment=	remote_send_align;
  stream_rr_request->send_offset	=	remote_send_offset;
  stream_rr_request->request_size	=	req_size;
  stream_rr_request->response_size	=	rsp_size;
  stream_rr_request->measure_cpu	=	remote_cpu_usage;
  stream_rr_request->cpu_rate	=	remote_cpu_rate;
  if (test_time) {
    stream_rr_request->test_length	=	test_time;
  }
  else {
    stream_rr_request->test_length	=	test_trans * -1;
  }

  if (debug > 1) {
    fprintf(where,"netperf: send_stream_rr: requesting STREAM rr test\n");
  }

  send_request();

  /* The response from the remote will contain all of the relevant
     socket parameters for this test type. We will put them back into
     the variables here so they can be displayed if desired.  The
     remote will have calibrated CPU if necessary, and will have done
     all the needed set-up we will have calibrated the cpu locally
     before sending the request, and will grab the counter value right
     after the connect returns. The remote will grab the counter right
     after the accept call. This saves the hassle of extra messages
     being sent for the STREAM tests.  */

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rsr_size	=	stream_rr_response->recv_buf_size;
    rss_size	=	stream_rr_response->send_buf_size;
    remote_cpu_usage=	stream_rr_response->measure_cpu;
    remote_cpu_rate = 	stream_rr_response->cpu_rate;
    /* make sure that port numbers are in network order */
    strcpy(server.sun_path,stream_rr_response->unix_path);
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /*Connect up to the remote port on the data socket  */
  if (connect(send_socket,
	      (struct sockaddr *)&server,
	      sizeof(server)) == INVALID_SOCKET){
    perror("netperf: data socket connect failed");

    exit(1);
  }

  /* Data Socket set-up is finished. If there were problems, either
     the connect would have failed, or the previous response would
     have indicated a problem. I failed to see the value of the extra
     message after the accept on the remote. If it failed, we'll see
     it here. If it didn't, we might as well start pumping data. */

  /* Set-up the test end conditions. For a request/response test, they
     can be either time or transaction based. */

  if (test_time) {
    /* The user wanted to end the test after a period of time. */
    times_up = 0;
    trans_remaining = 0;
    start_timer(test_time);
  }
  else {
    /* The tester wanted to send a number of bytes. */
    trans_remaining = test_bytes;
    times_up = 1;
  }

  /* The cpu_start routine will grab the current time and possibly
     value of the idle counter for later use in measuring cpu
     utilization and/or service demand and thruput. */

  cpu_start(local_cpu_usage);

  /* We use an "OR" to control test execution. When the test is
     controlled by time, the byte count check will always return
     false.  When the test is controlled by byte count, the time test
     will always return false. When the test is finished, the whole
     expression will go false and we will stop sending data. I think I
     just arbitrarily decrement trans_remaining for the timed test,
     but will not do that just yet... One other question is whether or
     not the send buffer and the receive buffer should be the same
     buffer. */

  while ((!times_up) || (trans_remaining > 0)) {
    /* send the request. we assume that if we use a blocking socket,
       the request will be sent at one shot. */
    if((len=send(send_socket,
		 send_ring->buffer_ptr,
		 req_size,
		 0)) != req_size) {
      if (errno == EINTR) {
	/* we hit the end of a timed test. */
	timed_out = 1;
	break;
      }
      perror("send_stream_rr: data send error");
      exit(1);
    }
    send_ring = send_ring->next;

    /* receive the response */
    rsp_bytes_left = rsp_size;
    temp_message_ptr  = recv_ring->buffer_ptr;
    while(rsp_bytes_left > 0) {
      if((rsp_bytes_recvd=recv(send_socket,
			       temp_message_ptr,
			       rsp_bytes_left,
			       0)) == SOCKET_ERROR) {
	if (errno == EINTR) {
	  /* We hit the end of a timed test. */
	  timed_out = 1;
	  break;
	}
	perror("send_stream_rr: data recv error");
	exit(1);
      }
      rsp_bytes_left -= rsp_bytes_recvd;
      temp_message_ptr  += rsp_bytes_recvd;
    }
    recv_ring = recv_ring->next;

    if (timed_out) {
      /* we may have been in a nested while loop - we need
         another call to break. */
      break;
    }

    nummessages++;
    if (trans_remaining) {
      trans_remaining--;
    }

    if (debug > 3) {
      fprintf(where,
	      "Transaction %d completed\n",
	      nummessages);
      fflush(where);
    }
  }

  /* At this point we used to call shutdown on the data socket to be
     sure all the data was delivered, but this was not germane in a
     request/response test, and it was causing the tests to "hang"
     when they were being controlled by time. So, I have replaced this
     shutdown call with a call to close that can be found later in the
     procedure. */

  /* this call will always give us the elapsed time for the test, and
     will also store-away the necessaries for cpu utilization */

  cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being
						   measured? how long
						   did we really
						   run? */

  /* Get the statistics from the remote end. The remote will have
     calculated service demand and all those interesting things. If it
     wasn't supposed to care, it will return obvious values. */

  recv_response();
  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote results obtained\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /* We now calculate what our thruput was for the test. In the
     future, we may want to include a calculation of the thruput
     measured by the remote, but it should be the case that for a
     STREAM stream test, that the two numbers should be *very*
     close... We calculate bytes_sent regardless of the way the test
     length was controlled.  If it was time, we needed to, and if it
     was by bytes, the user may have specified a number of bytes that
     wasn't a multiple of the send_size, so we really didn't send what
     he asked for ;-) We use Kbytes/s as the units of thruput for a
     STREAM stream test, where K = 1024. A future enhancement *might*
     be to choose from a couple of unit selections. */

  bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
  thruput	= calc_thruput(bytes_xferd);

  if (local_cpu_usage || remote_cpu_usage) {
    /* We must now do a little math for service demand and cpu
       utilization for the system(s) Of course, some of the
       information might be bogus because there was no idle counter in
       the kernel(s). We need to make a note of this for the user's
       benefit...*/
    if (local_cpu_usage) {
      if (local_cpu_rate == 0.0) {
	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
	fprintf(where,"Local CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      local_cpu_utilization = calc_cpu_util(0.0);
      /* since calc_service demand is doing ms/Kunit we will multiply
         the number of transaction by 1024 to get "good" numbers */
      local_service_demand  = calc_service_demand((double) nummessages*1024,
						  0.0,
						  0.0,
						  0);
    }
    else {
      local_cpu_utilization	= -1.0;
      local_service_demand	= -1.0;
    }

    if (remote_cpu_usage) {
      if (remote_cpu_rate == 0.0) {
	fprintf(where,"DANGER  DANGER  DANGER    DANGER  DANGER  DANGER    DANGER!\n");
	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      remote_cpu_utilization = stream_rr_result->cpu_util;
      /* since calc_service demand is doing ms/Kunit we will multiply
         the number of transaction by 1024 to get "good" numbers */
      remote_service_demand = calc_service_demand((double) nummessages*1024,
						  0.0,
						  remote_cpu_utilization,
						  stream_rr_result->num_cpus);
    }
    else {
      remote_cpu_utilization = -1.0;
      remote_service_demand  = -1.0;
    }

    /* We are now ready to print all the information. If the user has
       specified zero-level verbosity, we will just print the local
       service demand, or the remote service demand. If the user has
       requested verbosity level 1, he will get the basic "streamperf"
       numbers. If the user has specified a verbosity of greater than
       1, we will display a veritable plethora of background
       information from outside of this block as it it not
       cpu_measurement specific...  */

    switch (verbosity) {
    case 0:
      if (local_cpu_usage) {
	fprintf(where,
		cpu_fmt_0,
		local_service_demand);
      }
      else {
	fprintf(where,
		cpu_fmt_0,
		remote_service_demand);
      }
      break;
    case 1:
      fprintf(where,
	      cpu_fmt_1_line_1,		/* the format string */
	      lss_size,		/* local sendbuf size */
	      lsr_size,
	      req_size,		/* how large were the requests */
	      rsp_size,		/* guess */
	      elapsed_time,		/* how long was the test */
	      nummessages/elapsed_time,
	      local_cpu_utilization,	/* local cpu */
	      remote_cpu_utilization,	/* remote cpu */
	      local_service_demand,	/* local service demand */
	      remote_service_demand);	/* remote service demand */
      fprintf(where,
	      cpu_fmt_1_line_2,
	      rss_size,
	      rsr_size);
      break;
    }
  }
  else {
    /* The tester did not wish to measure service demand. */
    switch (verbosity) {
    case 0:
      fprintf(where,
	      tput_fmt_0,
	      nummessages/elapsed_time);
      break;
    case 1:
      fprintf(where,
	      tput_fmt_1_line_1,	/* the format string */
	      lss_size,
	      lsr_size,
	      req_size,		/* how large were the requests */
	      rsp_size,		/* how large were the responses */
	      elapsed_time, 		/* how long did it take */
	      nummessages/elapsed_time);
      fprintf(where,
	      tput_fmt_1_line_2,
	      rss_size, 		/* remote recvbuf size */
	      rsr_size);

      break;
    }
  }

  /* it would be a good thing to include information about some of the
     other parameters that may have been set for this test, but at the
     moment, I do not wish to figure-out all the formatting, so I will
     just put this comment here to help remind me that it is something
     that should be done at a later time. */

  if (verbosity > 1) {
    /* The user wanted to know it all, so we will give it to him.
       This information will include as much as we can find about
       STREAM statistics, the alignments of the sends and receives and
       all that sort of rot... */

    fprintf(where,
    	    "%s",
	    ksink_fmt);
  }
  /* The test is over. Kill the data socket */

  if (close(send_socket) == -1) {
    perror("send_stream_rr: cannot shutdown stream stream socket");
  }

}

void
send_dg_stream(char remote_host[])
{
  /*********************************************************************/
  /*								       */
  /*               	DG Unidirectional Send Test                    */
  /*								       */
  /*********************************************************************/
  char *tput_title =
    "Socket  Message  Elapsed      Messages                \n\
Size    Size     Time         Okay Errors   Throughput\n\
bytes   bytes    secs            #      #   %s/sec\n\n";

  char *tput_fmt_0 =
    "%7.2f\n";

  char *tput_fmt_1 =
    "%5d   %5d    %-7.2f   %7d %6d    %7.2f\n\
%5d            %-7.2f   %7d           %7.2f\n\n";


  char *cpu_title =
    "Socket  Message  Elapsed      Messages                   CPU     Service\n\
Size    Size     Time         Okay Errors   Throughput   Util    Demand\n\
bytes   bytes    secs            #      #   %s/sec   %%       us/KB\n\n";

  char *cpu_fmt_0 =
    "%6.2f\n";

  char *cpu_fmt_1 =
    "%5d   %5d    %-7.2f   %7d %6d    %7.1f      %-6.2f  %-6.3f\n\
%5d            %-7.2f   %7d           %7.1f      %-6.2f  %-6.3f\n\n";

  int	messages_recvd;
  float	elapsed_time,
  local_cpu_utilization,
  remote_cpu_utilization;

  float	local_service_demand, remote_service_demand;
  double	local_thruput, remote_thruput;
  double	bytes_sent;
  double	bytes_recvd;


  int	len;
  struct ring_elt *send_ring;
  int	failed_sends;
  int	failed_cows;
  int 	messages_sent;
  SOCKET data_socket;


#ifdef WANT_INTERVALS
  int	interval_count;
#endif /* WANT_INTERVALS */
#ifdef DIRTY
  int	*message_int_ptr;
  int	i;
#endif /* DIRTY */

  struct	sockaddr_un	server;

  struct	dg_stream_request_struct	*dg_stream_request;
  struct	dg_stream_response_struct	*dg_stream_response;
  struct	dg_stream_results_struct	*dg_stream_results;

  dg_stream_request	= (struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
  dg_stream_response	= (struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
  dg_stream_results	= (struct dg_stream_results_struct *)netperf_response.content.test_specific_data;

  /* since we are now disconnected from the code that established the
     control socket, and since we want to be able to use different
     protocols and such, we are passed the name of the remote host and
     must turn that into the test specific addressing information. */

  bzero((char *)&server,
	sizeof(server));

  server.sun_family = AF_UNIX;

  if ( print_headers ) {
    printf("DG UNIDIRECTIONAL SEND TEST\n");
    if (local_cpu_usage || remote_cpu_usage)
      printf(cpu_title,format_units());
    else
      printf(tput_title,format_units());
  }

  failed_sends	= 0;
  failed_cows	= 0;
  messages_sent	= 0;
  times_up	= 0;

  /*set up the data socket			*/
  data_socket = create_unix_socket(AF_UNIX,
				   SOCK_DGRAM);

  if (data_socket == INVALID_SOCKET){
    perror("dg_send: data socket");
    exit(1);
  }

  /* now, we want to see if we need to set the send_size */
  if (send_size == 0) {
    if (lss_size > 0) {
      send_size = (lss_size < UNIX_LENGTH_MAX ? lss_size : UNIX_LENGTH_MAX);
    }
    else {
      send_size = 4096;
    }
  }


  /* set-up the data buffer with the requested alignment and offset,
     most of the numbers here are just a hack to pick something nice
     and big in an attempt to never try to send a buffer a second time
     before it leaves the node...unless the user set the width
     explicitly. */
  if (send_width == 0) send_width = 32;

  send_ring = allocate_buffer_ring(send_width,
				   send_size,
				   local_send_align,
				   local_send_offset);

  /* At this point, we want to do things like disable DG checksumming
     and measure the cpu rate and all that so we are ready to go
     immediately after the test response message is delivered. */

  /* if the user supplied a cpu rate, this call will complete rather
     quickly, otherwise, the cpu rate will be retured to us for
     possible display. The Library will keep it's own copy of this
     data for use elsewhere. We will only display it. (Does that make
     it "opaque" to us?) */

  if (local_cpu_usage)
    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);

  /* Tell the remote end to set up the data connection. The server
     sends back the port number and alters the socket parameters
     there.  Of course this is a datagram service so no connection is
     actually set up, the server just sets up the socket and binds
     it. */

  netperf_request.content.request_type = DO_DG_STREAM;
  dg_stream_request->recv_buf_size	= rsr_size;
  dg_stream_request->message_size	= send_size;
  dg_stream_request->recv_alignment	= remote_recv_align;
  dg_stream_request->recv_offset	= remote_recv_offset;
  dg_stream_request->measure_cpu	= remote_cpu_usage;
  dg_stream_request->cpu_rate		= remote_cpu_rate;
  dg_stream_request->test_length	= test_time;

  send_request();

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"send_dg_stream: remote data connection done.\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("send_dg_stream: error on remote");
    exit(1);
  }

  /* Place the port number returned by the remote into the sockaddr
     structure so our sends can be sent to the correct place. Also get
     some of the returned socket buffer information for user
     display. */

  /* make sure that port numbers are in the proper order */
  strcpy(server.sun_path,dg_stream_response->unix_path);
  rsr_size	= dg_stream_response->recv_buf_size;
  rss_size	= dg_stream_response->send_buf_size;
  remote_cpu_rate	= dg_stream_response->cpu_rate;

  /* We "connect" up to the remote post to allow is to use the send
     call instead of the sendto call. Presumeably, this is a little
     simpler, and a little more efficient. I think that it also means
     that we can be informed of certain things, but am not sure
     yet... */

  if (connect(data_socket,
	      (struct sockaddr *)&server,
	      sizeof(server)) == INVALID_SOCKET){
    perror("send_dg_stream: data socket connect failed");
    exit(1);
  }

  /* set up the timer to call us after test_time  */
  start_timer(test_time);

  /* Get the start count for the idle counter and the start time */

  cpu_start(local_cpu_usage);

#ifdef WANT_INTERVALS
  interval_count = interval_burst;
#endif

  /* Send datagrams like there was no tomorrow. at somepoint it might
     be nice to set this up so that a quantity of bytes could be sent,
     but we still need some sort of end of test trigger on the receive
     side. that could be a select with a one second timeout, but then
     if there is a test where none of the data arrives for awile and
     then starts again, we would end the test too soon. something to
     think about... */
  while (!times_up) {

#ifdef DIRTY
    /* we want to dirty some number of consecutive integers in the
       buffer we are about to send. we may also want to bring some
       number of them cleanly into the cache. The clean ones will
       follow any dirty ones into the cache. */
    message_int_ptr = (int *)(send_ring->buffer_ptr);
    for (i = 0; i < loc_dirty_count; i++) {
      *message_int_ptr = 4;
      message_int_ptr++;
    }
    for (i = 0; i < loc_clean_count; i++) {
      loc_dirty_count = *message_int_ptr;
      message_int_ptr++;
    }
#endif /* DIRTY */

    if ((len=send(data_socket,
		  send_ring->buffer_ptr,
		  send_size,
		  0))  != send_size) {
      if ((len >= 0) || (errno == EINTR))
	break;
      if (errno == ENOBUFS) {
	failed_sends++;
	continue;
      }
      perror("dg_send: data send error");
      exit(1);
    }
    messages_sent++;

    /* now we want to move our pointer to the next position in the
       data buffer... */

    send_ring = send_ring->next;


#ifdef WANT_INTERVALS
    /* in this case, the interval count is the count-down couter to
       decide to sleep for a little bit */
    if ((interval_burst) && (--interval_count == 0)) {
      /* call the sleep routine for some milliseconds, if our timer
         popped while we were in there, we want to break out of the
         loop. */
      if (msec_sleep(interval_wate)) {
	break;
      }
      interval_count = interval_burst;
    }

#endif

  }

  /* This is a timed test, so the remote will be returning to us after
     a time. We should not need to send any "strange" messages to tell
     the remote that the test is completed, unless we decide to add a
     number of messages to the test. */

  /* the test is over, so get stats and stuff */
  cpu_stop(local_cpu_usage,
	   &elapsed_time);

  /* Get the statistics from the remote end  */
  recv_response();
  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"send_dg_stream: remote results obtained\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("send_dg_stream: error on remote");
    exit(1);
  }

  bytes_sent	= send_size * messages_sent;
  local_thruput	= calc_thruput(bytes_sent);

  messages_recvd	= dg_stream_results->messages_recvd;
  bytes_recvd	= send_size * messages_recvd;

  /* we asume that the remote ran for as long as we did */

  remote_thruput	= calc_thruput(bytes_recvd);

  /* print the results for this socket and message size */

  if (local_cpu_usage || remote_cpu_usage) {
    /* We must now do a little math for service demand and cpu
       utilization for the system(s) We pass zeros for the local cpu
       utilization and elapsed time to tell the routine to use the
       libraries own values for those. */
    if (local_cpu_usage) {
      if (local_cpu_rate == 0.0) {
	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
	fprintf(where,"Local CPU usage numbers based on process information only!\n");
	fflush(where);
      }

      local_cpu_utilization	= calc_cpu_util(0.0);
      local_service_demand	= calc_service_demand(bytes_sent,
						      0.0,
						      0.0,
						      0);
    }
    else {
      local_cpu_utilization	= -1.0;
      local_service_demand	= -1.0;
    }

    /* The local calculations could use variables being kept by the
       local netlib routines. The remote calcuations need to have a
       few things passed to them. */
    if (remote_cpu_usage) {
      if (remote_cpu_rate == 0.0) {
	fprintf(where,"DANGER   DANGER  DANGER   DANGER  DANGER   DANGER   DANGER!\n");
	fprintf(where,"REMOTE CPU usage numbers based on process information only!\n");
	fflush(where);
      }

      remote_cpu_utilization	= dg_stream_results->cpu_util;
      remote_service_demand	= calc_service_demand(bytes_recvd,
						      0.0,
						      remote_cpu_utilization,
						      dg_stream_results->num_cpus);
    }
    else {
      remote_cpu_utilization	= -1.0;
      remote_service_demand	= -1.0;
    }

    /* We are now ready to print all the information. If the user has
       specified zero-level verbosity, we will just print the local
       service demand, or the remote service demand. If the user has
       requested verbosity level 1, he will get the basic "streamperf"
       numbers. If the user has specified a verbosity of greater than
       1, we will display a veritable plethora of background
       information from outside of this block as it it not
       cpu_measurement specific...  */

    switch (verbosity) {
    case 0:
      if (local_cpu_usage) {
	fprintf(where,
		cpu_fmt_0,
		local_service_demand);
      }
      else {
	fprintf(where,
		cpu_fmt_0,
		remote_service_demand);
      }
      break;
    case 1:
      fprintf(where,
	      cpu_fmt_1,	    /* the format string */
	      lss_size,		    /* local sendbuf size */
	      send_size,	    /* how large were the sends */
	      elapsed_time,	    /* how long was the test */
	      messages_sent,
	      failed_sends,
	      local_thruput, 	    /* what was the xfer rate */
	      local_cpu_utilization,/* local cpu */
	      local_service_demand, /* local service demand */
	      rsr_size,
	      elapsed_time,
	      messages_recvd,
	      remote_thruput,
	      remote_cpu_utilization,	/* remote cpu */
	      remote_service_demand);	/* remote service demand */
      break;
    }
  }
  else {
    /* The tester did not wish to measure service demand. */
    switch (verbosity) {
    case 0:
      fprintf(where,
	      tput_fmt_0,
	      local_thruput);
      break;
    case 1:
      fprintf(where,
	      tput_fmt_1,		/* the format string */
	      lss_size, 		/* local sendbuf size */
	      send_size,		/* how large were the sends */
	      elapsed_time, 		/* how long did it take */
	      messages_sent,
	      failed_sends,
	      local_thruput,
	      rsr_size, 		/* remote recvbuf size */
	      elapsed_time,
	      messages_recvd,
	      remote_thruput
	      );
      break;
    }
  }
}


 /* this routine implements the receive side (netserver) of the
    DG_STREAM performance test. */

void
recv_dg_stream()
{
  struct ring_elt *recv_ring;

  struct sockaddr_un myaddr_un;
  SOCKET s_data;
  int	len = 0;
  int	bytes_received = 0;
  float	elapsed_time;

  int	message_size;
  int	messages_recvd = 0;

  struct	dg_stream_request_struct	*dg_stream_request;
  struct	dg_stream_response_struct	*dg_stream_response;
  struct	dg_stream_results_struct	*dg_stream_results;

  dg_stream_request  =
    (struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
  dg_stream_response =
    (struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
  dg_stream_results  =
    (struct dg_stream_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_dg_stream: entered...\n");
    fflush(where);
  }

  /* We want to set-up the listen socket with all the desired
     parameters and then let the initiator know that all is ready. If
     socket size defaults are to be used, then the initiator will have
     sent us 0's. If the socket sizes cannot be changed, then we will
     send-back what they are. If that information cannot be
     determined, then we send-back -1's for the sizes. If things go
     wrong for any reason, we will drop back ten yards and punt. */

  /* If anything goes wrong, we want the remote to know about it. It
     would be best if the error that the remote reports to the user is
     the actual error we encountered, rather than some bogus
     unexpected response type message. */

  if (debug > 1) {
    fprintf(where,"recv_dg_stream: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = DG_STREAM_RESPONSE;

  if (debug > 2) {
    fprintf(where,"recv_dg_stream: the response type is set...\n");
    fflush(where);
  }

  /* We now alter the message_ptr variable to be at the desired
     alignment with the desired offset. */

  if (debug > 1) {
    fprintf(where,"recv_dg_stream: requested alignment of %d\n",
	    dg_stream_request->recv_alignment);
    fflush(where);
  }

  if (recv_width == 0) recv_width = 1;

  recv_ring = allocate_buffer_ring(recv_width,
				   dg_stream_request->message_size,
				   dg_stream_request->recv_alignment,
				   dg_stream_request->recv_offset);

  if (debug > 1) {
    fprintf(where,"recv_dg_stream: receive alignment and offset set...\n");
    fflush(where);
  }

  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
     can put in OUR values !-) At some point, we may want to nail this
     socket to a particular network-level address, but for now,
     INADDR_ANY should be just fine. */

  bzero((char *)&myaddr_un,
	sizeof(myaddr_un));
  myaddr_un.sun_family      = AF_UNIX;

  /* Grab a socket to listen on, and then listen on it. */

  if (debug > 1) {
    fprintf(where,"recv_dg_stream: grabbing a socket...\n");
    fflush(where);
  }

  /* create_unix_socket expects to find some things in the global
     variables, so set the globals based on the values in the request.
     once the socket has been created, we will set the response values
     based on the updated value of those globals. raj 7/94 */
  lsr_size = dg_stream_request->recv_buf_size;

  s_data = create_unix_socket(AF_UNIX,
			      SOCK_DGRAM);

  if (s_data == INVALID_SOCKET) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  /* Let's get an address assigned to this socket so we can tell the
     initiator how to reach the data socket. There may be a desire to
     nail this socket to a specific IP address in a multi-homed,
     multi-connection situation, but for now, we'll ignore the issue
     and concentrate on single connection testing. */

  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
  if (bind(s_data,
	   (struct sockaddr *)&myaddr_un,
	   sizeof(myaddr_un)) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  chmod(myaddr_un.sun_path, 0666);

  dg_stream_response->test_length = dg_stream_request->test_length;

  /* Now myaddr_un contains the port and the internet address this is
     returned to the sender also implicitly telling the sender that
     the socket buffer sizing has been done. */

  strcpy(dg_stream_response->unix_path,myaddr_un.sun_path);
  netperf_response.content.serv_errno   = 0;

  /* But wait, there's more. If the initiator wanted cpu measurements,
     then we must call the calibrate routine, which will return the
     max rate back to the initiator. If the CPU was not to be
     measured, or something went wrong with the calibration, we will
     return a -1 to the initiator. */

  dg_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
  if (dg_stream_request->measure_cpu) {
    /* We will pass the rate into the calibration routine. If the user
       did not specify one, it will be 0.0, and we will do a "real"
       calibration. Otherwise, all it will really do is store it
       away... */
    dg_stream_response->measure_cpu = 1;
    dg_stream_response->cpu_rate =
      calibrate_local_cpu(dg_stream_request->cpu_rate);
  }

  message_size	= dg_stream_request->message_size;
  test_time	= dg_stream_request->test_length;

  /* before we send the response back to the initiator, pull some of
     the socket parms from the globals */
  dg_stream_response->send_buf_size = lss_size;
  dg_stream_response->recv_buf_size = lsr_size;

  send_response();

  /* Now it's time to start receiving data on the connection. We will
     first grab the apropriate counters and then start grabbing. */

  cpu_start(dg_stream_request->measure_cpu);

  /* The loop will exit when the timer pops, or if we happen to recv a
     message of less than send_size bytes... */

  times_up = 0;
  start_timer(test_time + PAD_TIME);

  if (debug) {
    fprintf(where,"recv_dg_stream: about to enter inner sanctum.\n");
    fflush(where);
  }

  while (!times_up) {
    if ((len = recv(s_data,
		    recv_ring->buffer_ptr,
		    message_size,
		    0)) != message_size) {
      if ((len == SOCKET_ERROR) && (errno != EINTR)) {
	netperf_response.content.serv_errno = errno;
	send_response();
	exit(1);
      }
      break;
    }
    messages_recvd++;
    recv_ring = recv_ring->next;
  }

  if (debug) {
    fprintf(where,"recv_dg_stream: got %d messages.\n",messages_recvd);
    fflush(where);
  }


  /* The loop now exits due timer or < send_size bytes received. */

  cpu_stop(dg_stream_request->measure_cpu,&elapsed_time);

  if (times_up) {
    /* we ended on a timer, subtract the PAD_TIME */
    elapsed_time -= (float)PAD_TIME;
  }
  else {
    stop_timer();
  }

  if (debug) {
    fprintf(where,"recv_dg_stream: test ended in %f seconds.\n",elapsed_time);
    fflush(where);
  }


  /* We will count the "off" message that got us out of the loop */
  bytes_received = (messages_recvd * message_size) + len;

  /* send the results to the sender			*/

  if (debug) {
    fprintf(where,
	    "recv_dg_stream: got %d bytes\n",
	    bytes_received);
    fflush(where);
  }

  netperf_response.content.response_type		= DG_STREAM_RESULTS;
  dg_stream_results->bytes_received	= bytes_received;
  dg_stream_results->messages_recvd	= messages_recvd;
  dg_stream_results->elapsed_time	= elapsed_time;
  if (dg_stream_request->measure_cpu) {
    dg_stream_results->cpu_util	= calc_cpu_util(elapsed_time);
  }
  else {
    dg_stream_results->cpu_util	= -1.0;
  }

  if (debug > 1) {
    fprintf(where,
	    "recv_dg_stream: test complete, sending results.\n");
    fflush(where);
  }

  send_response();

}

void
send_dg_rr(char remote_host[])
{

  char *tput_title = "\
Local /Remote\n\
Socket Size   Request  Resp.   Elapsed  Trans.\n\
Send   Recv   Size     Size    Time     Rate         \n\
bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";

  char *tput_fmt_0 =
    "%7.2f\n";

  char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
  char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";

  char *cpu_title = "\
Local /Remote\n\
Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";

  char *cpu_fmt_0 =
    "%6.3f\n";

  char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";

  char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";

  float			elapsed_time;

  /* we add MAXALIGNMENT and MAXOFFSET to insure that there is enough
     space for a maximally aligned, maximally sized message. At some
     point, we may want to actually make this even larger and cycle
     through the thing one piece at a time.*/

  int	len;
  char	*send_message_ptr;
  char	*recv_message_ptr;
  char	*temp_message_ptr;
  int	nummessages;
  SOCKET send_socket;
  int	trans_remaining;
  int	bytes_xferd;

  int	rsp_bytes_recvd;

  float	local_cpu_utilization;
  float	local_service_demand;
  float	remote_cpu_utilization;
  float	remote_service_demand;
  double	thruput;

#ifdef WANT_INTERVALS
  /* timing stuff */
#define	MAX_KEPT_TIMES	1024
  int	time_index = 0;
  int	unused_buckets;
  int	kept_times[MAX_KEPT_TIMES];
  int	sleep_usecs;
  unsigned	int	total_times=0;
  struct	timezone	dummy_zone;
  struct	timeval		send_time;
  struct	timeval		recv_time;
  struct	timeval		sleep_timeval;
#endif

  struct	sockaddr_un	server, myaddr_un;

  struct	dg_rr_request_struct	*dg_rr_request;
  struct	dg_rr_response_struct	*dg_rr_response;
  struct	dg_rr_results_struct	*dg_rr_result;

  dg_rr_request	=
    (struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
  dg_rr_response=
    (struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
  dg_rr_result	=
    (struct dg_rr_results_struct *)netperf_response.content.test_specific_data;

  /* we want to zero out the times, so we can detect unused entries. */
#ifdef WANT_INTERVALS
  time_index = 0;
  while (time_index < MAX_KEPT_TIMES) {
    kept_times[time_index] = 0;
    time_index += 1;
  }
  time_index = 0;
#endif

  /* since we are now disconnected from the code that established the
     control socket, and since we want to be able to use different
     protocols and such, we are passed the name of the remote host and
     must turn that into the test specific addressing information. */

  bzero((char *)&server,
	sizeof(server));
  server.sun_family = AF_UNIX;

  bzero((char *)&myaddr_un,
	sizeof(myaddr_un));
  myaddr_un.sun_family = AF_UNIX;

  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));

  if ( print_headers ) {
    fprintf(where,"DG REQUEST/RESPONSE TEST\n");
    if (local_cpu_usage || remote_cpu_usage)
      fprintf(where,cpu_title,format_units());
    else
      fprintf(where,tput_title,format_units());
  }

  /* initialize a few counters */

  nummessages	=	0;
  bytes_xferd	=	0;
  times_up 	= 	0;

  /* set-up the data buffer with the requested alignment and offset */
  temp_message_ptr = (char *)malloc(DATABUFFERLEN);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", DATABUFFERLEN);
    exit(1);
  }
  send_message_ptr = (char *)(( (long)temp_message_ptr +
			(long) local_send_align - 1) &
			~((long) local_send_align - 1));
  send_message_ptr = send_message_ptr + local_send_offset;
  temp_message_ptr = (char *)malloc(DATABUFFERLEN);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", DATABUFFERLEN);
    exit(1);
  }
  recv_message_ptr = (char *)(( (long)temp_message_ptr +
			(long) local_recv_align - 1) &
			~((long) local_recv_align - 1));
  recv_message_ptr = recv_message_ptr + local_recv_offset;

  /*set up the data socket                        */
  send_socket = create_unix_socket(AF_UNIX,
				   SOCK_DGRAM);

  if (send_socket == INVALID_SOCKET){
    perror("netperf: send_dg_rr: dg rr data socket");
    exit(1);
  }

  if (debug) {
    fprintf(where,"send_dg_rr: send_socket obtained...\n");
  }


  /* If the user has requested cpu utilization measurements, we must
     calibrate the cpu(s). We will perform this task within the tests
     themselves. If the user has specified the cpu rate, then
     calibrate_local_cpu will return rather quickly as it will have
     nothing to do. If local_cpu_rate is zero, then we will go through
     all the "normal" calibration stuff and return the rate back. If
     there is no idle counter in the kernel idle loop, the
     local_cpu_rate will be set to -1. */

  if (local_cpu_usage) {
    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
  }

  /* Tell the remote end to do a listen. The server alters the socket
     paramters on the other side at this point, hence the reason for
     all the values being passed in the setup message. If the user did
     not specify any of the parameters, they will be passed as 0,
     which will indicate to the remote that no changes beyond the
     system's default should be used. Alignment is the exception, it
     will default to 8, which will be no alignment alterations. */

  netperf_request.content.request_type	=	DO_DG_RR;
  dg_rr_request->recv_buf_size	=	rsr_size;
  dg_rr_request->send_buf_size	=	rss_size;
  dg_rr_request->recv_alignment	=	remote_recv_align;
  dg_rr_request->recv_offset	=	remote_recv_offset;
  dg_rr_request->send_alignment	=	remote_send_align;
  dg_rr_request->send_offset	=	remote_send_offset;
  dg_rr_request->request_size	=	req_size;
  dg_rr_request->response_size	=	rsp_size;
  dg_rr_request->measure_cpu	=	remote_cpu_usage;
  dg_rr_request->cpu_rate	=	remote_cpu_rate;
  if (test_time) {
    dg_rr_request->test_length	=	test_time;
  }
  else {
    dg_rr_request->test_length	=	test_trans * -1;
  }

  if (debug > 1) {
    fprintf(where,"netperf: send_dg_rr: requesting DG request/response test\n");
  }

  send_request();

  /* The response from the remote will contain all of the relevant
     socket parameters for this test type. We will put them back into
     the variables here so they can be displayed if desired.  The
     remote will have calibrated CPU if necessary, and will have done
     all the needed set-up we will have calibrated the cpu locally
     before sending the request, and will grab the counter value right
     after the connect returns. The remote will grab the counter right
     after the accept call. This saves the hassle of extra messages
     being sent for the DG tests.  */

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rsr_size	=	dg_rr_response->recv_buf_size;
    rss_size	=	dg_rr_response->send_buf_size;
    remote_cpu_usage=	dg_rr_response->measure_cpu;
    remote_cpu_rate = 	dg_rr_response->cpu_rate;
    /* port numbers in proper order */
    strcpy(server.sun_path,dg_rr_response->unix_path);
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /* Connect up to the remote port on the data socket. This will set
     the default destination address on this socket. we need to bind
     out socket so that the remote gets something from a recvfrom  */
  if (bind(send_socket,
	   (struct sockaddr *)&myaddr_un,
	   sizeof(myaddr_un)) == SOCKET_ERROR) {
    perror("netperf: send_dg_rr");
    unlink(myaddr_un.sun_path);
    close(send_socket);
    exit(1);
  }

  if (connect(send_socket,
	      (struct sockaddr *)&server,
	      sizeof(server)) == INVALID_SOCKET ) {
    perror("netperf: data socket connect failed");
    exit(1);
  }

  /* Data Socket set-up is finished. If there were problems, either
     the connect would have failed, or the previous response would
     have indicated a problem. I failed to see the value of the extra
     message after the accept on the remote. If it failed, we'll see
     it here. If it didn't, we might as well start pumping data. */

  /* Set-up the test end conditions. For a request/response test, they
     can be either time or transaction based. */

  if (test_time) {
    /* The user wanted to end the test after a period of time. */
    times_up = 0;
    trans_remaining = 0;
    start_timer(test_time);
  }
  else {
    /* The tester wanted to send a number of bytes. */
    trans_remaining = test_bytes;
    times_up = 1;
  }

  /* The cpu_start routine will grab the current time and possibly
     value of the idle counter for later use in measuring cpu
     utilization and/or service demand and thruput. */

  cpu_start(local_cpu_usage);

  /* We use an "OR" to control test execution. When the test is
     controlled by time, the byte count check will always return
     false.  When the test is controlled by byte count, the time test
     will always return false. When the test is finished, the whole
     expression will go false and we will stop sending data. I think I
     just arbitrarily decrement trans_remaining for the timed test,
     but will not do that just yet... One other question is whether or
     not the send buffer and the receive buffer should be the same
     buffer. */
  while ((!times_up) || (trans_remaining > 0)) {
    /* send the request */
#ifdef WANT_INTERVALS
    gettimeofday(&send_time,&dummy_zone);
#endif
    if((len=send(send_socket,
		 send_message_ptr,
		 req_size,
		 0)) != req_size) {
      if (errno == EINTR) {
	/* We likely hit */
	/* test-end time. */
	break;
      }
      perror("send_dg_rr: data send error");
      exit(1);
    }

    /* receive the response. with DG we will get it all, or nothing */

    if((rsp_bytes_recvd=recv(send_socket,
			     recv_message_ptr,
			     rsp_size,
			     0)) != rsp_size) {
      if (errno == EINTR) {
	/* Again, we have likely hit test-end time */
	break;
      }
      perror("send_dg_rr: data recv error");
      exit(1);
    }
#ifdef WANT_INTERVALS
    gettimeofday(&recv_time,&dummy_zone);

    /* now we do some arithmatic on the two timevals */
    if (recv_time.tv_usec < send_time.tv_usec) {
      /* we wrapped around a second */
      recv_time.tv_usec += 1000000;
      recv_time.tv_sec  -= 1;
    }

    /* and store it away */
    kept_times[time_index] = (recv_time.tv_sec - send_time.tv_sec) * 1000000;
    kept_times[time_index] += (recv_time.tv_usec - send_time.tv_usec);

    /* at this point, we may wish to sleep for some period of time, so
       we see how long that last transaction just took, and sleep for
       the difference of that and the interval. We will not sleep if
       the time would be less than a millisecond.  */
    if (interval_usecs > 0) {
      sleep_usecs = interval_usecs - kept_times[time_index];
      if (sleep_usecs > 1000) {
	/* we sleep */
	sleep_timeval.tv_sec = sleep_usecs / 1000000;
	sleep_timeval.tv_usec = sleep_usecs % 1000000;
	select(0,
	       0,
	       0,
	       0,
	       &sleep_timeval);
      }
    }

    /* now up the time index */
    time_index = (time_index +1)%MAX_KEPT_TIMES;
#endif
    nummessages++;
    if (trans_remaining) {
      trans_remaining--;
    }

    if (debug > 3) {
      fprintf(where,"Transaction %d completed\n",nummessages);
      fflush(where);
    }

  }

  /* The test is over. Flush the buffers to the remote end. We do a
     graceful release to insure that all data has been taken by the
     remote. Of course, since this was a request/response test, there
     should be no data outstanding on the socket ;-) */

  if (shutdown(send_socket,1) == SOCKET_ERROR) {
    perror("netperf: cannot shutdown dg stream socket");

    exit(1);
  }

  /* this call will always give us the elapsed time for the test, and
     will also store-away the necessaries for cpu utilization */

  cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being
						   measured? how long
						   did we really
						   run? */

  /* Get the statistics from the remote end. The remote will have
     calculated service demand and all those interesting things. If it
     wasn't supposed to care, it will return obvious values. */

  recv_response();
  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote results obtained\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /* We now calculate what our thruput was for the test. In the
     future, we may want to include a calculation of the thruput
     measured by the remote, but it should be the case that for a DG
     stream test, that the two numbers should be *very* close... We
     calculate bytes_sent regardless of the way the test length was
     controlled.  If it was time, we needed to, and if it was by
     bytes, the user may have specified a number of bytes that wasn't
     a multiple of the send_size, so we really didn't send what he
     asked for ;-) We use */

  bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
  thruput		= calc_thruput(bytes_xferd);

  if (local_cpu_usage || remote_cpu_usage) {
    /* We must now do a little math for service demand and cpu
       utilization for the system(s) Of course, some of the
       information might be bogus because there was no idle counter in
       the kernel(s). We need to make a note of this for the user's
       benefit...*/
    if (local_cpu_usage) {
      if (local_cpu_rate == 0.0) {
	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
	fprintf(where,"Local CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      local_cpu_utilization = calc_cpu_util(0.0);
      /* since calc_service demand is doing ms/Kunit we will multiply
         the number of transaction by 1024 to get "good" numbers */
      local_service_demand  = calc_service_demand((double) nummessages*1024,
						  0.0,
						  0.0,
						  0);
    }
    else {
      local_cpu_utilization	= -1.0;
      local_service_demand	= -1.0;
    }

    if (remote_cpu_usage) {
      if (remote_cpu_rate == 0.0) {
	fprintf(where,"DANGER  DANGER  DANGER    DANGER  DANGER  DANGER    DANGER!\n");
	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
	fflush(where);
      }
      remote_cpu_utilization = dg_rr_result->cpu_util;
      /* since calc_service demand is doing ms/Kunit we will multiply
         the number of transaction by 1024 to get "good" numbers */
      remote_service_demand  = calc_service_demand((double) nummessages*1024,
						   0.0,
						   remote_cpu_utilization,
						   dg_rr_result->num_cpus);
    }
    else {
      remote_cpu_utilization = -1.0;
      remote_service_demand  = -1.0;
    }

    /* We are now ready to print all the information. If the user has
       specified zero-level verbosity, we will just print the local
       service demand, or the remote service demand. If the user has
       requested verbosity level 1, he will get the basic "streamperf"
       numbers. If the user has specified a verbosity of greater than
       1, we will display a veritable plethora of background
       information from outside of this block as it it not
       cpu_measurement specific...  */

    switch (verbosity) {
    case 0:
      if (local_cpu_usage) {
	fprintf(where,
		cpu_fmt_0,
		local_service_demand);
      }
      else {
	fprintf(where,
		cpu_fmt_0,
		remote_service_demand);
      }
      break;
    case 1:
    case 2:
      fprintf(where,
	      cpu_fmt_1_line_1,	/* the format string */
	      lss_size,		/* local sendbuf size */
	      lsr_size,
	      req_size,		/* how large were the requests */
	      rsp_size,		/* guess */
	      elapsed_time,	/* how long was the test */
	      nummessages/elapsed_time,
	      local_cpu_utilization,	/* local cpu */
	      remote_cpu_utilization,	/* remote cpu */
	      local_service_demand,	/* local service demand */
	      remote_service_demand);	/* remote service demand */
      fprintf(where,
	      cpu_fmt_1_line_2,
	      rss_size,
	      rsr_size);
      break;
    }
  }
  else {
    /* The tester did not wish to measure service demand. */
    switch (verbosity) {
    case 0:
      fprintf(where,
	      tput_fmt_0,
	      nummessages/elapsed_time);
      break;
    case 1:
    case 2:
      fprintf(where,
	      tput_fmt_1_line_1,	/* the format string */
	      lss_size,
	      lsr_size,
	      req_size,		/* how large were the requests */
	      rsp_size,		/* how large were the responses */
	      elapsed_time, 		/* how long did it take */
	      nummessages/elapsed_time);
      fprintf(where,
	      tput_fmt_1_line_2,
	      rss_size, 		/* remote recvbuf size */
	      rsr_size);

      break;
    }
  }

  /* it would be a good thing to include information about some of the
     other parameters that may have been set for this test, but at the
     moment, I do not wish to figure-out all the formatting, so I will
     just put this comment here to help remind me that it is something
     that should be done at a later time. */

  if (verbosity > 1) {
    /* The user wanted to know it all, so we will give it to him.
       This information will include as much as we can find about DG
       statistics, the alignments of the sends and receives and all
       that sort of rot... */

#ifdef WANT_INTERVALS
    kept_times[MAX_KEPT_TIMES] = 0;
    time_index = 0;
    while (time_index < MAX_KEPT_TIMES) {
      if (kept_times[time_index] > 0) {
	total_times += kept_times[time_index];
      }
      else
	unused_buckets++;
      time_index += 1;
    }
    total_times /= (MAX_KEPT_TIMES-unused_buckets);
    fprintf(where,
	    "Average response time %d usecs\n",
	    total_times);
#endif
  }
  unlink(myaddr_un.sun_path);
}

 /* this routine implements the receive side (netserver) of a DG_RR
    test. */
void
recv_dg_rr()
{

  struct ring_elt *recv_ring;
  struct ring_elt *send_ring;

  struct	sockaddr_un        myaddr_un,
  peeraddr_un;
  SOCKET s_data;
  netperf_socklen_t addrlen;
  int	trans_received = 0;
  int	trans_remaining;
  float	elapsed_time;

  struct	dg_rr_request_struct	*dg_rr_request;
  struct	dg_rr_response_struct	*dg_rr_response;
  struct	dg_rr_results_struct	*dg_rr_results;

  dg_rr_request  =
    (struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
  dg_rr_response =
    (struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
  dg_rr_results  =
    (struct dg_rr_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_dg_rr: entered...\n");
    fflush(where);
  }

  /* We want to set-up the listen socket with all the desired
     parameters and then let the initiator know that all is ready. If
     socket size defaults are to be used, then the initiator will have
     sent us 0's. If the socket sizes cannot be changed, then we will
     send-back what they are. If that information cannot be
     determined, then we send-back -1's for the sizes. If things go
     wrong for any reason, we will drop back ten yards and punt. */

  /* If anything goes wrong, we want the remote to know about it. It
     would be best if the error that the remote reports to the user is
     the actual error we encountered, rather than some bogus
     unexpected response type message. */

  if (debug) {
    fprintf(where,"recv_dg_rr: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = DG_RR_RESPONSE;

  if (debug) {
    fprintf(where,"recv_dg_rr: the response type is set...\n");
    fflush(where);
  }

  /* We now alter the message_ptr variables to be at the desired
     alignments with the desired offsets. */

  if (debug) {
    fprintf(where,"recv_dg_rr: requested recv alignment of %d offset %d\n",
	    dg_rr_request->recv_alignment,
	    dg_rr_request->recv_offset);
    fprintf(where,"recv_dg_rr: requested send alignment of %d offset %d\n",
	    dg_rr_request->send_alignment,
	    dg_rr_request->send_offset);
    fflush(where);
  }

  if (send_width == 0) send_width = 1;
  if (recv_width == 0) recv_width = 1;

  recv_ring = allocate_buffer_ring(recv_width,
				   dg_rr_request->request_size,
				   dg_rr_request->recv_alignment,
				   dg_rr_request->recv_offset);

  send_ring = allocate_buffer_ring(send_width,
				   dg_rr_request->response_size,
				   dg_rr_request->send_alignment,
				   dg_rr_request->send_offset);

  if (debug) {
    fprintf(where,"recv_dg_rr: receive alignment and offset set...\n");
    fflush(where);
  }

  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
     can put in OUR values !-) At some point, we may want to nail this
     socket to a particular network-level address, but for now,
     INADDR_ANY should be just fine. */

  bzero((char *)&myaddr_un,
	sizeof(myaddr_un));
  myaddr_un.sun_family      = AF_UNIX;

  /* Grab a socket to listen on, and then listen on it. */

  if (debug) {
    fprintf(where,"recv_dg_rr: grabbing a socket...\n");
    fflush(where);
  }


  /* create_unix_socket expects to find some things in the global
     variables, so set the globals based on the values in the request.
     once the socket has been created, we will set the response values
     based on the updated value of those globals. raj 7/94 */
  lss_size_req = dg_rr_request->send_buf_size;
  lsr_size_req = dg_rr_request->recv_buf_size;

  s_data = create_unix_socket(AF_UNIX,
			      SOCK_DGRAM);

  if (s_data == INVALID_SOCKET) {
    netperf_response.content.serv_errno = errno;
    send_response();

    exit(1);
  }

  /* Let's get an address assigned to this socket so we can tell the
     initiator how to reach the data socket. There may be a desire to
     nail this socket to a specific IP address in a multi-homed,
     multi-connection situation, but for now, we'll ignore the issue
     and concentrate on single connection testing. */

  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
  if (bind(s_data,
	   (struct sockaddr *)&myaddr_un,
	   sizeof(myaddr_un)) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    unlink(myaddr_un.sun_path);
    close(s_data);
    send_response();

    exit(1);
  }

  /* Now myaddr_un contains the port and the internet address this is
     returned to the sender also implicitly telling the sender that
     the socket buffer sizing has been done. */

  strcpy(dg_rr_response->unix_path,myaddr_un.sun_path);
  netperf_response.content.serv_errno   = 0;

  /* But wait, there's more. If the initiator wanted cpu measurements,
     then we must call the calibrate routine, which will return the
     max rate back to the initiator. If the CPU was not to be
     measured, or something went wrong with the calibration, we will
     return a 0.0 to the initiator. */

  dg_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
  if (dg_rr_request->measure_cpu) {
    dg_rr_response->measure_cpu = 1;
    dg_rr_response->cpu_rate = calibrate_local_cpu(dg_rr_request->cpu_rate);
  }

  /* before we send the response back to the initiator, pull some of
     the socket parms from the globals */
  dg_rr_response->send_buf_size = lss_size;
  dg_rr_response->recv_buf_size = lsr_size;

  send_response();


  /* Now it's time to start receiving data on the connection. We will
     first grab the apropriate counters and then start grabbing. */

  cpu_start(dg_rr_request->measure_cpu);

  if (dg_rr_request->test_length > 0) {
    times_up = 0;
    trans_remaining = 0;
    start_timer(dg_rr_request->test_length + PAD_TIME);
  }
  else {
    times_up = 1;
    trans_remaining = dg_rr_request->test_length * -1;
  }

  addrlen = sizeof(peeraddr_un);
  bzero((char *)&peeraddr_un, addrlen);

  while ((!times_up) || (trans_remaining > 0)) {

    /* receive the request from the other side */
    fprintf(where,"socket %d ptr %p size %d\n",
	    s_data,
	    recv_ring->buffer_ptr,
	    dg_rr_request->request_size);
    fflush(where);
    if (recvfrom(s_data,
		 recv_ring->buffer_ptr,
		 dg_rr_request->request_size,
		 0,
		 (struct sockaddr *)&peeraddr_un,
		 &addrlen) != dg_rr_request->request_size) {
      if (errno == EINTR) {
	/* we must have hit the end of test time. */
	break;
      }
      netperf_response.content.serv_errno = errno;
      fprintf(where,"error on recvfrom errno %d\n",errno);
      fflush(where);
      send_response();
      unlink(myaddr_un.sun_path);
      exit(1);
    }
    recv_ring = recv_ring->next;

    /* Now, send the response to the remote */
    if (sendto(s_data,
	       send_ring->buffer_ptr,
	       dg_rr_request->response_size,
	       0,
	       (struct sockaddr *)&peeraddr_un,
	       addrlen) != dg_rr_request->response_size) {
      if (errno == EINTR) {
	/* we have hit end of test time. */
	break;
      }
      netperf_response.content.serv_errno = errno;
      fprintf(where,"error on recvfrom errno %d\n",errno);
      fflush(where);
      unlink(myaddr_un.sun_path);
      send_response();
      exit(1);
    }
    send_ring = send_ring->next;

    trans_received++;
    if (trans_remaining) {
      trans_remaining--;
    }

    if (debug) {
      fprintf(where,
	      "recv_dg_rr: Transaction %d complete.\n",
	      trans_received);
      fflush(where);
    }

  }


  /* The loop now exits due to timeout or transaction count being
     reached */

  cpu_stop(dg_rr_request->measure_cpu,&elapsed_time);

  if (times_up) {
    /* we ended the test by time, which was at least 2 seconds longer
       than we wanted to run. so, we want to subtract PAD_TIME from
       the elapsed_time. */
    elapsed_time -= PAD_TIME;
  }
  /* send the results to the sender			*/

  if (debug) {
    fprintf(where,
	    "recv_dg_rr: got %d transactions\n",
	    trans_received);
    fflush(where);
  }

  dg_rr_results->bytes_received	= (trans_received *
					   (dg_rr_request->request_size +
					    dg_rr_request->response_size));
  dg_rr_results->trans_received	= trans_received;
  dg_rr_results->elapsed_time	= elapsed_time;
  if (dg_rr_request->measure_cpu) {
    dg_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
  }

  if (debug) {
    fprintf(where,
	    "recv_dg_rr: test complete, sending results.\n");
    fflush(where);
  }

  send_response();
  unlink(myaddr_un.sun_path);

}
 /* this routine implements the receive (netserver) side of a
    STREAM_RR test */

void
recv_stream_rr()
{

  struct ring_elt *send_ring;
  struct ring_elt *recv_ring;

  struct	sockaddr_un        myaddr_un,
  peeraddr_un;
  SOCKET s_listen,s_data;
  netperf_socklen_t addrlen;
  char	*temp_message_ptr;
  int	trans_received = 0;
  int	trans_remaining;
  int	bytes_sent;
  int	request_bytes_recvd;
  int	request_bytes_remaining;
  int	timed_out = 0;
  float	elapsed_time;

  struct	stream_rr_request_struct	*stream_rr_request;
  struct	stream_rr_response_struct	*stream_rr_response;
  struct	stream_rr_results_struct	*stream_rr_results;

  stream_rr_request =
    (struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
  stream_rr_response =
    (struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
  stream_rr_results =
    (struct stream_rr_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_stream_rr: entered...\n");
    fflush(where);
  }

  /* We want to set-up the listen socket with all the desired
     parameters and then let the initiator know that all is ready. If
     socket size defaults are to be used, then the initiator will have
     sent us 0's. If the socket sizes cannot be changed, then we will
     send-back what they are. If that information cannot be
     determined, then we send-back -1's for the sizes. If things go
     wrong for any reason, we will drop back ten yards and punt. */

  /* If anything goes wrong, we want the remote to know about it. It
     would be best if the error that the remote reports to the user is
     the actual error we encountered, rather than some bogus
     unexpected response type message. */

  if (debug) {
    fprintf(where,"recv_stream_rr: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = STREAM_RR_RESPONSE;

  if (debug) {
    fprintf(where,"recv_stream_rr: the response type is set...\n");
    fflush(where);
  }

  /* allocate the recv and send rings with the requested alignments
     and offsets. raj 7/94 */
  if (debug) {
    fprintf(where,"recv_stream_rr: requested recv alignment of %d offset %d\n",
	    stream_rr_request->recv_alignment,
	    stream_rr_request->recv_offset);
    fprintf(where,"recv_stream_rr: requested send alignment of %d offset %d\n",
	    stream_rr_request->send_alignment,
	    stream_rr_request->send_offset);
    fflush(where);
  }

  /* at some point, these need to come to us from the remote system */
  if (send_width == 0) send_width = 1;
  if (recv_width == 0) recv_width = 1;

  send_ring = allocate_buffer_ring(send_width,
				   stream_rr_request->response_size,
				   stream_rr_request->send_alignment,
				   stream_rr_request->send_offset);

  recv_ring = allocate_buffer_ring(recv_width,
				   stream_rr_request->request_size,
				   stream_rr_request->recv_alignment,
				   stream_rr_request->recv_offset);


  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
     can put in OUR values !-) At some point, we may want to nail this
     socket to a particular network-level address, but for now,
     INADDR_ANY should be just fine. */

  bzero((char *)&myaddr_un,
	sizeof(myaddr_un));
  myaddr_un.sun_family      = AF_UNIX;

  /* Grab a socket to listen on, and then listen on it. */

  if (debug) {
    fprintf(where,"recv_stream_rr: grabbing a socket...\n");
    fflush(where);
  }

  /* create_unix_socket expects to find some things in the global
     variables, so set the globals based on the values in the request.
     once the socket has been created, we will set the response values
     based on the updated value of those globals. raj 7/94 */
  lss_size_req = stream_rr_request->send_buf_size;
  lsr_size_req = stream_rr_request->recv_buf_size;

  s_listen = create_unix_socket(AF_UNIX,
				SOCK_STREAM);

  if (s_listen == INVALID_SOCKET) {
    netperf_response.content.serv_errno = errno;
    send_response();

    exit(1);
  }

  /* Let's get an address assigned to this socket so we can tell the
     initiator how to reach the data socket. There may be a desire to
     nail this socket to a specific IP address in a multi-homed,
     multi-connection situation, but for now, we'll ignore the issue
     and concentrate on single connection testing. */

  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
  if (bind(s_listen,
	   (struct sockaddr *)&myaddr_un,
	   sizeof(myaddr_un)) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    unlink(myaddr_un.sun_path);
    close(s_listen);
    send_response();

    exit(1);
  }

  /* Now, let's set-up the socket to listen for connections */
  if (listen(s_listen, 5) == SOCKET_ERROR) {
    netperf_response.content.serv_errno = errno;
    close(s_listen);
    send_response();

    exit(1);
  }

  /* Now myaddr_un contains the port and the internet address this is
     returned to the sender also implicitly telling the sender that
     the socket buffer sizing has been done. */

  strcpy(stream_rr_response->unix_path,myaddr_un.sun_path);
  netperf_response.content.serv_errno   = 0;

  /* But wait, there's more. If the initiator wanted cpu measurements,
     then we must call the calibrate routine, which will return the
     max rate back to the initiator. If the CPU was not to be
     measured, or something went wrong with the calibration, we will
     return a 0.0 to the initiator. */

  stream_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
  if (stream_rr_request->measure_cpu) {
    stream_rr_response->measure_cpu = 1;
    stream_rr_response->cpu_rate = calibrate_local_cpu(stream_rr_request->cpu_rate);
  }


  /* before we send the response back to the initiator, pull some of
     the socket parms from the globals */
  stream_rr_response->send_buf_size = lss_size;
  stream_rr_response->recv_buf_size = lsr_size;

  send_response();

  addrlen = sizeof(peeraddr_un);

  if ((s_data = accept(s_listen,
		       (struct sockaddr *)&peeraddr_un,
		       &addrlen)) == INVALID_SOCKET) {
    /* Let's just punt. The remote will be given some information */
    close(s_listen);

    exit(1);
  }

  if (debug) {
    fprintf(where,"recv_stream_rr: accept completes on the data connection.\n");
    fflush(where);
  }

  /* Now it's time to start receiving data on the connection. We will
     first grab the apropriate counters and then start grabbing. */

  cpu_start(stream_rr_request->measure_cpu);

  /* The loop will exit when the sender does a shutdown, which will
     return a length of zero  */

  if (stream_rr_request->test_length > 0) {
    times_up = 0;
    trans_remaining = 0;
    start_timer(stream_rr_request->test_length + PAD_TIME);
  }
  else {
    times_up = 1;
    trans_remaining = stream_rr_request->test_length * -1;
  }

  while ((!times_up) || (trans_remaining > 0)) {
    temp_message_ptr = recv_ring->buffer_ptr;
    request_bytes_remaining	= stream_rr_request->request_size;

    /* receive the request from the other side */
    if (debug) {
      fprintf(where,"about to receive for trans %d\n",trans_received);
      fprintf(where,"temp_message_ptr is %p\n",temp_message_ptr);
      fflush(where);
    }
    while(request_bytes_remaining > 0) {
      if((request_bytes_recvd=recv(s_data,
				   temp_message_ptr,
				   request_bytes_remaining,
				   0)) == SOCKET_ERROR) {
	if (errno == EINTR) {
	  /* the timer popped */
	  timed_out = 1;
	  break;
	}
	netperf_response.content.serv_errno = errno;
	send_response();
	exit(1);
      }
      else {
	request_bytes_remaining -= request_bytes_recvd;
	temp_message_ptr  += request_bytes_recvd;
      }
      if (debug) {
	fprintf(where,"just received for trans %d\n",trans_received);
	fflush(where);
      }
    }

    recv_ring = recv_ring->next;

    if (timed_out) {
      /* we hit the end of the test based on time - lets
         bail out of here now... */
      fprintf(where,"yo5\n");
      fflush(where);
      break;
    }

    /* Now, send the response to the remote */
    if (debug) {
      fprintf(where,"about to send for trans %d\n",trans_received);
      fflush(where);
    }
    if((bytes_sent=send(s_data,
			send_ring->buffer_ptr,
			stream_rr_request->response_size,
			0)) == SOCKET_ERROR) {
      if (errno == EINTR) {
	/* the test timer has popped */
	timed_out = 1;
	fprintf(where,"yo6\n");
	fflush(where);
	break;
      }
      netperf_response.content.serv_errno = 997;
      send_response();
      exit(1);
    }

    send_ring = send_ring->next;

    trans_received++;
    if (trans_remaining) {
      trans_remaining--;
    }

    if (debug) {
      fprintf(where,
	      "recv_stream_rr: Transaction %d complete\n",
	      trans_received);
      fflush(where);
    }
  }


  /* The loop now exits due to timeout or transaction count being
     reached */

  cpu_stop(stream_rr_request->measure_cpu,&elapsed_time);

  if (timed_out) {
    /* we ended the test by time, which was at least 2 seconds longer
       than we wanted to run. so, we want to subtract PAD_TIME from
       the elapsed_time. */
    elapsed_time -= PAD_TIME;
  }
  /* send the results to the sender			*/

  if (debug) {
    fprintf(where,
	    "recv_stream_rr: got %d transactions\n",
	    trans_received);
    fflush(where);
  }

  stream_rr_results->bytes_received	= (trans_received *
					   (stream_rr_request->request_size +
					    stream_rr_request->response_size));
  stream_rr_results->trans_received	= trans_received;
  stream_rr_results->elapsed_time	= elapsed_time;
  if (stream_rr_request->measure_cpu) {
    stream_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
  }

  if (debug) {
    fprintf(where,
	    "recv_stream_rr: test complete, sending results.\n");
    fflush(where);
  }

  send_response();
  unlink(myaddr_un.sun_path);
}

void
print_unix_usage()
{

  fwrite(unix_usage, sizeof(char), strlen(unix_usage), stdout);
  exit(1);

}
void
scan_unix_args(int argc, char *argv[])
{
#define UNIX_ARGS "hm:M:p:r:s:S:"
  extern char	*optarg;	  /* pointer to option string	*/

  int		c;

  char
    arg1[BUFSIZ],  /* argument holders		*/
    arg2[BUFSIZ];

  init_test_vars();

  if (no_control) {
    fprintf(where,
	    "The UNIX tests do not know how to run with no control connection\n");
    exit(-1);
  }

  /* Go through all the command line arguments and break them out. For
     those options that take two parms, specifying only the first will
     set both to that value. Specifying only the second will leave the
     first untouched. To change only the first, use the form "first,"
     (see the routine break_args.. */

  while ((c= getopt(argc, argv, UNIX_ARGS)) != EOF) {
    switch (c) {
    case '?':
    case 'h':
      print_unix_usage();
      exit(1);
    case 'p':
      /* set the path prefix (directory) that should be used for the
         pipes. at some point, there should be some error checking. */
      strcpy(path_prefix,optarg);
      break;
    case 's':
      /* set local socket sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	lss_size_req = convert(arg1);
      if (arg2[0])
	lsr_size_req = convert(arg2);
      break;
    case 'S':
      /* set remote socket sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	rss_size = convert(arg1);
      if (arg2[0])
	rsr_size = convert(arg2);
      break;
    case 'r':
      /* set the request/response sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	req_size = convert(arg1);
      if (arg2[0])
	rsp_size = convert(arg2);
      break;
    case 'm':
      /* set the send size */
      send_size = convert(optarg);
      break;
    case 'M':
      /* set the recv size */
      recv_size = convert(optarg);
      break;
    };
  }
}
#endif /* WANT_UNIX */
