
/****************************************************************/
/*								*/
/*	nettest_dlpi.c						*/
/*								*/
/*	the actual test routines...				*/
/*								*/
/*	send_dlpi_co_stream()	perform a CO DLPI stream test	*/
/*	recv_dlpi_co_stream()					*/
/*	send_dlpi_co_rr()	perform a CO DLPI req/res	*/
/*	recv_dlpi_co_rr()					*/
/*	send_dlpi_cl_stream()	perform a CL DLPI stream test	*/
/*	recv_dlpi_cl_stream()					*/
/*	send_dlpi_cl_rr()	perform a CL DLPI req/res	*/
/*	recv_dlpi_cl_rr()					*/
/*								*/
/****************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef WANT_DLPI
char	nettest_dlpi_id[]="\
@(#)nettest_dlpi.c (c) Copyright 1993-2012 Hewlett-Packard Co. Version 2.6.0";

#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <malloc.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/poll.h>
#ifdef __osf__
#include <sys/dlpihdr.h>
#else /* __osf__ */
#include <sys/dlpi.h>
#ifdef __hpux__
#include <sys/dlpi_ext.h>
#endif /* __hpux__ */
#endif /* __osf__ */

#include "netlib.h"
#include "netsh.h"
#include "nettest_dlpi.h"

/* some stuff for DLPI control messages */
#define DLPI_DATA_SIZE 2048

unsigned long control_data[DLPI_DATA_SIZE];
struct strbuf control_message = {DLPI_DATA_SIZE, 0, (char *)control_data};

/* these are some variables global to all the DLPI tests. declare */
/* them static to make them global only to this file */

static int
  rsw_size,		/* remote send window size	*/
  rrw_size,		/* remote recv window size	*/
  lsw_size,		/* local  send window size 	*/
  lrw_size,		/* local  recv window size 	*/
  req_size = 100,	/* request size                   	*/
  rsp_size = 200,	/* response size			*/
  send_size,		/* how big are individual sends		*/
  recv_size;		/* how big are individual receives	*/

int
  loc_ppa = 4,          /* the ppa for the local interface, */
  /* as shown as the NM Id in lanscan */
  rem_ppa = 4,          /* the ppa for the remote interface */
  dlpi_sap = 84;        /* which 802.2 SAP should we use?   */

char loc_dlpi_device[32] = "/dev/dlpi";
char rem_dlpi_device[32] = "/dev/dlpi";

char dlpi_usage[] = "\n\
Usage: netperf [global options] -- [test options] \n\
\n\
CO/CL DLPI Test Options:\n\
    -D dev[,dev]      Set the local/remote DLPI device file name\n\
    -h                Display this text\n\
    -M bytes          Set the recv size (DLCO_STREAM, DLCL_STREAM)\n\
    -m bytes          Set the send size (DLCO_STREAM, DLCL_STREAM)\n\
    -p loc[,rem]      Set the local/remote PPA for the test\n\
    -R bytes          Set response size (DLCO_RR, DLCL_RR)\n\
    -r bytes          Set request size (DLCO_RR, DLCL_RR)\n\
    -s sap            Set the 802.2 sap for the test\n\
    -W send[,recv]    Set remote send/recv window sizes\n\
    -w send[,recv]    Set local send/recv window 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";


/* routines that used to be in src/netlib.c but this code is the only
   code that uses them. raj 20110111 */


int
put_control(fd, len, pri, ack)
     int fd, len, pri, ack;
{
  int error;
  int flags = 0;
  dl_error_ack_t *err_ack = (dl_error_ack_t *)control_data;

  control_message.len = len;

  if ((error = putmsg(fd, &control_message, 0, pri)) < 0 ) {
    fprintf(where,"put_control: putmsg error %d\n",error);
    fflush(where);
    return(-1);
  }
  if ((error = getmsg(fd, &control_message, 0, &flags)) < 0) {
    fprintf(where,"put_control: getsmg error %d\n",error);
    fflush(where);
    return(-1);
  }
  if (err_ack->dl_primitive != ack) {
    fprintf(where,"put_control: acknowledgement error wanted %u got %u \n",
            ack,err_ack->dl_primitive);
    if (err_ack->dl_primitive == DL_ERROR_ACK) {
      fprintf(where,"             dl_error_primitive: %u\n",
              err_ack->dl_error_primitive);
      fprintf(where,"             dl_errno:           %u\n",
              err_ack->dl_errno);
      fprintf(where,"             dl_unix_errno       %u\n",
              err_ack->dl_unix_errno);
    }
    fflush(where);
    return(-1);
  }

  return(0);
}

int
dl_open(char devfile[], int ppa)
{
  int fd;
  dl_attach_req_t *attach_req = (dl_attach_req_t *)control_data;

  if ((fd = open(devfile, O_RDWR)) == -1) {
    fprintf(where,"netperf: dl_open: open of %s failed, errno = %d\n",
            devfile,
            errno);
    return(-1);
  }

  attach_req->dl_primitive = DL_ATTACH_REQ;
  attach_req->dl_ppa = ppa;

  if (put_control(fd, sizeof(dl_attach_req_t), 0, DL_OK_ACK) < 0) {
    fprintf(where,
            "netperf: dl_open: could not send control message, errno = %d\n",
            errno);
    return(-1);
  }
  return(fd);
}

int
dl_bind(int fd, int sap, int mode, char *dlsap_ptr, int *dlsap_len)
{
  dl_bind_req_t *bind_req = (dl_bind_req_t *)control_data;
  dl_bind_ack_t *bind_ack = (dl_bind_ack_t *)control_data;

  bind_req->dl_primitive = DL_BIND_REQ;
  bind_req->dl_sap = sap;
  bind_req->dl_max_conind = 1;
  bind_req->dl_service_mode = mode;
  bind_req->dl_conn_mgmt = 0;
  bind_req->dl_xidtest_flg = 0;

  if (put_control(fd, sizeof(dl_bind_req_t), 0, DL_BIND_ACK) < 0) {
    fprintf(where,
            "netperf: dl_bind: could not send control message, errno = %d\n",
            errno);
    return(-1);
  }

  /* at this point, the control_data portion of the control message */
  /* structure should contain a DL_BIND_ACK, which will have a full */
  /* DLSAP in it. we want to extract this and pass it up so that    */
  /* it can be passed around. */
  if (*dlsap_len >= bind_ack->dl_addr_length) {
    bcopy((char *)bind_ack+bind_ack->dl_addr_offset,
          dlsap_ptr,
          bind_ack->dl_addr_length);
    *dlsap_len = bind_ack->dl_addr_length;
    return(0);
  }
  else {
    return (-1);
  }
}

int
dl_connect(int fd, unsigned char *remote_addr, int remote_addr_len)
{
  dl_connect_req_t *connection_req = (dl_connect_req_t *)control_data;
  dl_connect_con_t *connection_con = (dl_connect_con_t *)control_data;
  struct pollfd pinfo;

  int flags = 0;

  /* this is here on the off chance that we really want some data */
  u_long data_area[512];
  struct strbuf data_message;

  int error;

  data_message.maxlen = 2048;
  data_message.len = 0;
  data_message.buf = (char *)data_area;

  connection_req->dl_primitive = DL_CONNECT_REQ;
  connection_req->dl_dest_addr_length = remote_addr_len;
  connection_req->dl_dest_addr_offset = sizeof(dl_connect_req_t);
  connection_req->dl_qos_length = 0;
  connection_req->dl_qos_offset = 0;
  bcopy (remote_addr,
         (unsigned char *)control_data + sizeof(dl_connect_req_t),
         remote_addr_len);

  /* well, I would call the put_control routine here, but the sequence */
  /* of connection stuff with DLPI is a bit screwey with all this */
  /* message passing - Toto, I don't think were in Berkeley anymore. */

  control_message.len = sizeof(dl_connect_req_t) + remote_addr_len;
  if ((error = putmsg(fd,&control_message,0,0)) !=0) {
    fprintf(where,"dl_connect: putmsg failure, errno = %d, error 0x%x \n",
            errno,error);
    fflush(where);
    return(-1);
  };

  pinfo.fd = fd;
  pinfo.events = POLLIN | POLLPRI;
  pinfo.revents = 0;

  if ((error = getmsg(fd,&control_message,&data_message,&flags)) != 0) {
    fprintf(where,"dl_connect: getmsg failure, errno = %d, error 0x%x \n",
            errno,error);
    fflush(where);
    return(-1);
  }
  while (control_data[0] == DL_TEST_CON) {
    /* i suppose we spin until we get an error, or a connection */
    /* indication */
    if((error = getmsg(fd,&control_message,&data_message,&flags)) !=0) {
       fprintf(where,"dl_connect: getmsg failure, errno = %d, error = 0x%x\n",
               errno,error);
       fflush(where);
       return(-1);
    }
  }

  /* we are out - it either worked or it didn't - which was it? */
  if (control_data[0] == DL_CONNECT_CON) {
    return(0);
  }
  else {
    return(-1);
  }
}

int
dl_accept(fd, remote_addr, remote_addr_len)
     int fd;
     unsigned char *remote_addr;
     int remote_addr_len;
{
  dl_connect_ind_t *connect_ind = (dl_connect_ind_t *)control_data;
  dl_connect_res_t *connect_res = (dl_connect_res_t *)control_data;
  int tmp_cor;
  int flags = 0;

  /* hang around and wait for a connection request */
  getmsg(fd,&control_message,0,&flags);
  while (control_data[0] != DL_CONNECT_IND) {
    getmsg(fd,&control_message,0,&flags);
  }

  /* now respond to the request. at some point, we may want to be sure */
  /* that the connection came from the correct station address, but */
  /* will assume that we do not have to worry about it just now. */

  tmp_cor = connect_ind->dl_correlation;

  connect_res->dl_primitive = DL_CONNECT_RES;
  connect_res->dl_correlation = tmp_cor;
  connect_res->dl_resp_token = 0;
  connect_res->dl_qos_length = 0;
  connect_res->dl_qos_offset = 0;
  connect_res->dl_growth = 0;

  return(put_control(fd, sizeof(dl_connect_res_t), 0, DL_OK_ACK));

}

int
dl_set_window(fd, window)
     int fd, window;
{
  return(0);
}

void
dl_stats(fd)
     int fd;
{
}

int
dl_send_disc(fd)
     int fd;
{
}

int
dl_recv_disc(fd)
     int fd;
{
}


/* This routine implements the CO 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_dlpi_co_stream()
{

  char *tput_title = "\
Recv   Send    Send                          \n\
Window Window  Message  Elapsed              \n\
Size   Size    Size     Time     Throughput  \n\
frames frames  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\
Window Window  Message  Elapsed              Send   Recv    Send    Recv\n\
Size   Size    Size     Time     Throughput  local  remote  local   remote\n\
frames frames  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 /* WANT_INTERVALS */

  /* 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. */

  struct ring_elt *send_ring;
  char	*message;
  char	*message_ptr;
  struct strbuf send_message;
  char  dlsap[BUFSIZ];
  int   dlsap_len;
  int	*message_int_ptr;
  int	message_offset;
  int	malloc_size;

  int	len;
  int	nummessages;
  int	send_descriptor;
  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	dlpi_co_stream_request_struct	*dlpi_co_stream_request;
  struct	dlpi_co_stream_response_struct	*dlpi_co_stream_response;
  struct	dlpi_co_stream_results_struct	*dlpi_co_stream_result;

  dlpi_co_stream_request	=
    (struct dlpi_co_stream_request_struct *)netperf_request.content.test_specific_data;
  dlpi_co_stream_response	=
    (struct dlpi_co_stream_response_struct *)netperf_response.content.test_specific_data;
  dlpi_co_stream_result	        =
    (struct dlpi_co_stream_results_struct *)netperf_response.content.test_specific_data;

  if ( print_headers ) {
    fprintf(where,"DLPI CO 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 descriptor                        */
  send_descriptor = dl_open(loc_dlpi_device,loc_ppa);
  if (send_descriptor < 0){
    perror("netperf: send_dlpi_co_stream: dlpi stream data descriptor");
    exit(1);
  }

  /* bind the puppy and get the assigned dlsap */
  dlsap_len = BUFSIZ;
  if (dl_bind(send_descriptor,
              dlpi_sap, DL_CODLS, dlsap, &dlsap_len) != 0) {
    fprintf(where,"send_dlpi_co_rr: bind failure\n");
    fflush(where);
    exit(1);
  }

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

#ifdef DL_HP_SET_LOCAL_WIN_REQ
  if (lsw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_co_stream: window send size altered from system default...\n");
      fprintf(where,"                          send: %d\n",lsw_size);
    }
  }
  if (lrw_size > 0) {
    if (debug > 1) {
      fprintf(where,
	      "netperf: send_dlpi_co_stream: window recv size altered from system default...\n");
      fprintf(where,"                          recv: %d\n",lrw_size);
    }
  }


  /* Now, we will find-out what the size actually became, and report */
  /* that back to the user. If the call fails, we will just report a -1 */
  /* back to the initiator for the recv buffer size. */


  if (debug) {
    fprintf(where,
	    "netperf: send_dlpi_co_stream: window sizes determined...\n");
    fprintf(where,"         send: %d recv: %d\n",lsw_size,lrw_size);
    fflush(where);
  }

#else /* DL_HP_SET_LOCAL_WIN_REQ */

  lsw_size = -1;
  lrw_size = -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* we should pick a default send_size, it should not be larger than */
  /* the min of the two interface MTU's, and should perhaps default to */
  /* the Interface MTU, but for now, we will default it to 1024... if */
  /* someone wants to change this, the should change the corresponding */
  /* lines in the recv_dlpi_co_stream routine */

  if (send_size == 0) {
    send_size = 1024;
  }

  /* set-up the data buffer with the requested alignment and offset. */
  /* After we have calculated the proper starting address, we want to */
  /* put that back into the message variable so we go back to the */
  /* proper place. note that this means that only the first send is */
  /* guaranteed to be at the alignment specified by the -a parameter. I */
  /* think that this is a little more "real-world" than what was found */
  /* in previous versions. 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 = (lsw_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);

  send_message.maxlen = send_size;
  send_message.len = send_size;
  send_message.buf = send_ring->buffer_ptr;

  /* 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. */

  netperf_request.content.request_type	 =	DO_DLPI_CO_STREAM;
  dlpi_co_stream_request->send_win_size =	rsw_size;
  dlpi_co_stream_request->recv_win_size =	rrw_size;
  dlpi_co_stream_request->receive_size	 =	recv_size;
  dlpi_co_stream_request->recv_alignment=	remote_recv_align;
  dlpi_co_stream_request->recv_offset	 =	remote_recv_offset;
  dlpi_co_stream_request->measure_cpu	 =	remote_cpu_usage;
  dlpi_co_stream_request->cpu_rate	 =	remote_cpu_rate;
  dlpi_co_stream_request->ppa           =      rem_ppa;
  dlpi_co_stream_request->sap           =      dlpi_sap;
  dlpi_co_stream_request->dev_name_len  =      strlen(rem_dlpi_device);
  strcpy(dlpi_co_stream_request->dlpi_device,
	 rem_dlpi_device);

#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I didn't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_co_stream_request->dlpi_device;
    lastword = initword + ((strlen(rem_dlpi_device) + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = ntohl(*charword);
    }
  }
#endif /* __alpha */

  if (test_time) {
    dlpi_co_stream_request->test_length	=	test_time;
  }
  else {
    dlpi_co_stream_request->test_length	=	test_bytes;
  }
#ifdef DIRTY
  dlpi_co_stream_request->dirty_count       =       rem_dirty_count;
  dlpi_co_stream_request->clean_count       =       rem_clean_count;
#endif /* DIRTY */


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

  send_request();

  /* The response from the remote will contain all of the relevant 	*/
  /* 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 TCP tests.					*/

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rrw_size	=	dlpi_co_stream_response->recv_win_size;
    rsw_size	=	dlpi_co_stream_response->send_win_size;
    remote_cpu_usage=	dlpi_co_stream_response->measure_cpu;
    remote_cpu_rate = 	dlpi_co_stream_response->cpu_rate;
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");
    exit(1);
  }

  /* Connect up to the remote port on the data descriptor */
  if(dl_connect(send_descriptor,
		dlpi_co_stream_response->station_addr,
		dlpi_co_stream_response->station_addr_len) != 0) {
    fprintf(where,"recv_dlpi_co_stream: connect failure\n");
    fflush(where);
    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 /* DIRTY */

  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. */
    message_int_ptr = (int *)message_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((putmsg(send_descriptor,
	       0,
	       &send_message,
	       0)) != 0) {
      if (errno == EINTR)
	break;
      perror("netperf: data send error");
      exit(1);
    }
    send_ring = send_ring->next;
    send_message.buf = send_ring->buffer_ptr;
#ifdef WANT_INTERVALS
    for (interval_count = 0;
	 interval_count < interval_wate;
	 interval_count++);
#endif /* WANT_INTERVALS */

    if (debug > 4) {
      fprintf(where,"netperf: send_clpi_co_stream: putmsg called ");
      fprintf(where,"len is %d\n",send_message.len);
      fflush(where);
    }

    nummessages++;
    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. this needs a little work - there is no three-way */
  /* handshake with type two as there is with TCP, so there really */
  /* should be a message exchange here. however, we will finesse it by */
  /* saying that the tests shoudl run for a while. */

  if (debug) {
    fprintf(where,"sending test end signal \n");
    fflush(where);
  }

  send_message.len = (send_size - 1);
  if (send_message.len == 0) send_message.len = 2;

  if((putmsg(send_descriptor,
	     0,
	     &send_message,
	     0)) != 0) {
    perror("netperf: data send error");
    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 TCP 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) + (double) 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	= dlpi_co_stream_result->cpu_util;
      remote_service_demand	= calc_service_demand(bytes_sent,
						      0.0,
						      remote_cpu_utilization,
						      dlpi_co_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 */
	      rrw_size,		/* remote recvbuf size */
	      lsw_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 */
	      rrw_size, 		/* remote recvbuf size */
	      lsw_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 */
    /* TCP 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)dlpi_co_stream_result->recv_calls,
	    dlpi_co_stream_result->recv_calls);
  }

}


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

int
  recv_dlpi_co_stream()
{

  int	data_descriptor;
  int	flags = 0;
  int	measure_cpu;
  int	bytes_received;
  int	receive_calls;
  float	elapsed_time;

  struct ring_elt *recv_ring;
  char	*message_ptr;
  char	*message;
  int   *message_int_ptr;
  struct strbuf recv_message;
  int   dirty_count;
  int   clean_count;
  int   i;

  struct	dlpi_co_stream_request_struct	*dlpi_co_stream_request;
  struct	dlpi_co_stream_response_struct	*dlpi_co_stream_response;
  struct	dlpi_co_stream_results_struct	*dlpi_co_stream_results;

  dlpi_co_stream_request	= (struct dlpi_co_stream_request_struct *)netperf_request.content.test_specific_data;
  dlpi_co_stream_response	= (struct dlpi_co_stream_response_struct *)netperf_response.content.test_specific_data;
  dlpi_co_stream_results	= (struct dlpi_co_stream_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_dlpi_co_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. */

  netperf_response.content.response_type = DLPI_CO_STREAM_RESPONSE;

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

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


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

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


#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_co_stream_request->dlpi_device;
    lastword = initword + ((dlpi_co_stream_request->dev_name_len + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = htonl(*charword);
    }
  }
#endif /* __alpha */

  data_descriptor = dl_open(dlpi_co_stream_request->dlpi_device,
			    dlpi_co_stream_request->ppa);
  if (data_descriptor < 0) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

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

  /* bind the sap and retrieve the dlsap assigned by the system  */
  dlpi_co_stream_response->station_addr_len = 14; /* arbitrary */
  if (dl_bind(data_descriptor,
	      dlpi_co_stream_request->sap,
	      DL_CODLS,
	      (char *)dlpi_co_stream_response->station_addr,
	      &dlpi_co_stream_response->station_addr_len) != 0) {
    fprintf(where,"recv_dlpi_co_stream: bind failure\n");
    fflush(where);
    exit(1);
  }

  /* The initiator may have wished-us to modify the socket buffer */
  /* sizes. We should give it a shot. If he didn't ask us to change the */
  /* sizes, we should let him know what sizes were in use at this end. */
  /* If none of this code is compiled-in, then we will tell the */
  /* initiator that we were unable to play with the socket buffer by */
  /* setting the size in the response to -1. */

#ifdef DL_HP_SET_LOCAL_WIN_REQ

  if (dlpi_co_stream_request->recv_win_size) {
  }
  /* Now, we will find-out what the size actually became, and report */
  /* that back to the user. If the call fails, we will just report a -1 */
  /* back to the initiator for the recv buffer size. */

#else /* the system won't let us play with the buffers */

  dlpi_co_stream_response->recv_win_size	= -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* what sort of sizes did we end-up with? */
  /* this bit of code whould default to the Interface MTU */
  if (dlpi_co_stream_request->receive_size == 0) {
    recv_size = 1024;
  }
  else {
    recv_size = dlpi_co_stream_request->receive_size;
  }

  /* tell the other fellow what our receive size became */
  dlpi_co_stream_response->receive_size = recv_size;

  /* just a little prep work for when we may have to behave like the */
  /* sending side... */
  message = (char *)malloc(recv_size * 2);
  if (message == NULL) {
    printf("malloc(%d) failed!\n", recv_size * 2);
    exit(1);
  }

  message_ptr = ALIGN_BUFFER(message, dlpi_co_stream_request->recv_alignment, dlpi_co_stream_request->recv_offset);
  recv_message.maxlen = recv_size;
  recv_message.len = 0;
  recv_message.buf = message_ptr;

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

  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. */

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

  send_response();

  /* accept a connection on this file descriptor. at some point, */
  /* dl_accept will "do the right thing" with the last two parms, but */
  /* for now it ignores them, so we will pass zeros. */

  if(dl_accept(data_descriptor, 0, 0) != 0) {
    fprintf(where,
	    "recv_dlpi_co_stream: error in accept, errno %d\n",
	    errno);
    fflush(where);
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  if (debug) {
    fprintf(where,"netserver:recv_dlpi_co_stream: connection accepted\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(dlpi_co_stream_request->measure_cpu);

#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 = dlpi_co_stream_request->dirty_count;
  clean_count = dlpi_co_stream_request->clean_count;
  message_int_ptr = (int *)message_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 */

  recv_message.len = recv_size;
  while (recv_message.len == recv_size) {
    if (getmsg(data_descriptor,
	       0,
	       &recv_message,
	       &flags) != 0) {
      netperf_response.content.serv_errno = errno;
      send_response();
      exit(1);
    }
    bytes_received += recv_message.len;
    receive_calls++;

    if (debug) {
      fprintf(where,
	      "netserver:recv_dlpi_co_stream: getmsg accepted %d bytes\n",
	      recv_message.len);
      fflush(where);
    }


#ifdef DIRTY
    message_int_ptr = (int *)message_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. */
  /* should perform a disconnect to signal the sender that */
  /* we have received all the data sent. */

  if (close(data_descriptor) == -1) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  cpu_stop(dlpi_co_stream_request->measure_cpu,&elapsed_time);

  /* send the results to the sender			*/

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

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

  if (dlpi_co_stream_request->measure_cpu) {
    dlpi_co_stream_results->cpu_util	= calc_cpu_util(0.0);
  };

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

  send_response();
}

/*********************************/

int send_dlpi_co_rr(char remote_host[])
{

  char *tput_title = "\
 Local /Remote\n\
 Window Size   Request  Resp.   Elapsed  Trans.\n\
 Send   Recv   Size     Size    Time     Rate         \n\
 frames frames 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\
 Window Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
 Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
 frames frames 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	    dlsap_len;
  char      dlsap[BUFSIZ];

  int   flags = 0;
  char	*send_message_ptr;
  char	*recv_message_ptr;
  char	*temp_message_ptr;
  struct strbuf send_message;
  struct strbuf recv_message;

  int	nummessages;
  int	send_descriptor;
  int	trans_remaining;
  double	bytes_xferd;

  int	rsp_bytes_left;

  /* we assume that station adresses fit within two ints */
  unsigned int   remote_address[1];

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

  struct	dlpi_co_rr_request_struct	*dlpi_co_rr_request;
  struct	dlpi_co_rr_response_struct	*dlpi_co_rr_response;
  struct	dlpi_co_rr_results_struct	*dlpi_co_rr_result;

  dlpi_co_rr_request	=
    (struct dlpi_co_rr_request_struct *)netperf_request.content.test_specific_data;
  dlpi_co_rr_response	=
    (struct dlpi_co_rr_response_struct *)netperf_response.content.test_specific_data;
  dlpi_co_rr_result	=
    (struct dlpi_co_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. */

  if ( print_headers ) {
    fprintf(where,"DLPI CO 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 */
  temp_message_ptr = (char *)malloc(req_size+MAXALIGNMENT+MAXOFFSET);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", req_size+MAXALIGNMENT+MAXOFFSET);
    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;
  send_message.maxlen = req_size+MAXALIGNMENT+MAXOFFSET;
  send_message.len    = req_size;
  send_message.buf    = send_message_ptr;

  temp_message_ptr = (char *)malloc(rsp_size+MAXALIGNMENT+MAXOFFSET);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", rsp_size+MAXALIGNMENT+MAXOFFSET);
    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;
  recv_message.maxlen = rsp_size+MAXALIGNMENT+MAXOFFSET;
  recv_message.len    = 0;
  recv_message.buf    = send_message_ptr;

  /*set up the data socket                        */

  send_descriptor = dl_open(loc_dlpi_device,loc_ppa);
  if (send_descriptor < 0){
    perror("netperf: send_dlpi_co_rr: tcp stream data descriptor");
    exit(1);
  }

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

  /* bind the puppy and get the assigned dlsap */

  dlsap_len = BUFSIZ;
  if (dl_bind(send_descriptor,
	      dlpi_sap, DL_CODLS, dlsap, &dlsap_len) != 0) {
    fprintf(where,"send_dlpi_co_rr: bind failure\n");
    fflush(where);
    exit(1);
  }

  /* 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 TCP no-no. Also, by setting the */
  /* buffer (window) size before the connection is established, we can */
  /* control the TCP 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.  */

#ifdef DL_HP_SET_LOCAL_WIN_REQ
  if (lsw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_co_rr: socket send size altered from system default...\n");
      fprintf(where,"                          send: %d\n",lsw_size);
    }
  }
  if (lrw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_co_rr: socket recv size altered from system default...\n");
      fprintf(where,"                          recv: %d\n",lrw_size);
    }
  }


  /* Now, we will find-out what the size actually became, and report */
  /* that back to the user. If the call fails, we will just report a -1 */
  /* back to the initiator for the recv buffer size. */


  if (debug) {
    fprintf(where,"netperf: send_dlpi_co_rr: socket sizes determined...\n");
    fprintf(where,"         send: %d recv: %d\n",lsw_size,lrw_size);
  }

#else /* DL_HP_SET_LOCAL_WIN_REQ */

  lsw_size = -1;
  lrw_size = -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* 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_DLPI_CO_RR;
  dlpi_co_rr_request->recv_win_size	=	rrw_size;
  dlpi_co_rr_request->send_win_size	=	rsw_size;
  dlpi_co_rr_request->recv_alignment	=	remote_recv_align;
  dlpi_co_rr_request->recv_offset	=	remote_recv_offset;
  dlpi_co_rr_request->send_alignment	=	remote_send_align;
  dlpi_co_rr_request->send_offset	=	remote_send_offset;
  dlpi_co_rr_request->request_size	=	req_size;
  dlpi_co_rr_request->response_size	=	rsp_size;
  dlpi_co_rr_request->measure_cpu	=	remote_cpu_usage;
  dlpi_co_rr_request->cpu_rate	        =	remote_cpu_rate;
  dlpi_co_rr_request->ppa               =       rem_ppa;
  dlpi_co_rr_request->sap               =       dlpi_sap;
  dlpi_co_rr_request->dev_name_len      =       strlen(rem_dlpi_device);
  strcpy(dlpi_co_rr_request->dlpi_device,
	 rem_dlpi_device);
#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_co_rr_request->dlpi_device;
    lastword = initword + ((strlen(rem_dlpi_device) + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = ntohl(*charword);
    }
  }
#endif /* __alpha */

  if (test_time) {
    dlpi_co_rr_request->test_length	=	test_time;
  }
  else {
    dlpi_co_rr_request->test_length	=	test_trans * -1;
  }

  if (debug > 1) {
    fprintf(where,"netperf: send_dlpi_co_rr: requesting TCP 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 TCP tests.					*/

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rrw_size	=	dlpi_co_rr_response->recv_win_size;
    rsw_size	=	dlpi_co_rr_response->send_win_size;
    remote_cpu_usage=	dlpi_co_rr_response->measure_cpu;
    remote_cpu_rate = 	dlpi_co_rr_response->cpu_rate;

  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");

    exit(1);
  }

  /*Connect up to the remote port on the data descriptor  */

  if(dl_connect(send_descriptor,
		dlpi_co_rr_response->station_addr,
		dlpi_co_rr_response->station_addr_len) != 0) {
    fprintf(where,"send_dlpi_co_rr: connect failure\n");
    fflush(where);
    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 */
    if((putmsg(send_descriptor,
	       0,
	       &send_message,
	       0)) != 0) {
      if (errno == EINTR) {
	/* we hit the end of a */
	/* timed test. */
	timed_out = 1;
	break;
      }
      perror("send_dlpi_co_rr: putmsg error");
      exit(1);
    }

    if (debug) {
      fprintf(where,"recv_message.len %d\n",recv_message.len);
      fprintf(where,"send_message.len %d\n",send_message.len);
      fflush(where);
    }

    /* receive the response */
    /* this needs some work with streams buffers if we are going to */
    /* support requests and responses larger than the MTU of the */
    /* network, but this can wait until later */
    rsp_bytes_left = rsp_size;
    recv_message.len = rsp_size;
    while(rsp_bytes_left > 0) {
      if((getmsg(send_descriptor,
		 0,
		 &recv_message,
		 &flags)) < 0) {
	if (errno == EINTR) {
	  /* We hit the end of a timed test. */
	  timed_out = 1;
	  break;
	}
	perror("send_dlpi_co_rr: data recv error");
	exit(1);
      }
      rsp_bytes_left -= recv_message.len;
    }

    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 onthe 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 TCP 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 TCP 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 = dlpi_co_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,
						  dlpi_co_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 */
	      lsw_size,		/* local sendbuf size */
	      lrw_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,
	      rsw_size,
	      rrw_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 */
	      lsw_size,
	      lrw_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,
	      rsw_size, 		/* remote recvbuf size */
	      rrw_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 */
    /* TCP statistics, the alignments of the sends and receives */
    /* and all that sort of rot... */

    fprintf(where,
	    ksink_fmt);
  }
  /* The test is over. Kill the data descriptor */

  if (close(send_descriptor) == -1) {
    perror("send_dlpi_co_rr: cannot shutdown tcp stream descriptor");
  }

}

void
  send_dlpi_cl_stream(char remote_host[])
{
  /************************************************************************/
  /*									*/
  /*               	UDP Unidirectional Send Test                    */
  /*									*/
  /************************************************************************/
  char *tput_title =
    "Window  Message  Elapsed      Messages                \n\
Size    Size     Time         Okay Errors   Throughput\n\
frames  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 =
    "Window  Message  Elapsed      Messages                   CPU     Service\n\
Size    Size     Time         Okay Errors   Throughput   Util    Demand\n\
frames  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	*message_int_ptr;
  char	*message_ptr;
  char	*message;
  char  sctl_data[BUFSIZ];
  struct strbuf send_message;
  struct strbuf sctl_message;
  dl_unitdata_req_t *data_req = (dl_unitdata_req_t *)sctl_data;

  char dlsap[BUFSIZ];
  int  dlsap_len;
  int	message_offset;
  int	message_max_offset;
  int	failed_sends;
  int	failed_cows;
  int 	messages_sent;
  int 	data_descriptor;


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

  struct	dlpi_cl_stream_request_struct	*dlpi_cl_stream_request;
  struct	dlpi_cl_stream_response_struct	*dlpi_cl_stream_response;
  struct	dlpi_cl_stream_results_struct	*dlpi_cl_stream_results;

  dlpi_cl_stream_request	= (struct dlpi_cl_stream_request_struct *)netperf_request.content.test_specific_data;
  dlpi_cl_stream_response	= (struct dlpi_cl_stream_response_struct *)netperf_response.content.test_specific_data;
  dlpi_cl_stream_results	= (struct dlpi_cl_stream_results_struct *)netperf_response.content.test_specific_data;

  if ( print_headers ) {
    printf("DLPI CL 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;
  messages_sent	= 0;
  times_up	= 0;

  /*set up the data descriptor			*/

  data_descriptor = dl_open(loc_dlpi_device,loc_ppa);
  if (data_descriptor < 0){
    perror("send_dlpi_cl_stream: data descriptor");
    exit(1);
  }

  /* bind the puppy and get the assigned dlsap */
  dlsap_len = BUFSIZ;
  if (dl_bind(data_descriptor,
              dlpi_sap, DL_CLDLS, dlsap, &dlsap_len) != 0) {
    fprintf(where,"send_dlpi_cl_stream: bind failure\n");
    fflush(where);
    exit(1);
  }

  /* Modify the local socket size (SNDBUF size)    */

#ifdef DL_HP_SET_LOCAL_WIN_REQ
  if (lsw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_cl_stream: descriptor send size altered from system default...\n");
      fprintf(where,"                          send: %d\n",lsw_size);
    }
  }
  if (lrw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_cl_stream: descriptor recv size altered from system default...\n");
      fprintf(where,"                          recv: %d\n",lrw_size);
    }
  }


  /* Now, we will find-out what the size actually became, and report */
  /* that back to the user. If the call fails, we will just report a -1 */
  /* back to the initiator for the recv buffer size. */

#else /* DL_HP_SET_LOCAL_WIN_REQ */

  lsw_size = -1;
  lrw_size = -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* now, we want to see if we need to set the send_size */
  if (send_size == 0) {
    send_size = 1024;
  }


  /* 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;
  message = (char *)malloc(send_size * (send_width + 1) + local_send_align + local_send_offset);
  if (message == NULL) {
    printf("malloc(%d) failed!\n", send_size * (send_width + 1) + local_send_align + local_send_offset);
    exit(1);
  }
  message_ptr = (char *)(( (long) message +
			  (long) local_send_align - 1) &
			 ~((long) local_send_align - 1));
  message_ptr = message_ptr + local_send_offset;
  message = message_ptr;
  send_message.maxlen = send_size;
  send_message.len = send_size;
  send_message.buf = message;

  sctl_message.maxlen = BUFSIZ;
  sctl_message.len    = 0;
  sctl_message.buf    = sctl_data;

  /* 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_DLPI_CL_STREAM;
  dlpi_cl_stream_request->recv_win_size	        = rrw_size;
  dlpi_cl_stream_request->message_size	        = send_size;
  dlpi_cl_stream_request->recv_alignment	= remote_recv_align;
  dlpi_cl_stream_request->recv_offset		= remote_recv_offset;
  dlpi_cl_stream_request->measure_cpu		= remote_cpu_usage;
  dlpi_cl_stream_request->cpu_rate		= remote_cpu_rate;
  dlpi_cl_stream_request->ppa                   = rem_ppa;
  dlpi_cl_stream_request->sap                   = dlpi_sap;
  dlpi_cl_stream_request->dev_name_len          = strlen(rem_dlpi_device);
  strcpy(dlpi_cl_stream_request->dlpi_device,
	 rem_dlpi_device);

#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_cl_stream_request->dlpi_device;
    lastword = initword + ((strlen(rem_dlpi_device) + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = ntohl(*charword);
    }
  }
#endif /* __alpha */

  if (test_time) {
    dlpi_cl_stream_request->test_length	=	test_time;
  }
  else {
    dlpi_cl_stream_request->test_length	=	test_bytes * -1;
  }


  send_request();

  recv_response();

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

  /* place some of the remote's addressing information into the send */
  /* structure so our sends can be sent to the correct place. Also get */
  /* some of the returned socket buffer information for user display. */

  /* set-up the destination addressing control info */
  data_req->dl_primitive = DL_UNITDATA_REQ;
  bcopy((char *)(dlpi_cl_stream_response->station_addr),
	((char *)data_req + sizeof(dl_unitdata_req_t)),
	dlpi_cl_stream_response->station_addr_len);
  data_req->dl_dest_addr_offset = sizeof(dl_unitdata_req_t);
  data_req->dl_dest_addr_length = dlpi_cl_stream_response->station_addr_len;
  /* there is a dl_priority structure too, but I am ignoring it for */
  /* the time being. */
  /* however... it is best to put some value in there lest some code
     get grumpy about it - fix from Nicolas Thomas */
  data_req->dl_priority.dl_min = DL_QOS_DONT_CARE;
  data_req->dl_priority.dl_max = DL_QOS_DONT_CARE;

  sctl_message.len = sizeof(dl_unitdata_req_t) +
    data_req->dl_dest_addr_length;

  rrw_size	        = dlpi_cl_stream_response->recv_win_size;
  rsw_size	        = dlpi_cl_stream_response->send_win_size;
  remote_cpu_rate	= dlpi_cl_stream_response->cpu_rate;


  /* 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 /* WANT_INTERVALS */

  /* Send datagrams like there was no tomorrow */
  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 *)message_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 (putmsg(data_descriptor,
	       &sctl_message,
	       &send_message,
	       0)  != 0) {
      if (errno == EINTR) {
	break;
      }
      if (errno == ENOBUFS) {
	/* we might not ever hit this with STREAMS, it would probably */
	/* be better to do a getinfo request at the end of the test to */
	/* get all sorts of gory statistics. in the meantime, we will */
	/* keep this code in place. */
	failed_sends++;
	continue;
      }
      perror("send_dlpi_cl_stream: data send error");
      if (debug) {
	fprintf(where,"messages_sent %u\n",messages_sent);
	fflush(where);
      }
      exit(1);
    }
    messages_sent++;

    /* now we want to move our pointer to the next position in the */
    /* data buffer...since there was a successful send */


#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 /* WANT_INTERVALS */

  }

  /* 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_dlpi_cl_stream: remote results obtained\n");
  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("send_dlpi_cl_stream: error on remote");
    exit(1);
  }

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

  messages_recvd	= dlpi_cl_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 descriptor 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	= dlpi_cl_stream_results->cpu_util;
      remote_service_demand	= calc_service_demand(bytes_recvd,
						      0.0,
						      remote_cpu_utilization,
						      dlpi_cl_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 */
	      lsw_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 */
	      rrw_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 */
	      lsw_size, 		/* local sendbuf size */
	      send_size,		/* how large were the sends */
	      elapsed_time, 		/* how long did it take */
	      messages_sent,
	      failed_sends,
	      local_thruput,
	      rrw_size, 		/* remote recvbuf size */
	      elapsed_time,
	      messages_recvd,
	      remote_thruput
	      );
      break;
    }
  }
}

int
  recv_dlpi_cl_stream()
{

  char  *message;
  int	data_descriptor;
  int	len;
  char	*message_ptr;
  char  rctl_data[BUFSIZ];
  struct strbuf recv_message;
  struct strbuf rctl_message;
  int flags = 0;
  /* these are to make reading some of the DLPI control messages easier */
  dl_unitdata_ind_t *data_ind = (dl_unitdata_ind_t *)rctl_data;
  dl_uderror_ind_t  *uder_ind = (dl_uderror_ind_t *)rctl_data;

  int	bytes_received = 0;
  float	elapsed_time;

  int	message_size;
  int	messages_recvd = 0;
  int	measure_cpu;

  struct	dlpi_cl_stream_request_struct	*dlpi_cl_stream_request;
  struct	dlpi_cl_stream_response_struct	*dlpi_cl_stream_response;
  struct	dlpi_cl_stream_results_struct	*dlpi_cl_stream_results;

  dlpi_cl_stream_request	= (struct dlpi_cl_stream_request_struct *)netperf_request.content.test_specific_data;
  dlpi_cl_stream_response	= (struct dlpi_cl_stream_response_struct *)netperf_response.content.test_specific_data;
  dlpi_cl_stream_results	= (struct dlpi_cl_stream_results_struct *)netperf_response.content.test_specific_data;

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

  /* We want to set-up the listen descriptor 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_dlpi_cl_stream: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = DLPI_CL_STREAM_RESPONSE;

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

  /* set-up the data buffer with the requested alignment and offset */
  message = (char *)malloc(DATABUFFERLEN);
  if (message == NULL) {
    printf("malloc(%d) failed!\n", DATABUFFERLEN);
    exit(1);
  }

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

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

  message_ptr = ALIGN_BUFFER(message, dlpi_cl_stream_request->recv_alignment, dlpi_cl_stream_request->recv_offset);

  if (dlpi_cl_stream_request->message_size > 0) {
    recv_message.maxlen = dlpi_cl_stream_request->message_size;
  }
  else {
    recv_message.maxlen = 4096;
  }
  recv_message.len    = 0;
  recv_message.buf    = message_ptr;

  rctl_message.maxlen = BUFSIZ;
  rctl_message.len    = 0;
  rctl_message.buf    = rctl_data;

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

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

#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_cl_stream_request->dlpi_device;
    lastword = initword + ((dlpi_cl_stream_request->dev_name_len + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = htonl(*charword);
    }
  }
#endif /* __alpha */

  data_descriptor = dl_open(dlpi_cl_stream_request->dlpi_device,
			    dlpi_cl_stream_request->ppa);
  if (data_descriptor < 0) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  /* The initiator may have wished-us to modify the window */
  /* sizes. We should give it a shot. If he didn't ask us to change the */
  /* sizes, we should let him know what sizes were in use at this end. */
  /* If none of this code is compiled-in, then we will tell the */
  /* initiator that we were unable to play with the sizes by */
  /* setting the size in the response to -1. */

#ifdef DL_HP_SET_LOCAL_WIN_REQ

  if (dlpi_cl_stream_request->recv_win_size) {
    dlpi_cl_stream_response->recv_win_size	= -1;
  }

#else /* the system won't let us play with the buffers */

  dlpi_cl_stream_response->recv_win_size	= -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  dlpi_cl_stream_response->test_length = dlpi_cl_stream_request->test_length;

  /* bind the sap and retrieve the dlsap assigned by the system  */
  dlpi_cl_stream_response->station_addr_len = 14; /* arbitrary */
  if (dl_bind(data_descriptor,
	      dlpi_cl_stream_request->sap,
	      DL_CLDLS,
	      (char *)dlpi_cl_stream_response->station_addr,
	      &dlpi_cl_stream_response->station_addr_len) != 0) {
    fprintf(where,"send_dlpi_cl_stream: bind failure\n");
    fflush(where);
    exit(1);
  }

  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. */

  dlpi_cl_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
  if (dlpi_cl_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... */
    dlpi_cl_stream_response->measure_cpu = 1;
    dlpi_cl_stream_response->cpu_rate = calibrate_local_cpu(dlpi_cl_stream_request->cpu_rate);
  }

  message_size	= dlpi_cl_stream_request->message_size;
  test_time	= dlpi_cl_stream_request->test_length;

  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(dlpi_cl_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_dlpi_cl_stream: about to enter inner sanctum.\n");
    fflush(where);
  }

  while (!times_up) {
    if((getmsg(data_descriptor,
	       &rctl_message,
	       &recv_message,
	       &flags) != 0) ||
       (data_ind->dl_primitive != DL_UNITDATA_IND)) {
      if (errno == EINTR) {
	/* Again, we have likely hit test-end time */
	break;
      }
      fprintf(where,
	      "dlpi_recv_cl_stream: getmsg failure: errno %d primitive 0x%x\n",
	      errno,
	      data_ind->dl_primitive);
      fflush(where);
      netperf_response.content.serv_errno = 996;
      send_response();
      exit(1);
    }
    messages_recvd++;
  }

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


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

  cpu_stop(dlpi_cl_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_dlpi_cl_stream: test ended in %f seconds.\n",elapsed_time);
    fflush(where);
  }


  /* We will count the "off" message */
  bytes_received = (messages_recvd * message_size) + len;

  /* send the results to the sender			*/

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

  netperf_response.content.response_type		= DLPI_CL_STREAM_RESULTS;
  dlpi_cl_stream_results->bytes_received	= bytes_received;
  dlpi_cl_stream_results->messages_recvd	= messages_recvd;
  dlpi_cl_stream_results->elapsed_time	= elapsed_time;
  if (dlpi_cl_stream_request->measure_cpu) {
    dlpi_cl_stream_results->cpu_util	= calc_cpu_util(elapsed_time);
  }
  else {
    dlpi_cl_stream_results->cpu_util	= -1.0;
  }

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

  send_response();

}

int send_dlpi_cl_rr(char remote_host[])
{

  char *tput_title = "\
Local /Remote\n\
Window Size   Request  Resp.   Elapsed  Trans.\n\
Send   Recv   Size     Size    Time     Rate         \n\
frames frames 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\
Window Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
frames frames 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";


  float			elapsed_time;

  int   dlsap_len;
  int   flags = 0;
  char	*send_message_ptr;
  char	*recv_message_ptr;
  char	*temp_message_ptr;
  char  sctl_data[BUFSIZ];
  char  rctl_data[BUFSIZ];
  char  dlsap[BUFSIZ];
  struct strbuf send_message;
  struct strbuf recv_message;
  struct strbuf sctl_message;
  struct strbuf rctl_message;

  /* these are to make reading some of the DLPI control messages easier */
  dl_unitdata_ind_t *data_ind = (dl_unitdata_ind_t *)rctl_data;
  dl_unitdata_req_t *data_req = (dl_unitdata_req_t *)sctl_data;
  dl_uderror_ind_t  *uder_ind = (dl_uderror_ind_t *)rctl_data;

  int	nummessages;
  int	send_descriptor;
  int	trans_remaining;
  int	bytes_xferd;

  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 /* WANT_INTERVALS */

  struct	dlpi_cl_rr_request_struct	*dlpi_cl_rr_request;
  struct	dlpi_cl_rr_response_struct	*dlpi_cl_rr_response;
  struct	dlpi_cl_rr_results_struct	*dlpi_cl_rr_result;

  dlpi_cl_rr_request	=
    (struct dlpi_cl_rr_request_struct *)netperf_request.content.test_specific_data;
  dlpi_cl_rr_response	=
    (struct dlpi_cl_rr_response_struct *)netperf_response.content.test_specific_data;
  dlpi_cl_rr_result	=
    (struct dlpi_cl_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 /* WANT_INTERVALS */

  if (print_headers) {
    fprintf(where,"DLPI CL 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(req_size+MAXALIGNMENT+MAXOFFSET);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", req_size+MAXALIGNMENT+MAXOFFSET);
    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;
  send_message.maxlen = req_size;
  send_message.len    = req_size;
  send_message.buf    = send_message_ptr;

  temp_message_ptr = (char *)malloc(rsp_size+MAXALIGNMENT+MAXOFFSET);
  if (temp_message_ptr == NULL) {
    printf("malloc(%d) failed!\n", rsp_size+MAXALIGNMENT+MAXOFFSET);
    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;
  recv_message.maxlen = rsp_size;
  recv_message.len    = 0;
  recv_message.buf    = recv_message_ptr;

  sctl_message.maxlen = BUFSIZ;
  sctl_message.len    = 0;
  sctl_message.buf    = sctl_data;

  rctl_message.maxlen = BUFSIZ;
  rctl_message.len    = 0;
  rctl_message.buf    = rctl_data;

  /* lets get ourselves a file descriptor */

  send_descriptor = dl_open(loc_dlpi_device,loc_ppa);
  if (send_descriptor < 0){
    perror("netperf: send_dlpi_cl_rr: dlpi cl rr send descriptor");
    exit(1);
  }

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

  /* bind the sap to the descriptor and get the dlsap */
  dlsap_len = BUFSIZ;
  if (dl_bind(send_descriptor,
	      dlpi_sap,
	      DL_CLDLS,
	      dlsap,
	      &dlsap_len) != 0) {
    fprintf(where,"send_dlpi_cl_rr: bind failure\n");
    fflush(where);
    exit(1);
  }

  /* Modify the local socket size. 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.  The receive socket */
  /* must have enough space to hold addressing information so += a */
  /* sizeof struct sockaddr_in to it. */

  /* this is actually nothing code, and should be replaced with the */
  /* alalagous calls in the STREAM test where the window size is set */
  /* with the HP DLPI Extension. raj 8/94 */
#ifdef SO_SNDBUF
  if (lsw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_cl_rr: local window size altered from system default...\n");
      fprintf(where,"                          window: %d\n",lsw_size);
    }
  }
  if (lrw_size > 0) {
    if (debug > 1) {
      fprintf(where,"netperf: send_dlpi_cl_rr: remote window size altered from system default...\n");
      fprintf(where,"                          remote: %d\n",lrw_size);
    }
  }


  /* Now, we will find-out what the size actually became, and report */
  /* that back to the user. If the call fails, we will just report a -1 */
  /* back to the initiator for the recv buffer size. */

  if (debug) {
    fprintf(where,"netperf: send_dlpi_cl_rr: socket sizes determined...\n");
    fprintf(where,"         send: %d recv: %d\n",lsw_size,lrw_size);
  }

#else /* SO_SNDBUF */

  lsw_size = -1;
  lrw_size = -1;

#endif /* SO_SNDBUF */

  /* 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_DLPI_CL_RR;
  dlpi_cl_rr_request->recv_win_size	=	rrw_size;
  dlpi_cl_rr_request->send_win_size	=	rsw_size;
  dlpi_cl_rr_request->recv_alignment	=	remote_recv_align;
  dlpi_cl_rr_request->recv_offset	=	remote_recv_offset;
  dlpi_cl_rr_request->send_alignment	=	remote_send_align;
  dlpi_cl_rr_request->send_offset	=	remote_send_offset;
  dlpi_cl_rr_request->request_size	=	req_size;
  dlpi_cl_rr_request->response_size	=	rsp_size;
  dlpi_cl_rr_request->measure_cpu	=	remote_cpu_usage;
  dlpi_cl_rr_request->cpu_rate	        =	remote_cpu_rate;
  dlpi_cl_rr_request->ppa               =       rem_ppa;
  dlpi_cl_rr_request->sap               =       dlpi_sap;
  dlpi_cl_rr_request->dev_name_len      =       strlen(rem_dlpi_device);
  strcpy(dlpi_cl_rr_request->dlpi_device,
	 rem_dlpi_device);

#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_cl_rr_request->dlpi_device;
    lastword = initword + ((strlen(rem_dlpi_device) + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = ntohl(*charword);
    }
  }
#endif /* __alpha */

  if (test_time) {
    dlpi_cl_rr_request->test_length	=	test_time;
  }
  else {
    dlpi_cl_rr_request->test_length	=	test_trans * -1;
  }

  if (debug > 1) {
    fprintf(where,"netperf: send_dlpi_cl_rr: requesting DLPI CL 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 tests.                                          */

  recv_response();

  if (!netperf_response.content.serv_errno) {
    if (debug)
      fprintf(where,"remote listen done.\n");
    rrw_size	=	dlpi_cl_rr_response->recv_win_size;
    rsw_size	=	dlpi_cl_rr_response->send_win_size;
    remote_cpu_usage=	dlpi_cl_rr_response->measure_cpu;
    remote_cpu_rate = 	dlpi_cl_rr_response->cpu_rate;

    /* set-up the destination addressing control info */
    data_req->dl_primitive = DL_UNITDATA_REQ;
    bcopy((char *)(dlpi_cl_rr_response->station_addr),
	  ((char *)data_req + sizeof(dl_unitdata_req_t)),
	  dlpi_cl_rr_response->station_addr_len);
    data_req->dl_dest_addr_offset = sizeof(dl_unitdata_req_t);
    data_req->dl_dest_addr_length = dlpi_cl_rr_response->station_addr_len;
    /* there is a dl_priority structure too, but I am ignoring it for */
    /* the time being. */
    sctl_message.len = sizeof(dl_unitdata_req_t) +
      data_req->dl_dest_addr_length;
    /* famous last words - some DLPI providers get unhappy if the
       priority stuff is not initialized.  fix from Nicolas Thomas. */
    data_req->dl_priority.dl_min = DL_QOS_DONT_CARE;
    data_req->dl_priority.dl_max = DL_QOS_DONT_CARE;

  }
  else {
    Set_errno(netperf_response.content.serv_errno);
    perror("netperf: remote error");
    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 /* WANT_INTERVALS */
    if(putmsg(send_descriptor,
	      &sctl_message,
	      &send_message,
	      0) != 0) {
      if (errno == EINTR) {
	/* We likely hit */
	/* test-end time. */
	break;
      }
      /* there is more we could do here, but it can wait */
      perror("send_dlpi_cl_rr: data send error");
      exit(1);
    }

    /* receive the response. at some point, we will need to handle */
    /* sending responses which are greater than the datalink MTU. we */
    /* may also want to add some DLPI error checking, but for now we */
    /* will ignore that and just let errors stop the test with little */
    /* indication of what might actually be wrong. */

    if((getmsg(send_descriptor,
	       &rctl_message,
	       &recv_message,
	       &flags) != 0) ||
       (data_ind->dl_primitive != DL_UNITDATA_IND)) {
      if (errno == EINTR) {
	/* Again, we have likely hit test-end time */
	break;
      }
      fprintf(where,
	      "send_dlpi_cl_rr: recv error: errno %d primitive 0x%x\n",
	      errno,
	      data_ind->dl_primitive);
      fflush(where);
      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 /* WANT_INTERVALS */
    nummessages++;
    if (trans_remaining) {
      trans_remaining--;
    }

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

  }

  /* 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 UDP 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 = dlpi_cl_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,
						   dlpi_cl_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 */
	      lsw_size,		/* local sendbuf size */
	      lrw_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,
	      rsw_size,
	      rrw_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 */
	      lsw_size,
	      lrw_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,
	      rsw_size, 		/* remote recvbuf size */
	      rrw_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 */
    /* UDP 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
  }
}

int
  recv_dlpi_cl_rr()
{

  char  *message;
  int	data_descriptor;
  int   flags = 0;
  int	measure_cpu;

  char	*recv_message_ptr;
  char	*send_message_ptr;
  char  sctl_data[BUFSIZ];
  char  rctl_data[BUFSIZ];
  char  dlsap[BUFSIZ];
  struct strbuf send_message;
  struct strbuf recv_message;
  struct strbuf sctl_message;
  struct strbuf rctl_message;

  /* these are to make reading some of the DLPI control messages easier */
  dl_unitdata_ind_t *data_ind = (dl_unitdata_ind_t *)rctl_data;
  dl_unitdata_req_t *data_req = (dl_unitdata_req_t *)sctl_data;
  dl_uderror_ind_t  *uder_ind = (dl_uderror_ind_t *)rctl_data;

  int	trans_received;
  int	trans_remaining;
  float	elapsed_time;

  struct	dlpi_cl_rr_request_struct	*dlpi_cl_rr_request;
  struct	dlpi_cl_rr_response_struct	*dlpi_cl_rr_response;
  struct	dlpi_cl_rr_results_struct	*dlpi_cl_rr_results;

  dlpi_cl_rr_request  =
    (struct dlpi_cl_rr_request_struct *)netperf_request.content.test_specific_data;
  dlpi_cl_rr_response =
    (struct dlpi_cl_rr_response_struct *)netperf_response.content.test_specific_data;
  dlpi_cl_rr_results  =
    (struct dlpi_cl_rr_results_struct *)netperf_response.content.test_specific_data;

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

  /* We want to set-up the listen descriptor 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 descriptor 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_dlpi_cl_rr: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = DLPI_CL_RR_RESPONSE;

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

  /* set-up the data buffer with the requested alignment and offset */
  message = (char *)malloc(DATABUFFERLEN);
  if (message == NULL) {
    printf("malloc(%d) failed!\n", DATABUFFERLEN);
    exit(1);
  }

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

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

  recv_message_ptr = ALIGN_BUFFER(message, dlpi_cl_rr_request->recv_alignment, dlpi_cl_rr_request->recv_offset);
  recv_message.maxlen = dlpi_cl_rr_request->request_size;
  recv_message.len    = 0;
  recv_message.buf    = recv_message_ptr;

  send_message_ptr = ALIGN_BUFFER(message, dlpi_cl_rr_request->send_alignment, dlpi_cl_rr_request->send_offset);
  send_message.maxlen = dlpi_cl_rr_request->response_size;
  send_message.len    = dlpi_cl_rr_request->response_size;
  send_message.buf    = send_message_ptr;

  sctl_message.maxlen = BUFSIZ;
  sctl_message.len    = 0;
  sctl_message.buf    = sctl_data;

  rctl_message.maxlen = BUFSIZ;
  rctl_message.len    = 0;
  rctl_message.buf    = rctl_data;

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


#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_cl_rr_request->dlpi_device;
    lastword = initword + ((dlpi_cl_rr_request->dev_name_len + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = htonl(*charword);
    }
  }
#endif /* __alpha */

  data_descriptor = dl_open(dlpi_cl_rr_request->dlpi_device,
			    dlpi_cl_rr_request->ppa);
  if (data_descriptor < 0) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }


  /* The initiator may have wished-us to modify the window */
  /* sizes. We should give it a shot. If he didn't ask us to change the */
  /* sizes, we should let him know what sizes were in use at this end. */
  /* If none of this code is compiled-in, then we will tell the */
  /* initiator that we were unable to play with the sizes by */
  /* setting the size in the response to -1. */

#ifdef DL_HP_SET_LOCAL_WIN_REQ

  if (dlpi_cl_rr_request->recv_win_size) {
  }

  if (dlpi_cl_rr_request->send_win_size) {
  }

  /* Now, we will find-out what the sizes actually became, and report */
  /* them back to the user. If the calls fail, we will just report a -1 */
  /* back to the initiator for the buffer size. */

#else /* the system won't let us play with the buffers */

  dlpi_cl_rr_response->recv_win_size	= -1;
  dlpi_cl_rr_response->send_win_size	= -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* bind the sap and retrieve the dlsap assigned by the system  */
  dlpi_cl_rr_response->station_addr_len = 14; /* arbitrary */
  if (dl_bind(data_descriptor,
	      dlpi_cl_rr_request->sap,
	      DL_CLDLS,
	      (char *)dlpi_cl_rr_response->station_addr,
	      &dlpi_cl_rr_response->station_addr_len) != 0) {
    fprintf(where,"send_dlpi_cl_rr: bind failure\n");
    fflush(where);
    exit(1);
  }

  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. */

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

  send_response();

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

  cpu_start(dlpi_cl_rr_request->measure_cpu);

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

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

    /* receive the request from the other side. at some point we need */
    /* to handle "logical" requests and responses which are larger */
    /* than the data link MTU */

    if((getmsg(data_descriptor,
	       &rctl_message,
	       &recv_message,
	       &flags) != 0) ||
       (data_ind->dl_primitive != DL_UNITDATA_IND)) {
      if (errno == EINTR) {
	/* Again, we have likely hit test-end time */
	break;
      }
      fprintf(where,
	      "dlpi_recv_cl_rr: getmsg failure: errno %d primitive 0x%x\n",
	      errno,
	      data_ind->dl_primitive);
      fprintf(where,
	      "                 recevied %u transactions\n",
	      trans_received);
      fflush(where);
      netperf_response.content.serv_errno = 995;
      send_response();
      exit(1);
    }

    /* Now, send the response to the remote. first copy the dlsap */
    /* information from the receive to the sending control message */

    data_req->dl_dest_addr_offset = sizeof(dl_unitdata_req_t);
    bcopy((char *)data_ind + data_ind->dl_src_addr_offset,
	  (char *)data_req + data_req->dl_dest_addr_offset,
	  data_ind->dl_src_addr_length);
    data_req->dl_dest_addr_length = data_ind->dl_src_addr_length;
    data_req->dl_primitive = DL_UNITDATA_REQ;
    /* be sure to initialize the priority fields. fix from Nicholas
       Thomas */
    data_req->dl_priority.dl_min = DL_QOS_DONT_CARE;
    data_req->dl_priority.dl_max = DL_QOS_DONT_CARE;

    sctl_message.len = sizeof(dl_unitdata_req_t) +
      data_ind->dl_src_addr_length;
    if(putmsg(data_descriptor,
	      &sctl_message,
	      &send_message,
	      0) != 0) {
      if (errno == EINTR) {
	/* We likely hit */
	/* test-end time. */
	break;
      }
      /* there is more we could do here, but it can wait */
      fprintf(where,
	      "dlpi_recv_cl_rr: putmsg failure: errno %d\n",
	      errno);
      fflush(where);
      netperf_response.content.serv_errno = 993;
      send_response();
      exit(1);
    }

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

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

  }


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

  cpu_stop(dlpi_cl_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_dlpi_cl_rr: got %d transactions\n",
	    trans_received);
    fflush(where);
  }

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

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

  send_response();

}

int
  recv_dlpi_co_rr()
{

  char  *message;
  SOCKET	s_listen,data_descriptor;

  int	measure_cpu;

  int   flags = 0;
  char	*recv_message_ptr;
  char	*send_message_ptr;
  struct strbuf send_message;
  struct strbuf recv_message;

  int	trans_received;
  int	trans_remaining;
  int	request_bytes_remaining;
  int	timed_out = 0;
  float	elapsed_time;

  struct	dlpi_co_rr_request_struct	*dlpi_co_rr_request;
  struct	dlpi_co_rr_response_struct	*dlpi_co_rr_response;
  struct	dlpi_co_rr_results_struct	*dlpi_co_rr_results;

  dlpi_co_rr_request	= (struct dlpi_co_rr_request_struct *)netperf_request.content.test_specific_data;
  dlpi_co_rr_response	= (struct dlpi_co_rr_response_struct *)netperf_response.content.test_specific_data;
  dlpi_co_rr_results	= (struct dlpi_co_rr_results_struct *)netperf_response.content.test_specific_data;

  if (debug) {
    fprintf(where,"netserver: recv_dlpi_co_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_dlpi_co_rr: setting the response type...\n");
    fflush(where);
  }

  netperf_response.content.response_type = DLPI_CO_RR_RESPONSE;

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

  /* set-up the data buffer with the requested alignment and offset */
  message = (char *)malloc(DATABUFFERLEN);
  if (message == NULL) {
    printf("malloc(%d) failed!\n", DATABUFFERLEN);
    exit(1);
  }

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

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

  recv_message_ptr = ALIGN_BUFFER(message, dlpi_co_rr_request->recv_alignment, dlpi_co_rr_request->recv_offset);
  recv_message.maxlen = dlpi_co_rr_request->request_size;
  recv_message.len    = 0;
  recv_message.buf    = recv_message_ptr;

  send_message_ptr = ALIGN_BUFFER(message, dlpi_co_rr_request->send_alignment, dlpi_co_rr_request->send_offset);
  send_message.maxlen = dlpi_co_rr_request->response_size;
  send_message.len    = dlpi_co_rr_request->response_size;
  send_message.buf    = send_message_ptr;

  if (debug) {
    fprintf(where,"recv_dlpi_co_rr: receive alignment and offset set...\n");
    fprintf(where,"recv_dlpi_co_rr: send_message.buf %x .len %d .maxlen %d\n",
	    send_message.buf,send_message.len,send_message.maxlen);
    fprintf(where,"recv_dlpi_co_rr: recv_message.buf %x .len %d .maxlen %d\n",
	    recv_message.buf,recv_message.len,recv_message.maxlen);
    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. */

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

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

  /* lets grab a file descriptor for a particular link */

#ifdef __alpha

  /* ok - even on a DEC box, strings are strings. I din't really want */
  /* to ntohl the words of a string. since I don't want to teach the */
  /* send_ and recv_ _request and _response routines about the types, */
  /* I will put "anti-ntohl" calls here. I imagine that the "pure" */
  /* solution would be to use XDR, but I am still leary of being able */
  /* to find XDR libs on all platforms I want running netperf. raj */
  {
    int *charword;
    int *initword;
    int *lastword;

    initword = (int *) dlpi_co_rr_request->dlpi_device;
    lastword = initword + ((dlpi_co_rr_request->dev_name_len + 3) / 4);

    for (charword = initword;
	 charword < lastword;
	 charword++) {

      *charword = htonl(*charword);
    }
  }
#endif /* __alpha */

  if ((data_descriptor = dl_open(dlpi_co_rr_request->dlpi_device,
				 dlpi_co_rr_request->ppa)) < 0) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  /* bind the file descriptor to a sap and get the resultant dlsap */
  dlpi_co_rr_response->station_addr_len = 14; /*arbitrary needs fixing */
  if (dl_bind(data_descriptor,
              dlpi_co_rr_request->sap,
              DL_CODLS,
              (char *)dlpi_co_rr_response->station_addr,
              &dlpi_co_rr_response->station_addr_len) != 0) {
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  /* The initiator may have wished-us to modify the socket buffer */
  /* sizes. We should give it a shot. If he didn't ask us to change the */
  /* sizes, we should let him know what sizes were in use at this end. */
  /* If none of this code is compiled-in, then we will tell the */
  /* initiator that we were unable to play with the socket buffer by */
  /* setting the size in the response to -1. */

#ifdef DL_HP_SET_LOCAL_WIN_REQ

  if (dlpi_co_rr_request->recv_win_size) {
    /* SMOP */
  }

  if (dlpi_co_rr_request->send_win_size) {
    /* SMOP */
  }

  /* Now, we will find-out what the sizes actually became, and report */
  /* them back to the user. If the calls fail, we will just report a -1 */
  /* back to the initiator for the buffer size. */

#else /* the system won't let us play with the buffers */

  dlpi_co_rr_response->recv_win_size	= -1;
  dlpi_co_rr_response->send_win_size	= -1;

#endif /* DL_HP_SET_LOCAL_WIN_REQ */

  /* we may have been requested to enable the copy avoidance features. */
  /* can we actually do this with DLPI, the world wonders */

  if (dlpi_co_rr_request->so_rcvavoid) {
#ifdef SO_RCV_COPYAVOID
    dlpi_co_rr_response->so_rcvavoid = 0;
#else
    /* it wasn't compiled in... */
    dlpi_co_rr_response->so_rcvavoid = 0;
#endif
  }

  if (dlpi_co_rr_request->so_sndavoid) {
#ifdef SO_SND_COPYAVOID
    dlpi_co_rr_response->so_sndavoid = 0;
#else
    /* it wasn't compiled in... */
    dlpi_co_rr_response->so_sndavoid = 0;
#endif
  }

  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. */

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

  send_response();

  /* accept a connection on this file descriptor. at some point, */
  /* dl_accept will "do the right thing" with the last two parms, but */
  /* for now it ignores them, so we will pass zeros. */

  if(dl_accept(data_descriptor, 0, 0) != 0) {
    fprintf(where,
	    "recv_dlpi_co_rr: error in accept, errno %d\n",
	    errno);
    fflush(where);
    netperf_response.content.serv_errno = errno;
    send_response();
    exit(1);
  }

  if (debug) {
    fprintf(where,
	    "recv_dlpi_co_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(dlpi_co_rr_request->measure_cpu);

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

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

  while ((!times_up) || (trans_remaining > 0)) {
    request_bytes_remaining	= dlpi_co_rr_request->request_size;

    /* receive the request from the other side. there needs to be some */
    /* more login in place for handling messages larger than link mtu, */
    /* but that can wait for later */
    while(request_bytes_remaining > 0) {
      if((getmsg(data_descriptor,
		 0,
		 &recv_message,
		 &flags)) < 0) {
	if (errno == EINTR) {
	  /* the timer popped */
	  timed_out = 1;
	  break;
	}

        if (debug) {
	  fprintf(where,"failed getmsg call errno %d\n",errno);
	  fprintf(where,"recv_message.len %d\n",recv_message.len);
	  fprintf(where,"send_message.len %d\n",send_message.len);
	  fflush(where);
        }

	netperf_response.content.serv_errno = errno;
	send_response();
	exit(1);
      }
      else {
	request_bytes_remaining -= recv_message.len;
      }
    }

    if (timed_out) {
      /* we hit the end of the test based on time - lets bail out of */
      /* here now... */
      break;
    }

    if (debug) {
      fprintf(where,"recv_message.len %d\n",recv_message.len);
      fprintf(where,"send_message.len %d\n",send_message.len);
      fflush(where);
    }

    /* Now, send the response to the remote */
    if((putmsg(data_descriptor,
	       0,
	       &send_message,
	       0)) != 0) {
      if (errno == EINTR) {
	/* the test timer has popped */
	timed_out = 1;
	break;
      }
      netperf_response.content.serv_errno = 994;
      send_response();
      exit(1);
    }

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

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


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

  cpu_stop(dlpi_co_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_dlpi_co_rr: got %d transactions\n",
	    trans_received);
    fflush(where);
  }

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

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

  send_response();

}

/* this routine will display the usage string for the DLPI tests */
void
  print_dlpi_usage()

{
  fwrite(dlpi_usage, sizeof(char), strlen(dlpi_usage), stdout);
}


/* this routine will scan the command line for DLPI test arguments */
void
  scan_dlpi_args(int argc, char *argv[])
{
  extern int	optind, opterrs;  /* index of first unused arg 	*/
  extern char	*optarg;	  /* pointer to option string	*/

  int		c;

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

  if (no_control) {
    fprintf(where,
	    "The DLPI 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.. */

#define DLPI_ARGS "D:hM:m:p:r:s:W:w:"

  while ((c= getopt(argc, argv, DLPI_ARGS)) != EOF) {
    switch (c) {
    case '?':
    case 'h':
      print_dlpi_usage();
      exit(1);
    case 'D':
      /* set the dlpi device file name(s) */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	strcpy(loc_dlpi_device,arg1);
      if (arg2[0])
	strcpy(rem_dlpi_device,arg2);
      break;
    case 'm':
      /* set the send size */
      send_size = atoi(optarg);
      break;
    case 'M':
      /* set the recv size */
      recv_size = atoi(optarg);
      break;
    case 'p':
      /* set the local/remote ppa */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	loc_ppa = atoi(arg1);
      if (arg2[0])
	rem_ppa = atoi(arg2);
      break;
    case 'r':
      /* set the request/response sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	req_size = atoi(arg1);
      if (arg2[0])
	rsp_size = atoi(arg2);
      break;
    case 's':
      /* set the 802.2 sap for the test */
      dlpi_sap = atoi(optarg);
      break;
    case 'w':
      /* set local window sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	lsw_size = atoi(arg1);
      if (arg2[0])
	lrw_size = atoi(arg2);
      break;
    case 'W':
      /* set remote window sizes */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	rsw_size = atoi(arg1);
      if (arg2[0])
	rrw_size = atoi(arg2);
      break;
    };
  }
}


#endif /* WANT_DLPI */