auto import from //depot/cupcake/@135843

35 files changed, 47058 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..a0d5b80
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,42 @@
+# Copyright (C) 2008 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+L_DEFS := -DHAVE_CONFIG_H -UAF_INET6
+L_CFLAGS := $(L_DEFS)
+L_USE_CPU_SOURCE := netcpu_none.c
+
+L_COMMON_SRC := hist.h netlib.c netsh.c nettest_bsd.c nettest_dlpi.c \
+  nettest_unix.c nettest_xti.c nettest_sctp.c nettest_sdp.c
+
+netperf_SOURCES := netperf.c $(L_COMMON_SRC) $(L_USE_CPU_SOURCE)
+netserver_SOURCES := netserver.c $(L_COMMON_SRC) $(L_USE_CPU_SOURCE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := netperf
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := tests eng
+LOCAL_CFLAGS := $(L_CFLAGS)
+LOCAL_SRC_FILES := $(netperf_SOURCES)
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := netserver
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := tests eng
+LOCAL_CFLAGS := $(L_CFLAGS)
+LOCAL_SRC_FILES := $(netserver_SOURCES)
+include $(BUILD_EXECUTABLE)
+
diff --git a/MODULE_LICENSE_HP b/MODULE_LICENSE_HP
new file mode 100644
index 0000000..3f3ceb2
--- /dev/null
+++ b/MODULE_LICENSE_HP
@@ -0,0 +1,43 @@
+
+ 
+              Copyright (C) 1993 Hewlett-Packard Company
+                         ALL RIGHTS RESERVED.
+ 
+  The enclosed software and documentation includes copyrighted works
+  of Hewlett-Packard Co. For as long as you comply with the following
+  limitations, you are hereby authorized to (i) use, reproduce, and
+  modify the software and documentation, and to (ii) distribute the
+  software and documentation, including modifications, for
+  non-commercial purposes only.
+      
+  1.  The enclosed software and documentation is made available at no
+      charge in order to advance the general development of
+      high-performance networking products.
+ 
+  2.  You may not delete any copyright notices contained in the
+      software or documentation. All hard copies, and copies in
+      source code or object code form, of the software or
+      documentation (including modifications) must contain at least
+      one of the copyright notices.
+ 
+  3.  The enclosed software and documentation has not been subjected
+      to testing and quality control and is not a Hewlett-Packard Co.
+      product. At a future time, Hewlett-Packard Co. may or may not
+      offer a version of the software and documentation as a product.
+  
+  4.  THE SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS".
+      HEWLETT-PACKARD COMPANY DOES NOT WARRANT THAT THE USE,
+      REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
+      DOCUMENTATION WILL NOT INFRINGE A THIRD PARTY'S INTELLECTUAL
+      PROPERTY RIGHTS. HP DOES NOT WARRANT THAT THE SOFTWARE OR
+      DOCUMENTATION IS ERROR FREE. HP DISCLAIMS ALL WARRANTIES,
+      EXPRESS AND IMPLIED, WITH REGARD TO THE SOFTWARE AND THE
+      DOCUMENTATION. HP SPECIFICALLY DISCLAIMS ALL WARRANTIES OF
+      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+  
+  5.  HEWLETT-PACKARD COMPANY WILL NOT IN ANY EVENT BE LIABLE FOR ANY
+      DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+      (INCLUDING LOST PROFITS) RELATED TO ANY USE, REPRODUCTION,
+      MODIFICATION, OR DISTRIBUTION OF THE SOFTWARE OR DOCUMENTATION.
+ 
+
diff --git a/config.h b/config.h
new file mode 100644
index 0000000..5c89615
--- /dev/null
+++ b/config.h
@@ -0,0 +1,351 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to one to enable dirty buffer support. May affect results. */
+/* #undef DIRTY */
+
+#undef AF_INET6
+
+/* Define to 1 if you have the `alarm' function. */
+#define HAVE_ALARM 1
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#define HAVE_ARPA_INET_H 1
+
+/* Define to 1 if you have the `bindprocessor' function. */
+/* #undef HAVE_BINDPROCESSOR */
+
+/* Define to 1 if you have the `bind_to_cpu_id' function. */
+/* #undef HAVE_BIND_TO_CPU_ID */
+
+/* Define to 1 if you have the `bzero' function. */
+#define HAVE_BZERO 1
+
+/* Define to 1 if you have the <endian.h> header file. */
+/* #define HAVE_ENDIAN_H 1 */
+
+/* Define to 1 if you have the <errno.h> header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `fork' function. */
+#define HAVE_FORK 1
+
+/* Define to 1 if you have the `getaddrinfo' function. */
+#define HAVE_GETADDRINFO 1
+
+/* Define to 1 if you have the `gethostbyname' function. */
+#define HAVE_GETHOSTBYNAME 1
+
+/* Define to 1 if you have the `gethrtime' function. */
+/* #undef HAVE_GETHRTIME */
+
+/* Define to 1 if you have the `getnameinfo' function. */
+#define HAVE_GETNAMEINFO 1
+
+/* Define to 1 if you have the `getpagesize' function. */
+#define HAVE_GETPAGESIZE 1
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#define HAVE_GETTIMEOFDAY 1
+
+/* Define to one to include ICSC-EXS tests. */
+/* #undef HAVE_ICSC_EXS */
+
+/* Define to 1 if you have the `inet_ntoa' function. */
+#define HAVE_INET_NTOA 1
+
+/* Define to 1 if you have the `inet_ntop' function. */
+#define HAVE_INET_NTOP 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `exs' library (-lexs). */
+/* #undef HAVE_LIBEXS */
+
+/* Define to 1 if you have the `kstat' library (-lkstat). */
+/* #undef HAVE_LIBKSTAT */
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the `mach' library (-lmach). */
+/* #undef HAVE_LIBMACH */
+
+/* Define to 1 if you have the `nsl' library (-lnsl). */
+/* #undef HAVE_LIBNSL */
+
+/* Define to 1 if you have the `perfstat' library (-lperfstat). */
+/* #undef HAVE_LIBPERFSTAT */
+
+/* Define to 1 if you have the `sctp' library (-lsctp). */
+/* #undef HAVE_LIBSCTP */
+
+/* Define to 1 if you have the `sdp' library (-lsdp). */
+/* #undef HAVE_LIBSDP */
+
+/* Define to 1 if you have the `sendfile' library (-lsendfile). */
+/* #undef HAVE_LIBSENDFILE */
+
+/* Define to 1 if you have the `socket' library (-lsocket). */
+/* #undef HAVE_LIBSOCKET */
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+/* #define HAVE_MALLOC_H 1 */
+
+/* Define to 1 if you have the `memcpy' function. */
+#define HAVE_MEMCPY 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `memset' function. */
+#define HAVE_MEMSET 1
+
+/* Define to 1 if you have a working `mmap' system call. */
+#define HAVE_MMAP 1
+
+/* Define to 1 if you have the `mpctl' function. */
+/* #undef HAVE_MPCTL */
+
+/* Define to 1 if you have the `munmap' function. */
+#define HAVE_MUNMAP 1
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#define HAVE_NETDB_H 1
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#define HAVE_NETINET_IN_H 1
+
+/* Define to 1 if you have the <netinet/sctp.h> header file. */
+/* #undef HAVE_NETINET_SCTP_H */
+
+/* Define to 1 if you have the `processor_bind' function. */
+/* #undef HAVE_PROCESSOR_BIND */
+
+/* Define to 1 if you have the `sched_setaffinity' function. */
+/* #define HAVE_SCHED_SETAFFINITY 1 */
+
+/* Define to 1 if `struct sctp_event_subscribe' has a
+   `sctp_adaptation_layer_event' member */
+/* #undef HAVE_SCTP_ADAPTATION_LAYER_EVENT */
+
+/* Define to 1 if you have the `select' function. */
+#define HAVE_SELECT 1
+
+/* Define to 1 if you have the `sendfile' function. */
+/* #undef HAVE_SENDFILE */ 
+
+/* Define to 1 if you have the <signal.h> header file. */
+#define HAVE_SIGNAL_H 1
+
+/* Define to 1 if you have the `socket' function. */
+#define HAVE_SOCKET 1
+
+/* Define to 1 if you have the `sqrt' function. */
+#define HAVE_SQRT 1
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#define HAVE_STDBOOL_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#define HAVE_STRCASECMP 1
+
+/* Define to 1 if you have the `strchr' function. */
+#define HAVE_STRCHR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strstr' function. */
+#define HAVE_STRSTR 1
+
+/* Define to 1 if you have the `strtoul' function. */
+#define HAVE_STRTOUL 1
+
+/* Define to 1 if <netinet/in.h> defines `struct sockaddr_storage' */
+#define HAVE_STRUCT_SOCKADDR_STORAGE 1
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#define HAVE_SYS_IOCTL_H 1
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#define HAVE_SYS_MMAN_H 1
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#define HAVE_SYS_PARAM_H 1
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#define HAVE_SYS_SELECT_H 1
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#define HAVE_SYS_SOCKET_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
+#define HAVE_SYS_WAIT_H 1
+
+/* Define to 1 if you have the `uname' function. */
+#define HAVE_UNAME 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `vfork' function. */
+#define HAVE_VFORK 1
+
+/* Define to 1 if you have the <vfork.h> header file. */
+/* #undef HAVE_VFORK_H */
+
+/* Define to 1 if `fork' works. */
+#define HAVE_WORKING_FORK 1
+
+/* Define to 1 if `vfork' works. */
+#define HAVE_WORKING_VFORK 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to 1 if `h_errno' is declared by <netdb.h> */
+#define H_ERRNO_DECLARED 1
+
+/* Name of package */
+#define PACKAGE "netperf"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "netperf"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "netperf 2.4.4"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "netperf"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "2.4.4"
+
+/* Define as the return type of signal handlers (`int' or `void'). */
+#define RETSIGTYPE void
+
+/* Define to the type of arg 1 for `select'. */
+#define SELECT_TYPE_ARG1 int
+
+/* Define to the type of args 2, 3 and 4 for `select'. */
+#define SELECT_TYPE_ARG234 (fd_set *)
+
+/* Define to the type of arg 5 for `select'. */
+#define SELECT_TYPE_ARG5 (struct timeval *)
+
+/* Define to 1 if the `setpgrp' function takes no argument. */
+#define SETPGRP_VOID 1
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
+
+/* Use Solaris's kstat interface to measure CPU util. */
+/* #undef USE_KSTAT */
+
+/* Use looper/soaker processes to measure CPU util. */
+/* #undef USE_LOOPER */
+
+/* Use MacOS X's host_info interface to measure CPU util. */
+/* #undef USE_OSX */
+
+/* Use AIX's perfstat interface to measure CPU util. */
+/* #undef USE_PERFSTAT */
+
+/* Use Linux's procstat interface to measure CPU util. */
+#define USE_PROC_STAT 1
+
+/* Use HP-UX's pstat interface to measure CPU util. */
+/* #undef USE_PSTAT */
+
+/* Use FreeBSD's sysctl interface to measure CPU util. */
+/* #undef USE_SYSCTL */
+
+/* Version number of package */
+#define VERSION "2.4.4"
+
+/* Define to one to enable demo support. May affect results. */
+/* #undef WANT_DEMO */
+
+/* Define to one to include DLPI tests. */
+/* #undef WANT_DLPI */
+
+/* Define to one to enable initial _RR burst support. May affect results. */
+/* #undef WANT_FIRST_BURST */
+
+/* Define to one to enable histogram support. May affect results. */
+/* #undef WANT_HISTOGRAM */
+
+/* Define to one to enable paced operation support. May affect results. */
+/* #undef WANT_INTERVALS */
+
+/* Define to one to include SCTP tests. */
+/* #define WANT_SCTP 1 */
+
+/* Define to one to include SDP tests. */
+/* #undef WANT_SDP */
+
+/* Define to one to spin waiting on paced operation. WILL AFFEFCT CPU
+   UTILIZATION */
+/* #undef WANT_SPIN */
+
+/* Define to one to include Unix Domain socket tests. */
+/* #undef WANT_UNIX */
+
+/* Define to one to include XTI tests. */
+/* #undef WANT_XTI */
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* type to use in place of socklen_t if not defined */
+#define netperf_socklen_t size_t
+
+/* Define to `long int' if <sys/types.h> does not define. */
+/* #undef off_t */
+
+/* Define to `int' if <sys/types.h> does not define. */
+/* #undef pid_t */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
+
+/* Define as `fork' if `vfork' does not work. */
+/* #undef vfork */
diff --git a/hist.h b/hist.h
new file mode 100644
index 0000000..b2ed22b
--- /dev/null
+++ b/hist.h
@@ -0,0 +1,116 @@
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+/* hist.h
+
+   Given a time difference in microseconds, increment one of 61
+   different buckets: 
+   
+   0 - 9 in increments of 1 usec
+   0 - 9 in increments of 10 usecs
+   0 - 9 in increments of 100 usecs
+   0 - 9 in increments of 1 msec
+   0 - 9 in increments of 10 msecs
+   0 - 9 in increments of 100 msecs
+   0 - 9 in increments of 1 sec
+   0 - 9 in increments of 10 sec
+   > 100 secs
+   
+   This will allow any time to be recorded to within an accuracy of
+   10%, and provides a compact representation for capturing the
+   distribution of a large number of time differences (e.g.
+   request-response latencies).
+   
+   Colin Low  10/6/93
+   Rick Jones 2004-06-15 - extend to 1 and 10 usec
+*/
+#ifndef _HIST_INCLUDED
+#define _HIST_INCLUDED
+
+#ifdef IRIX
+#include <sys/time.h>
+#endif /* IRIX */
+
+#if defined(HAVE_GET_HRT)
+#include "hrt.h"
+#endif
+   
+struct histogram_struct {
+  int unit_usec[10];
+  int ten_usec[10];
+  int hundred_usec[10];
+  int unit_msec[10];
+  int ten_msec[10];
+  int hundred_msec[10];
+  int unit_sec[10];
+  int ten_sec[10];
+  int ridiculous;
+  int total;
+};
+
+typedef struct histogram_struct *HIST;
+
+/* 
+   HIST_new - return a new, cleared histogram data type
+*/
+
+HIST HIST_new(void); 
+
+/* 
+   HIST_clear - reset a histogram by clearing all totals to zero
+*/
+
+void HIST_clear(HIST h);
+
+/*
+   HIST_add - add a time difference to a histogram. Time should be in
+   microseconds. 
+*/
+
+void HIST_add(register HIST h, int time_delta);
+
+/* 
+  HIST_report - create an ASCII report on the contents of a histogram.
+  Currently printsto standard out 
+*/
+
+void HIST_report(HIST h);
+
+/*
+  HIST_timestamp - take a timestamp suitable for use in a histogram.
+*/
+
+#ifdef HAVE_GETHRTIME
+void HIST_timestamp(hrtime_t *timestamp);
+#elif defined(HAVE_GET_HRT)
+void HIST_timestamp(hrt_t *timestamp);
+#elif defined(WIN32)
+void HIST_timestamp(LARGE_INTEGER *timestamp);
+#else
+void HIST_timestamp(struct timeval *timestamp);
+#endif
+
+/*
+  delta_micro - calculate the difference in microseconds between two
+  timestamps
+*/
+#ifdef HAVE_GETHRTIME
+int delta_micro(hrtime_t *begin, hrtime_t *end);
+#elif defined(HAVE_GET_HRT)
+int delta_micro(hrt_t *begin, hrt_t *end);
+#elif defined(WIN32)
+int delta_micro(LARGE_INTEGER *begin, LARGE_INTEGER *end);
+#else
+int delta_micro(struct timeval *begin, struct timeval *end);
+#endif
+
+#endif
+
diff --git a/netcpu.h b/netcpu.h
new file mode 100644
index 0000000..58d1e1c
--- /dev/null
+++ b/netcpu.h
@@ -0,0 +1,19 @@
+/* This should define all the common routines etc exported by the
+   various netcpu_mumble.c files raj 2005-01-26 */
+
+extern void  cpu_util_init(void);
+extern void  cpu_util_terminate(void);
+extern int   get_cpu_method();
+
+#ifdef WIN32
+/* +*+ temp until I figure out what header this is in; I know it's
+   there someplace...  */
+typedef unsigned __int64    uint64_t;
+#endif
+
+extern void  get_cpu_idle(uint64_t *res);
+extern float calibrate_idle_rate(int iterations, int interval);
+extern float calc_cpu_util_internal(float elapsed);
+extern void  cpu_start_internal(void);
+extern void  cpu_stop_internal(void);
+
diff --git a/netcpu_kstat.c b/netcpu_kstat.c
new file mode 100644
index 0000000..6320658
--- /dev/null
+++ b/netcpu_kstat.c
@@ -0,0 +1,415 @@
+char   netcpu_kstat_id[]="\
+@(#)netcpu_kstat.c  Version 2.4.0";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+
+#include <kstat.h>
+#include <sys/sysinfo.h>
+
+#include "netsh.h"
+#include "netlib.h"
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibrarion to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+static uint64_t  lib_start_count[MAXCPUS];
+static uint64_t  lib_end_count[MAXCPUS];
+
+static  kstat_t *cpu_ks[MAXCPUS]; /* the addresses that kstat will
+                                     need to pull the cpu info from
+                                     the kstat interface.  at least I
+                                     think that is what this is :) raj
+                                     8/2000 */  
+
+#define UPDKCID(nk,ok) \
+if (nk == -1) { \
+  perror("kstat_read "); \
+  exit(1); \
+} \
+if (nk != ok)\
+  goto kcid_changed;
+
+static kstat_ctl_t *kc = NULL;
+static kid_t kcid = 0;
+
+/* do the initial open of the kstat interface, get the chain id's all
+   straightened-out and set-up the addresses for get_kstat_idle to do
+   its thing.  liberally borrowed from the sources to TOP. raj 8/2000 */
+
+static int
+open_kstat()
+{
+  kstat_t *ks;
+  kid_t nkcid;
+  int i;
+  int changed = 0;
+  static int ncpu = 0;
+
+  kstat_named_t *kn;
+
+  if (debug) {
+    fprintf(where,"open_kstat: enter\n");
+    fflush(where);
+  }
+  
+  /*
+   * 0. kstat_open
+   */
+  
+  if (!kc)
+    {
+      kc = kstat_open();
+      if (!kc)
+        {
+          perror("kstat_open ");
+          exit(1);
+        }
+      changed = 1;
+      kcid = kc->kc_chain_id;
+    }
+#ifdef rickwasstupid
+  else {
+    fprintf(where,"open_kstat double open!\n");
+    fflush(where);
+    exit(1);
+  }
+#endif
+
+  /* keep doing it until no more changes */
+ kcid_changed:
+
+  if (debug) {
+    fprintf(where,"passing kcid_changed\n");
+    fflush(where);
+  }
+  
+  /*
+   * 1.  kstat_chain_update
+   */
+  nkcid = kstat_chain_update(kc);
+  if (nkcid)
+    {
+      /* UPDKCID will abort if nkcid is -1, so no need to check */
+      changed = 1;
+      kcid = nkcid;
+    }
+  UPDKCID(nkcid,0);
+
+  if (debug) {
+    fprintf(where,"kstat_lookup for unix/system_misc\n");
+    fflush(where);
+  }
+  
+  ks = kstat_lookup(kc, "unix", 0, "system_misc");
+  if (kstat_read(kc, ks, 0) == -1) {
+    perror("kstat_read");
+    exit(1);
+  }
+  
+  
+  if (changed) {
+    
+    /*
+     * 2. get data addresses
+     */
+    
+    ncpu = 0;
+    
+    kn = kstat_data_lookup(ks, "ncpus");
+    if (kn && kn->value.ui32 > lib_num_loc_cpus) {
+      fprintf(stderr,"number of CPU's mismatch!");
+      exit(1);
+    }
+    
+    for (ks = kc->kc_chain; ks;
+         ks = ks->ks_next)
+      {
+        if (strncmp(ks->ks_name, "cpu_stat", 8) == 0)
+          {
+            nkcid = kstat_read(kc, ks, NULL);
+            /* if kcid changed, pointer might be invalid. we'll deal
+               wtih changes at this stage, but will not accept them
+               when we are actually in the middle of reading
+               values. hopefully this is not going to be a big
+               issue. raj 8/2000 */
+            UPDKCID(nkcid, kcid);
+            
+            if (debug) {
+              fprintf(where,"cpu_ks[%d] getting %p\n",ncpu,ks);
+              fflush(where);
+            }
+
+            cpu_ks[ncpu] = ks;
+            ncpu++;
+            if (ncpu > lib_num_loc_cpus)
+              {
+                /* with the check above, would we ever hit this? */
+                fprintf(stderr, 
+                        "kstat finds too many cpus %d: should be %d\n",
+                        ncpu,lib_num_loc_cpus);
+                exit(1);
+              }
+          }
+      }
+    /* note that ncpu could be less than ncpus, but that's okay */
+    changed = 0;
+  }
+}
+
+/* return the value of the idle tick counter for the specified CPU */
+static long
+get_kstat_idle(cpu)
+     int cpu;
+{
+  cpu_stat_t cpu_stat;
+  kid_t nkcid;
+
+  if (debug) {
+    fprintf(where,
+            "get_kstat_idle reading with kc %x and ks %p\n",
+            kc,
+            cpu_ks[cpu]);
+  }
+
+  nkcid = kstat_read(kc, cpu_ks[cpu], &cpu_stat);
+  /* if kcid changed, pointer might be invalid, fail the test */
+  UPDKCID(nkcid, kcid);
+
+  return(cpu_stat.cpu_sysinfo.cpu[CPU_IDLE]);
+
+ kcid_changed:
+  perror("kcid changed midstream and I cannot deal with that!");
+  exit(1);
+}
+
+void
+cpu_util_init(void) 
+{
+  open_kstat();
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return KSTAT;
+}
+
+void
+get_cpu_idle(uint64_t *res)
+{
+
+  int i;
+
+  /* this open may be redundant */
+  open_kstat();
+
+  for (i = 0; i < lib_num_loc_cpus; i++){
+    res[i] = get_kstat_idle(i);
+  }
+  return;
+}
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+ 
+  long  
+    firstcnt[MAXCPUS],
+    secondcnt[MAXCPUS];
+
+  float 
+    elapsed,
+    temp_rate,
+    rate[MAXTIMES],
+    local_maxrate;
+
+  long  
+    sec,
+    usec;
+
+  int   
+    i,
+    j;
+  
+  struct  timeval time1, time2 ;
+  struct  timezone tz;
+  
+  if (debug) {
+    fprintf(where,"calling open_kstat from calibrate_kstat\n");
+    fflush(where);
+  }
+
+  open_kstat();
+
+  if (iterations > MAXTIMES) {
+    iterations = MAXTIMES;
+  }
+
+  local_maxrate = (float)-1.0;
+  
+  for(i = 0; i < iterations; i++) {
+    rate[i] = (float)0.0;
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      firstcnt[j] = get_kstat_idle(j);
+    }
+    gettimeofday (&time1, &tz);
+    sleep(interval);
+    gettimeofday (&time2, &tz);
+
+    if (time2.tv_usec < time1.tv_usec)
+      {
+        time2.tv_usec += 1000000;
+        time2.tv_sec -=1;
+      }
+    sec = time2.tv_sec - time1.tv_sec;
+    usec = time2.tv_usec - time1.tv_usec;
+    elapsed = (float)sec + ((float)usec/(float)1000000.0);
+    
+    if(debug) {
+      fprintf(where, "Calibration for kstat counter run: %d\n",i);
+      fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
+      fprintf(where,"\telapsed time = %g\n",elapsed);
+    }
+
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      secondcnt[j] = get_kstat_idle(j);
+      if(debug) {
+        /* I know that there are situations where compilers know about */
+        /* long long, but the library functions do not... raj 4/95 */
+        fprintf(where,
+                "\tfirstcnt[%d] = 0x%8.8lx%8.8lx secondcnt[%d] = 0x%8.8lx%8.8lx\n",
+                j,
+                firstcnt[j],
+                firstcnt[j],
+                j,
+                secondcnt[j],
+                secondcnt[j]);
+      }
+      /* we assume that it would wrap no more than once. we also */
+      /* assume that the result of subtracting will "fit" raj 4/95 */
+      temp_rate = (secondcnt[j] >= firstcnt[j]) ?
+        (float)(secondcnt[j] - firstcnt[j])/elapsed : 
+          (float)(secondcnt[j]-firstcnt[j]+MAXLONG)/elapsed;
+      if (temp_rate > rate[i]) rate[i] = temp_rate;
+      if(debug) {
+        fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
+        fflush(where);
+      }
+      if (local_maxrate < rate[i]) local_maxrate = rate[i];
+    }
+  }
+  if(debug) {
+    fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
+    fflush(where);
+  }
+  return local_maxrate;
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+  float correction_factor;
+  float actual_rate;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+
+    /* it would appear that on some systems, in loopback, nice is
+     *very* effective, causing the looper process to stop dead in its
+     tracks. if this happens, we need to ensure that the calculation
+     does not go south. raj 6/95 and if we run completely out of idle,
+     the same thing could in theory happen to the USE_KSTAT path. raj
+     8/2000 */ 
+    
+    if (lib_end_count[i] == lib_start_count[i]) {
+      lib_end_count[i]++;
+    }
+    
+    actual_rate = (lib_end_count[i] > lib_start_count[i]) ?
+      (float)(lib_end_count[i] - lib_start_count[i])/lib_elapsed :
+      (float)(lib_end_count[i] - lib_start_count[i] +
+	      MAXLONG)/ lib_elapsed;
+    if (debug) {
+      fprintf(where,
+              "calc_cpu_util: actual_rate on processor %d is %f start %lx end %lx\n",
+              i,
+              actual_rate,
+              lib_start_count[i],
+              lib_end_count[i]);
+    }
+    lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) /
+      lib_local_maxrate * 100;
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+  }
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  lib_local_cpu_util *= correction_factor;
+  return lib_local_cpu_util;
+
+
+}
+
+void
+cpu_start_internal(void)
+{
+  get_cpu_idle(lib_start_count);
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_idle(lib_end_count);
+}
diff --git a/netcpu_kstat10.c b/netcpu_kstat10.c
new file mode 100644
index 0000000..299e66d
--- /dev/null
+++ b/netcpu_kstat10.c
@@ -0,0 +1,559 @@
+char   netcpu_kstat10_id[]="\
+@(#)netcpu_kstat10.c (c) Copyright 2005-2007, Hewlett-Packard Company Version 2.4.3";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+
+#include <errno.h>
+
+#include <kstat.h>
+#include <sys/sysinfo.h>
+
+#include "netsh.h"
+#include "netlib.h"
+
+static kstat_ctl_t *kc = NULL;
+static kid_t kcid = 0;
+
+typedef struct cpu_time_counters {
+  uint64_t idle;
+  uint64_t user;
+  uint64_t kernel;
+  uint64_t interrupt;
+} cpu_time_counters_t;
+
+static cpu_time_counters_t starting_cpu_counters[MAXCPUS];
+static cpu_time_counters_t ending_cpu_counters[MAXCPUS];
+static cpu_time_counters_t delta_cpu_counters[MAXCPUS];
+static cpu_time_counters_t corrected_cpu_counters[MAXCPUS];
+
+static void
+print_cpu_time_counters(char *name, int instance, cpu_time_counters_t *counters) 
+{
+  fprintf(where,"%s[%d]:\n",name,instance);
+  fprintf(where,
+	  "\t idle %llu\n",counters[instance].idle);
+  fprintf(where,
+	  "\t user %llu\n",counters[instance].user);
+  fprintf(where,
+	  "\t kernel %llu\n",counters[instance].kernel);
+  fprintf(where,
+	  "\t interrupt %llu\n",counters[instance].interrupt);
+}
+
+void
+cpu_util_init(void) 
+{
+  kc = kstat_open();
+
+  if (kc == NULL) {
+    fprintf(where,
+	    "cpu_util_init: kstat_open: errno %d %s\n",
+	    errno,
+	    strerror(errno));
+    fflush(where);
+    exit(-1);
+  }
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  kstat_close(kc);
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return KSTAT_10;
+}
+
+static void
+print_unexpected_statistic_warning(char *who, char *what, char *why)
+{
+  if (why) {
+    fprintf(where,
+	    "WARNING! WARNING! WARNING! WARNING!\n");
+    fprintf(where,
+	    "%s found an unexpected %s statistic %.16s\n",
+	    who,
+	    why,
+	    what);
+  }
+  else {
+    fprintf(where,
+	    "%s is ignoring statistic %.16s\n",
+	    who,
+	    what);
+  }
+}
+
+static void
+get_cpu_counters(int cpu_num, cpu_time_counters_t *counters)
+{
+
+  kstat_t *ksp;
+  int found=0;
+  kid_t nkcid;
+  kstat_named_t *knp;
+  int i;
+
+  ksp = kstat_lookup(kc, "cpu", cpu_num, "sys");
+  if ((ksp) && (ksp->ks_type == KSTAT_TYPE_NAMED)) {
+    /* happiness and joy, keep going */
+    nkcid = kstat_read(kc, ksp, NULL);
+    if (nkcid != -1) {
+      /* happiness and joy, keep going. we could consider adding a
+	 "found < 3" to the end conditions, but then we wouldn't
+	 search to the end and find that Sun added some nsec. we
+	 probably want to see if they add an nsec. raj 2005-01-28 */
+      for (i = ksp->ks_ndata, knp = ksp->ks_data;
+	   i > 0;
+	   knp++,i--) {
+	/* we would be hosed if the same name could appear twice */
+	if (!strcmp("cpu_nsec_idle",knp->name)) {
+	  found++;
+	  counters[cpu_num].idle = knp->value.ui64;
+	}
+	else if (!strcmp("cpu_nsec_user",knp->name)) {
+	  found++;
+	  counters[cpu_num].user = knp->value.ui64;
+	}
+	else if (!strcmp("cpu_nsec_kernel",knp->name)) {
+	  found++;
+	  counters[cpu_num].kernel = knp->value.ui64;
+	}
+	else if (strstr(knp->name,"nsec")) {
+	  /* finding another nsec here means Sun have changed
+	     something and we need to warn the user. raj 2005-01-28 */ 
+	  print_unexpected_statistic_warning("get_cpu_counters",
+					     knp->name,
+					     "nsec");
+	}
+	else if (debug >=2) {
+
+	  /* might want to tell people about what we are skipping.
+	     however, only display other names debug >=2. raj
+	     2005-01-28
+	  */
+
+	  print_unexpected_statistic_warning("get_cpu_counters",
+					     knp->name,
+					     NULL);
+	}
+      }
+      if (3 == found) {
+	/* happiness and joy */
+	return;
+      }
+      else {
+	fprintf(where,
+		"get_cpu_counters could not find one or more of the expected counters!\n");
+	fflush(where);
+	exit(-1);
+      }
+    }
+    else {
+      /* the kstat_read returned an error or the chain changed */
+      fprintf(where,
+	      "get_cpu_counters: kstat_read failed or chain id changed %d %s\n",
+	      errno,
+	      strerror(errno));
+      fflush(where);
+      exit(-1);
+    }
+  }
+  else {
+    /* the lookup failed or found the wrong type */
+    fprintf(where,
+	    "get_cpu_counters: kstat_lookup failed for module 'cpu' instance %d name 'sys' and KSTAT_TYPE_NAMED: errno %d %s\n",
+	    cpu_num,
+	    errno,
+	    strerror(errno));
+    fflush(where);
+    exit(-1);
+  }
+}
+
+static void
+get_interrupt_counters(int cpu_num, cpu_time_counters_t *counters)
+{
+  kstat_t *ksp;
+  int found=0;
+  kid_t nkcid;
+  kstat_named_t *knp;
+  int i;
+
+  ksp = kstat_lookup(kc, "cpu", cpu_num, "intrstat");
+
+  counters[cpu_num].interrupt = 0;
+  if ((ksp) && (ksp->ks_type == KSTAT_TYPE_NAMED)) {
+    /* happiness and joy, keep going */
+    nkcid = kstat_read(kc, ksp, NULL);
+    if (nkcid != -1) {
+      /* happiness and joy, keep going. we could consider adding a
+	 "found < 15" to the end conditions, but then we wouldn't
+	 search to the end and find that Sun added some "time." we
+	 probably want to see if they add a "nsec." raj 2005-01-28 */
+      for (i = ksp->ks_ndata, knp = ksp->ks_data;
+	   i > 0;
+	   knp++,i--) {
+	if (strstr(knp->name,"time")) {
+	  found++;
+	  counters[cpu_num].interrupt += knp->value.ui64;
+	}
+	else if (debug >=2) {
+
+	  /* might want to tell people about what we are skipping.
+	     however, only display other names debug >=2. raj
+	     2005-01-28
+	  */
+
+	  print_unexpected_statistic_warning("get_cpu_counters",
+					     knp->name,
+					     NULL);
+	}
+      }
+      if (15 == found) {
+	/* happiness and joy */
+	return;
+      }
+      else {
+	fprintf(where,
+		"get_cpu_counters could not find one or more of the expected counters!\n");
+	fflush(where);
+	exit(-1);
+      }
+    }
+    else {
+      /* the kstat_read returned an error or the chain changed */
+      fprintf(where,
+	      "get_cpu_counters: kstat_read failed or chain id changed %d %s\n",
+	      errno,
+	      strerror(errno));
+      fflush(where);
+      exit(-1);
+    }
+  }
+  else {
+    /* the lookup failed or found the wrong type */
+    fprintf(where,
+	    "get_cpu_counters: kstat_lookup failed for module 'cpu' instance %d class 'intrstat' and KSTAT_TYPE_NAMED: errno %d %s\n",
+	    cpu_num,
+	    errno,
+	    strerror(errno));
+    fflush(where);
+    exit(-1);
+  }
+
+}
+
+static void
+get_cpu_time_counters(cpu_time_counters_t *counters)
+{
+
+  int i;
+
+  for (i = 0; i < lib_num_loc_cpus; i++){
+    get_cpu_counters(i, counters);
+    get_interrupt_counters(i, counters);
+  }
+
+  return;
+}
+
+/* the kstat10 mechanism, since it is based on actual nanosecond
+   counters is not going to use a comparison to an idle rate. so, the
+   calibrate_idle_rate routine will be rather simple :) raj 2005-01-28
+   */ 
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  return 0.0;
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+  float correction_factor;
+  float actual_rate;
+  
+  uint64_t total_cpu_nsec;
+
+  /* multiply by 100 and divide by total and you get whole
+     percentages. multiply by 1000 and divide by total and you get
+     tenths of percentages.  multiply by 10000 and divide by total and
+     you get hundredths of percentages. etc etc etc raj 2005-01-28 */
+
+#define CALC_PERCENT 100
+#define CALC_TENTH_PERCENT 1000
+#define CALC_HUNDREDTH_PERCENT 10000
+#define CALC_THOUSANDTH_PERCENT 100000
+#define CALC_ACCURACY CALC_THOUSANDTH_PERCENT
+  
+  uint64_t fraction_idle;
+  uint64_t fraction_user;
+  uint64_t fraction_kernel;
+  uint64_t fraction_interrupt;
+
+  uint64_t interrupt_idle;
+  uint64_t interrupt_user;
+  uint64_t interrupt_kernel;
+
+  lib_local_cpu_util = (float)0.0;
+
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+
+    /* this is now the fun part.  we have the nanoseconds _allegedly_
+       spent in user, idle and kernel.  We also have nanoseconds spent
+       servicing interrupts.  Sadly, in the developer's finite wisdom,
+       the interrupt time accounting is in parallel with the other
+       accounting. this means that time accounted in user, kernel or
+       idle will also include time spent in interrupt.  for netperf's
+       porpoises we do not really care about that for user and kernel,
+       but we certainly do care for idle.  the $64B question becomes -
+       how to "correct" for this?
+
+       we could just subtract interrupt time from idle.  that has the
+       virtue of simplicity and also "punishes" Sun for doing
+       something that seems to be so stupid.  however, we probably
+       have to be "fair" even to the allegedly stupid so the other
+       mechanism, suggested by a Sun engineer is to subtract interrupt
+       time from each of user, kernel and idle in proportion to their
+       numbers.  then we sum the corrected user, kernel and idle along
+       with the interrupt time and use that to calculate a new idle
+       percentage and thus a CPU util percentage.
+
+       that is what we will attempt to do here.  raj 2005-01-28 
+
+       of course, we also have to wonder what we should do if there is
+       more interrupt time than the sum of user, kernel and idle.
+       that is a theoretical possibility I suppose, but for the
+       time-being, one that we will blythly ignore, except perhaps for
+       a quick check. raj 2005-01-31 
+    */
+    
+    /* we ass-u-me that these counters will never wrap during a
+       netperf run.  this may not be a particularly safe thing to
+       do. raj 2005-01-28 */
+    delta_cpu_counters[i].idle = ending_cpu_counters[i].idle -
+      starting_cpu_counters[i].idle;
+    delta_cpu_counters[i].user = ending_cpu_counters[i].user -
+      starting_cpu_counters[i].user;
+    delta_cpu_counters[i].kernel = ending_cpu_counters[i].kernel -
+      starting_cpu_counters[i].kernel;
+    delta_cpu_counters[i].interrupt = ending_cpu_counters[i].interrupt -
+      starting_cpu_counters[i].interrupt;
+    
+    if (debug) {
+      print_cpu_time_counters("delta_cpu_counters",i,delta_cpu_counters);
+    }
+
+    /* for this summation, we do not include interrupt time */
+    total_cpu_nsec = 
+      delta_cpu_counters[i].idle +
+      delta_cpu_counters[i].user +
+      delta_cpu_counters[i].kernel;
+
+    if (debug) {
+      fprintf(where,"total_cpu_nsec %llu\n",total_cpu_nsec);
+    }
+
+    if (delta_cpu_counters[i].interrupt > total_cpu_nsec) {
+      /* we are not in Kansas any more Toto, and I am not quite sure
+	 the best way to get our tails out of here so let us just
+	 punt. raj 2005-01-31 */
+      fprintf(where,
+	      "WARNING! WARNING! WARNING! WARNING! WARNING! \n");
+      fprintf(where,
+	      "calc_cpu_util_internal: more interrupt time than others combined!\n");
+      fprintf(where,
+	      "\tso CPU util cannot be estimated\n");
+      fprintf(where,
+	      "\t delta[%d].interrupt %llu\n",i,delta_cpu_counters[i].interrupt);
+      fprintf(where,
+	      "\t delta[%d].idle %llu\n",i,delta_cpu_counters[i].idle);
+      fprintf(where,
+	      "\t delta[%d].user %llu\n",i,delta_cpu_counters[i].user);
+      fprintf(where,
+	      "\t delta[%d].kernel %llu\n",i,delta_cpu_counters[i].kernel);
+      fflush(where);
+      
+      lib_local_cpu_util = -1.0;
+      lib_local_per_cpu_util[i] = -1.0;
+      return -1.0;
+    }
+
+    /* and now some fun with integer math.  i initially tried to
+       promote things to long doubled but that didn't seem to result
+       in happiness and joy. raj 2005-01-28 */
+
+    fraction_idle = 
+      (delta_cpu_counters[i].idle * CALC_ACCURACY) / total_cpu_nsec;
+
+    fraction_user = 
+      (delta_cpu_counters[i].user * CALC_ACCURACY) / total_cpu_nsec;
+
+    fraction_kernel = 
+      (delta_cpu_counters[i].kernel * CALC_ACCURACY) / total_cpu_nsec;
+
+    /* ok, we have our fractions, now we want to take that fraction of
+       the interrupt time and subtract that from the bucket. */
+
+    interrupt_idle =  ((delta_cpu_counters[i].interrupt * fraction_idle) / 
+		       CALC_ACCURACY);
+
+    interrupt_user = ((delta_cpu_counters[i].interrupt * fraction_user) / 
+		      CALC_ACCURACY);
+
+    interrupt_kernel = ((delta_cpu_counters[i].interrupt * fraction_kernel) / 
+			CALC_ACCURACY);
+
+    if (debug) {
+      fprintf(where,
+	      "\tfraction_idle %llu interrupt_idle %llu\n",
+	      fraction_idle,
+	      interrupt_idle);
+      fprintf(where,
+	      "\tfraction_user %llu interrupt_user %llu\n",
+	      fraction_user,
+	      interrupt_user);
+      fprintf(where,"\tfraction_kernel %llu interrupt_kernel %llu\n",
+	      fraction_kernel,
+	      interrupt_kernel);
+    }
+
+    corrected_cpu_counters[i].idle = delta_cpu_counters[i].idle - 
+      interrupt_idle;
+
+    corrected_cpu_counters[i].user = delta_cpu_counters[i].user - 
+      interrupt_user;
+
+    corrected_cpu_counters[i].kernel = delta_cpu_counters[i].kernel - 
+      interrupt_kernel;
+
+    corrected_cpu_counters[i].interrupt = delta_cpu_counters[i].interrupt;
+		  
+    if (debug) {
+      print_cpu_time_counters("corrected_cpu_counters",
+			      i,
+			      corrected_cpu_counters);
+    }
+
+    /* I was going to checkfor going less than zero, but since all the
+       calculations are in unsigned quantities that would seem to be a
+       triffle silly... raj 2005-01-28 */
+
+    /* ok, now we sum the numbers again, this time including interrupt
+       */
+
+    total_cpu_nsec = 
+      corrected_cpu_counters[i].idle +
+      corrected_cpu_counters[i].user +
+      corrected_cpu_counters[i].kernel +
+      corrected_cpu_counters[i].interrupt;
+
+    /* and recalculate our fractions we are really only going to use
+       fraction_idle, but lets calculate the rest just for the heck of
+       it. one day we may want to display them. raj 2005-01-28 */
+    
+    /* multiply by 100 and divide by total and you get whole
+       percentages. multiply by 1000 and divide by total and you get
+       tenths of percentages.  multiply by 10000 and divide by total
+       and you get hundredths of percentages. etc etc etc raj
+       2005-01-28 */
+    fraction_idle = 
+      (corrected_cpu_counters[i].idle * CALC_ACCURACY) / total_cpu_nsec;
+
+    fraction_user = 
+      (corrected_cpu_counters[i].user * CALC_ACCURACY) / total_cpu_nsec;
+
+    fraction_kernel = 
+      (corrected_cpu_counters[i].kernel * CALC_ACCURACY) / total_cpu_nsec;
+
+    fraction_interrupt = 
+      (corrected_cpu_counters[i].interrupt * CALC_ACCURACY) / total_cpu_nsec;
+
+    if (debug) {
+      fprintf(where,"\tfraction_idle %lu\n",fraction_idle);
+      fprintf(where,"\tfraction_user %lu\n",fraction_user);
+      fprintf(where,"\tfraction_kernel %lu\n",fraction_kernel);
+      fprintf(where,"\tfraction_interrupt %lu\n",fraction_interrupt);
+    }
+
+    /* and finally, what is our CPU utilization? */
+    lib_local_per_cpu_util[i] = 100.0 - (((float)fraction_idle / 
+					  (float)CALC_ACCURACY) * 100.0);
+    if (debug) {
+      fprintf(where,
+	      "lib_local_per_cpu_util[%d] %g\n",
+	      i,
+	      lib_local_per_cpu_util[i]);
+    }
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+  }
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  lib_local_cpu_util *= correction_factor;
+  return lib_local_cpu_util;
+
+
+}
+
+void
+cpu_start_internal(void)
+{
+  get_cpu_time_counters(starting_cpu_counters);
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_time_counters(ending_cpu_counters);
+}
diff --git a/netcpu_looper.c b/netcpu_looper.c
new file mode 100644
index 0000000..b76c7c9
--- /dev/null
+++ b/netcpu_looper.c
@@ -0,0 +1,656 @@
+char   netcpu_looper_id[]="\
+@(#)netcpu_looper.c (c) Copyright 2005-2007. Version 2.4.3";
+
+/* netcpu_looper.c
+  
+   Implement the soaker process specific portions of netperf CPU
+   utilization measurements. These are broken-out into a separate file
+   to make life much nicer over in netlib.c which had become a maze of
+   twisty, CPU-util-related, #ifdefs, all different.  raj 2005-01-26
+   */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#if defined(HAVE_MMAP) || defined(HAVE_SYS_MMAN_H)
+# include <sys/mman.h>
+#else
+# error netcpu_looper requires mmap
+#endif
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+#endif
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+#include "netsh.h"
+#include "netlib.h"
+
+#define PAGES_PER_CHILD 2
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibrarion to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+static uint64_t  lib_start_count[MAXCPUS];
+static uint64_t  lib_end_count[MAXCPUS];
+
+static int *cpu_mappings;
+
+static int lib_idle_fd;
+static uint64_t *lib_idle_address[MAXCPUS];
+static long     *lib_base_pointer;
+static pid_t     lib_idle_pids[MAXCPUS];
+static int       lib_loopers_running=0;
+
+/* we used to use this code to bind the loopers, but since we have
+   decided to enable processor affinity for the actual
+   netperf/netserver processes we will use that affinity routine,
+   which happens to know about more systems than this */
+
+#ifdef NOTDEF
+static void
+bind_to_processor(int child_num)
+{
+  /* This routine will bind the calling process to a particular */
+  /* processor. We are not choosy as to which processor, so it will be */
+  /* the process id mod the number of processors - shifted by one for */
+  /* those systems which name processor starting from one instead of */
+  /* zero. on those systems where I do not yet know how to bind a */
+  /* process to a processor, this routine will be a no-op raj 10/95 */
+
+  /* just as a reminder, this is *only* for the looper processes, not */
+  /* the actual measurement processes. those will, should, MUST float */
+  /* or not float from CPU to CPU as controlled by the operating */
+  /* system defaults. raj 12/95 */
+
+#ifdef __hpux
+#include <sys/syscall.h>
+#include <sys/mp.h>
+
+  int old_cpu = -2;
+
+  if (debug) {
+    fprintf(where,
+            "child %d asking for CPU %d as pid %d with %d CPUs\n",
+            child_num,
+            (child_num % lib_num_loc_cpus),
+            getpid(),
+            lib_num_loc_cpus);
+    fflush(where);
+  }
+
+  SETPROCESS((child_num % lib_num_loc_cpus), getpid());
+  return;
+
+#else
+#if defined(__sun) && defined(__SVR4)
+ /* should only be Solaris */
+#include <sys/processor.h>
+#include <sys/procset.h>
+
+  int old_binding;
+
+  if (debug) {
+    fprintf(where,
+            "bind_to_processor: child %d asking for CPU %d as pid %d with %d CPUs\n",
+            child_num,
+            (child_num % lib_num_loc_cpus),
+            getpid(),
+            lib_num_loc_cpus);
+    fflush(where);
+  }
+
+  if (processor_bind(P_PID,
+                     getpid(),
+                     (child_num % lib_num_loc_cpus), 
+                      &old_binding) != 0) {
+    fprintf(where,"bind_to_processor: unable to perform processor binding\n");
+    fprintf(where,"                   errno %d\n",errno);
+    fflush(where);
+  }
+  return;
+#else
+#ifdef WIN32
+
+  if (!SetThreadAffinityMask(GetCurrentThread(), (ULONG_PTR)1 << (child_num % lib_num_loc_cpus))) {
+    perror("SetThreadAffinityMask failed");
+    fflush(stderr);
+  }
+
+  if (debug) {
+    fprintf(where,
+            "bind_to_processor: child %d asking for CPU %d of %d CPUs\n",
+            child_num,
+            (child_num % lib_num_loc_cpus),
+            lib_num_loc_cpus);
+    fflush(where);
+  }
+
+#endif
+  return;
+#endif /* __sun && _SVR4 */
+#endif /* __hpux */
+}
+#endif
+
+ /* sit_and_spin will just spin about incrementing a value */
+ /* this value will either be in a memory mapped region on Unix shared */
+ /* by each looper process, or something appropriate on Windows/NT */
+ /* (malloc'd or such). This routine is reasonably ugly in that it has */
+ /* priority manipulating code for lots of different operating */
+ /* systems. This routine never returns. raj 1/96 */ 
+
+static void
+sit_and_spin(int child_index)
+
+{
+  uint64_t *my_counter_ptr;
+
+ /* only use C stuff if we are not WIN32 unless and until we */
+ /* switch from CreateThread to _beginthread. raj 1/96 */
+#ifndef WIN32
+  /* we are the child. we could decide to exec some separate */
+  /* program, but that doesn't really seem worthwhile - raj 4/95 */
+  if (debug > 1) {
+    fprintf(where,
+            "Looper child %d is born, pid %d\n",
+            child_index,
+            getpid());
+    fflush(where);
+  }
+  
+#endif /* WIN32 */
+
+  /* reset our base pointer to be at the appropriate offset */
+  my_counter_ptr = (uint64_t *) ((char *)lib_base_pointer + 
+                             (netlib_get_page_size() * 
+                              PAGES_PER_CHILD * child_index));
+  
+  /* in the event we are running on an MP system, it would */
+  /* probably be good to bind the soaker processes to specific */
+  /* processors. I *think* this is the most reasonable thing to */
+  /* do, and would be closes to simulating the information we get */
+  /* on HP-UX with pstat. I could put all the system-specific code */
+  /* here, but will "abstract it into another routine to keep this */
+  /* area more readable. I'll probably do the same thine with the */
+  /* "low pri code" raj 10/95 */
+  
+  /* since we are "flying blind" wrt where we should bind the looper
+     processes, we want to use the cpu_map that was prepared by netlib
+     rather than assume that the CPU ids on the system start at zero
+     and are contiguous. raj 2006-04-03 */
+  bind_to_specific_processor(child_index % lib_num_loc_cpus,1);
+  
+  for (*my_counter_ptr = 0L;
+       ;
+       (*my_counter_ptr)++) {
+    if (!(*lib_base_pointer % 1)) {
+      /* every once and again, make sure that our process priority is */
+      /* nice and low. also, by making system calls, it may be easier */
+      /* for us to be pre-empted by something that needs to do useful */
+      /* work - like the thread of execution actually sending and */
+      /* receiving data across the network :) */
+#ifdef _AIX
+      int pid,prio;
+
+      prio = PRIORITY;
+      pid = getpid();
+      /* if you are not root, this call will return EPERM - why one */
+      /* cannot change one's own priority to  lower value is beyond */
+      /* me. raj 2/26/96 */  
+      setpri(pid, prio);
+#else /* _AIX */
+#ifdef __sgi
+      int pid,prio;
+
+      prio = PRIORITY;
+      pid = getpid();
+      schedctl(NDPRI, pid, prio);
+      sginap(0);
+#else /* __sgi */
+#ifdef WIN32
+      SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_IDLE);
+#else /* WIN32 */
+#if defined(__sun) && defined(__SVR4)
+#include <sys/types.h>
+#include <sys/priocntl.h>
+#include <sys/rtpriocntl.h>
+#include <sys/tspriocntl.h>
+      /* I would *really* like to know how to use priocntl to make the */
+      /* priority low for this looper process. however, either my mind */
+      /* is addled, or the manpage in section two for priocntl is not */
+      /* terribly helpful - for one, it has no examples :( so, if you */
+      /* can help, I'd love to hear from you. in the meantime, we will */
+      /* rely on nice(39). raj 2/26/96 */
+      nice(39);
+#else /* __sun && __SVR4 */
+      nice(39);
+#endif /* __sun && _SVR4 */
+#endif /* WIN32 */
+#endif /* __sgi */
+#endif /* _AIX */
+    }
+  }
+}
+
+
+
+ /* this routine will start all the looper processes or threads for */
+ /* measuring CPU utilization. */
+
+static void
+start_looper_processes()
+{
+
+  unsigned int      i, file_size;
+  
+  /* we want at least two pages for each processor. the */
+  /* child for any one processor will write to the first of his two */
+  /* pages, and the second page will be a buffer in case there is page */
+  /* prefetching. if your system pre-fetches more than a single page, */
+  /* well, you'll have to modify this or live with it :( raj 4/95 */
+
+  file_size = ((netlib_get_page_size() * PAGES_PER_CHILD) * 
+               lib_num_loc_cpus);
+  
+#ifndef WIN32
+
+  /* we we are not using WINDOWS NT (or 95 actually :), then we want */
+  /* to create a memory mapped region so we can see all the counting */
+  /* rates of the loopers */
+
+  /* could we just use an anonymous memory region for this? it is */
+  /* possible that using a mmap()'ed "real" file, while convenient for */
+  /* debugging, could result in some filesystem activity - like */
+  /* metadata updates? raj 4/96 */
+  lib_idle_fd = open("/tmp/netperf_cpu",O_RDWR | O_CREAT | O_EXCL);
+  
+  if (lib_idle_fd == -1) {
+    fprintf(where,"create_looper: file creation; errno %d\n",errno);
+    fflush(where);
+    exit(1);
+  }
+  
+  if (chmod("/tmp/netperf_cpu",0644) == -1) {
+    fprintf(where,"create_looper: chmod; errno %d\n",errno);
+    fflush(where);
+    exit(1);
+  }
+  
+  /* with the file descriptor in place, lets be sure that the file is */
+  /* large enough. */
+  
+  if (truncate("/tmp/netperf_cpu",file_size) == -1) {
+    fprintf(where,"create_looper: truncate: errno %d\n",errno);
+    fflush(where);
+    exit(1);
+  }
+  
+  /* the file should be large enough now, so we can mmap it */
+  
+  /* if the system does not have MAP_VARIABLE, just define it to */
+  /* be zero. it is only used/needed on HP-UX (?) raj 4/95 */
+#ifndef MAP_VARIABLE
+#define MAP_VARIABLE 0x0000
+#endif /* MAP_VARIABLE */
+#ifndef MAP_FILE
+#define MAP_FILE 0x0000
+#endif /* MAP_FILE */
+  if ((lib_base_pointer = (long *)mmap(NULL,
+                                       file_size,
+                                       PROT_READ | PROT_WRITE,
+                                       MAP_FILE | MAP_SHARED | MAP_VARIABLE,
+                                       lib_idle_fd,
+                                       0)) == (long *)-1) {
+    fprintf(where,"create_looper: mmap: errno %d\n",errno);
+    fflush(where);
+    exit(1);
+  }
+  
+
+  if (debug > 1) {
+    fprintf(where,"num CPUs %d, file_size %d, lib_base_pointer %p\n",
+            lib_num_loc_cpus,
+            file_size,
+            lib_base_pointer);
+    fflush(where);
+  }
+
+  /* we should have a valid base pointer. lets fork */
+  
+  for (i = 0; i < (unsigned int)lib_num_loc_cpus; i++) {
+    switch (lib_idle_pids[i] = fork()) {
+    case -1:
+      perror("netperf: fork");
+      exit(1);
+    case 0:
+      /* we are the child. we could decide to exec some separate */
+      /* program, but that doesn't really seem worthwhile - raj 4/95 */
+
+      signal(SIGTERM, SIG_DFL);
+      sit_and_spin(i);
+
+      /* we should never really get here, but if we do, just exit(0) */
+      exit(0);
+      break;
+    default:
+      /* we must be the parent */
+      lib_idle_address[i] = (uint64_t *) ((char *)lib_base_pointer + 
+                                      (netlib_get_page_size() * 
+                                       PAGES_PER_CHILD * i));
+      if (debug) {
+        fprintf(where,"lib_idle_address[%d] is %p\n",
+                i,
+                lib_idle_address[i]);
+        fflush(where);
+      }
+    }
+  }
+#else
+  /* we are compiled -DWIN32 */
+  if ((lib_base_pointer = malloc(file_size)) == NULL) {
+    fprintf(where,
+            "create_looper_process could not malloc %d bytes\n",
+            file_size);
+    fflush(where);
+    exit(1);
+  }
+
+  /* now, create all the threads */
+  for(i = 0; i < (unsigned int)lib_num_loc_cpus; i++) {
+    long place_holder;
+    if ((lib_idle_pids[i] = CreateThread(0,
+                                         0,
+                                         (LPTHREAD_START_ROUTINE)sit_and_spin,
+                                         (LPVOID)(ULONG_PTR)i,
+                                         0,
+                                         &place_holder)) == NULL ) {
+      fprintf(where,
+              "create_looper_process: CreateThread failed\n");
+      fflush(where);
+      /* I wonder if I need to look for other threads to kill? */
+      exit(1);
+    }
+    lib_idle_address[i] = (long *) ((char *)lib_base_pointer + 
+                                    (netlib_get_page_size() * 
+                                     PAGES_PER_CHILD * i));
+    if (debug) {
+      fprintf(where,"lib_idle_address[%d] is %p\n",
+              i,
+              lib_idle_address[i]);
+      fflush(where);
+    }
+  }
+#endif /* WIN32 */
+
+  /* we need to have the looper processes settled-in before we do */
+  /* anything with them, so lets sleep for say 30 seconds. raj 4/95 */
+
+  sleep(30);
+}
+
+void
+cpu_util_init(void) 
+{
+  cpu_method = LOOPER;
+
+  /* we want to get the looper processes going */
+  if (!lib_loopers_running) {
+    start_looper_processes();
+    lib_loopers_running = 1;
+  }
+
+  return;
+}
+
+/* clean-up any left-over CPU util resources - looper processes,
+   files, whatever.  raj 2005-01-26 */
+void
+cpu_util_terminate() {
+
+#ifdef WIN32
+  /* it would seem that if/when the process exits, all the threads */
+  /* will go away too, so I don't think I need any explicit thread */
+  /* killing calls here. raj 1/96 */
+#else
+
+  int i;
+
+  /* now go through and kill-off all the child processes */
+  for (i = 0; i < lib_num_loc_cpus; i++){
+    /* SIGKILL can leave core files behind - thanks to Steinar Haug */
+    /* for pointing that out. */
+    kill(lib_idle_pids[i],SIGTERM);
+  }
+  lib_loopers_running = 0;
+  /* reap the children */
+  while(waitpid(-1, NULL, WNOHANG) > 0) { }
+  
+  /* finally, unlink the mmaped file */
+  munmap((caddr_t)lib_base_pointer,
+         ((netlib_get_page_size() * PAGES_PER_CHILD) * 
+          lib_num_loc_cpus));
+  unlink("/tmp/netperf_cpu");
+#endif
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return LOOPER;
+}
+
+ /* calibrate_looper */
+
+ /* Loop a number of iterations, sleeping interval seconds each and */
+ /* count how high the idle counter gets each time. Return  the */
+ /* measured cpu rate to the calling routine. raj 4/95 */
+
+float
+calibrate_idle_rate (int iterations, int interval)
+{
+
+  uint64_t
+    firstcnt[MAXCPUS],
+    secondcnt[MAXCPUS];
+
+  float 
+    elapsed,
+    temp_rate,
+    rate[MAXTIMES],
+    local_maxrate;
+
+  long  
+    sec,
+    usec;
+
+  int   
+    i,
+    j;
+  
+  struct  timeval time1, time2 ;
+  struct  timezone tz;
+  
+  if (iterations > MAXTIMES) {
+    iterations = MAXTIMES;
+  }
+
+  local_maxrate = (float)-1.0;
+  
+  for(i = 0; i < iterations; i++) {
+    rate[i] = (float)0.0;
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      firstcnt[j] = *(lib_idle_address[j]);
+    }
+    gettimeofday (&time1, &tz);
+    sleep(interval);
+    gettimeofday (&time2, &tz);
+
+    if (time2.tv_usec < time1.tv_usec)
+      {
+        time2.tv_usec += 1000000;
+        time2.tv_sec -=1;
+      }
+    sec = time2.tv_sec - time1.tv_sec;
+    usec = time2.tv_usec - time1.tv_usec;
+    elapsed = (float)sec + ((float)usec/(float)1000000.0);
+    
+    if(debug) {
+      fprintf(where, "Calibration for counter run: %d\n",i);
+      fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
+      fprintf(where,"\telapsed time = %g\n",elapsed);
+    }
+
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      secondcnt[j] = *(lib_idle_address[j]);
+      if(debug) {
+        /* I know that there are situations where compilers know about */
+        /* long long, but the library fucntions do not... raj 4/95 */
+        fprintf(where,
+                "\tfirstcnt[%d] = 0x%8.8lx%8.8lx secondcnt[%d] = 0x%8.8lx%8.8lx\n",
+                j,
+                (uint32_t)(firstcnt[j]>>32),
+                (uint32_t)(firstcnt[j]&0xffffffff),
+                j,
+                (uint32_t)(secondcnt[j]>>32),
+                (uint32_t)(secondcnt[j]&0xffffffff));
+      }
+      /* we assume that it would wrap no more than once. we also */
+      /* assume that the result of subtracting will "fit" raj 4/95 */
+      temp_rate = (secondcnt[j] >= firstcnt[j]) ?
+        (float)(secondcnt[j] - firstcnt[j])/elapsed : 
+          (float)(secondcnt[j]-firstcnt[j]+MAXLONG)/elapsed;
+      if (temp_rate > rate[i]) rate[i] = temp_rate;
+      if(debug) {
+        fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
+        fflush(where);
+      }
+      if (local_maxrate < rate[i]) local_maxrate = rate[i];
+    }
+  }
+  if(debug) {
+    fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
+    fflush(where);
+  }
+  return local_maxrate;
+}
+
+
+void
+get_cpu_idle (uint64_t *res)
+{
+  int i;
+
+  for (i = 0; i < lib_num_loc_cpus; i++){
+    res[i] = *lib_idle_address[i];
+  }
+
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+  float correction_factor;
+  float actual_rate;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+
+    /* it would appear that on some systems, in loopback, nice is
+     *very* effective, causing the looper process to stop dead in its
+     tracks. if this happens, we need to ensure that the calculation
+     does not go south. raj 6/95 and if we run completely out of idle,
+     the same thing could in theory happen to the USE_KSTAT path. raj
+     8/2000 */ 
+    
+    if (lib_end_count[i] == lib_start_count[i]) {
+      lib_end_count[i]++;
+    }
+    
+    actual_rate = (lib_end_count[i] > lib_start_count[i]) ?
+      (float)(lib_end_count[i] - lib_start_count[i])/lib_elapsed :
+      (float)(lib_end_count[i] - lib_start_count[i] +
+	      MAXLONG)/ lib_elapsed;
+    if (debug) {
+      fprintf(where,
+              "calc_cpu_util: actual_rate on processor %d is %f start 0x%8.8lx%8.8lx end 0x%8.8lx%8.8lx\n",
+              i,
+              actual_rate,
+              (uint32_t)(lib_start_count[i]>>32),
+              (uint32_t)(lib_start_count[i]&0xffffffff),
+              (uint32_t)(lib_end_count[i]>>32),
+              (uint32_t)(lib_end_count[i]&0xffffffff));
+    }
+    lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) /
+      lib_local_maxrate * 100;
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+  }
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  lib_local_cpu_util *= correction_factor;
+  return lib_local_cpu_util;
+
+
+}
+void
+cpu_start_internal(void)
+{
+  get_cpu_idle(lib_start_count);
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_idle(lib_end_count);
+}
diff --git a/netcpu_none.c b/netcpu_none.c
new file mode 100644
index 0000000..f71b240
--- /dev/null
+++ b/netcpu_none.c
@@ -0,0 +1,67 @@
+char   netcpu_none_id[]="\
+@(#)netcpu_none.c (c) Copyright 2005, Hewlett-Packard Company, Version 2.4.0";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#include "netsh.h"
+#include "netlib.h"
+
+void
+cpu_util_init(void) 
+{
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return CPU_UNKNOWN;
+}
+
+void
+get_cpu_idle(uint64_t *res)
+{
+  return;
+}
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  return 0.0;
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  return -1.0;
+}
+
+void
+cpu_start_internal(void)
+{
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  return;
+}
diff --git a/netcpu_ntperf.c b/netcpu_ntperf.c
new file mode 100644
index 0000000..e8d8f76
--- /dev/null
+++ b/netcpu_ntperf.c
@@ -0,0 +1,497 @@
+char   netcpu_ntperf_id[]="\
+@(#)netcpu_ntperf.c (c) Copyright 2005-2007, Hewlett-Packard Company, Version 2.4.3";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if 0
+#include <limits.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#endif
+
+#include <assert.h>
+
+#include <process.h>
+#include <time.h>
+
+#include <windows.h>
+#include <assert.h>
+
+#include <winsock2.h>
+// If you are trying to compile on Windows 2000 or NT 4.0 you may
+// need to define DONT_IPV6 in the "sources" files.
+#ifndef DONT_IPV6
+#include <ws2tcpip.h>
+#endif
+
+#include "netsh.h"
+#include "netlib.h"
+
+//
+// System CPU time information class.
+// Used to get CPU time information.
+//
+//     SDK\inc\ntexapi.h 
+// Function x8:   SystemProcessorPerformanceInformation
+// DataStructure: SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION 
+//
+
+#define SystemProcessorPerformanceInformation 0x08
+
+typedef struct 
+{
+        LARGE_INTEGER   IdleTime;
+        LARGE_INTEGER   KernelTime;
+        LARGE_INTEGER   UserTime;
+        LARGE_INTEGER   DpcTime;
+        LARGE_INTEGER   InterruptTime;
+        LONG                    InterruptCount;
+} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
+
+//
+// Calls to get the information
+//
+typedef ULONG (__stdcall *NT_QUERY_SYSTEM_INFORMATION)( 
+                                                                                        ULONG SystemInformationClass, 
+                                                                                        PVOID SystemInformation, 
+                                                                                        ULONG SystemInformationLength,
+                                                                                        PULONG ReturnLength 
+                                                                                        );
+
+NT_QUERY_SYSTEM_INFORMATION NtQuerySystemInformation = NULL;
+
+
+static LARGE_INTEGER TickHz = {0,0};
+
+_inline LARGE_INTEGER ReadPerformanceCounter(VOID)
+{
+        LARGE_INTEGER Counter;
+        QueryPerformanceCounter(&Counter);
+
+        return(Counter);
+}       // ReadperformanceCounter
+
+
+/* The NT performance data is accessed through the NtQuerySystemInformation
+   call.  References to the PDH.DLL have been deleted.  This structure
+   is the root for these data structures. */
+
+typedef struct sPerfObj 
+{
+        LARGE_INTEGER   StartTime;
+        LARGE_INTEGER   EndTime;
+        SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION StartInfo[MAXCPUS +1];
+        SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION EndInfo[MAXCPUS +1];
+} PerfObj, *PPerfObj;
+
+static PerfObj *PerfCntrs;
+
+// Forward declarations
+
+PerfObj *InitPerfCntrs();
+void RestartPerfCntrs(PerfObj *PerfCntrs);
+double ReportPerfCntrs(PerfObj *PerfCntrs);  /* returns CPU utilization */
+void ClosePerfCntrs(PerfObj *PerfCntrs);
+
+
+void
+cpu_util_init(void) 
+{
+  if (NtQuerySystemInformation == NULL) {
+    // Open the performance counter interface
+    PerfCntrs = InitPerfCntrs();
+  }
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return NT_METHOD;
+}
+
+typedef unsigned __int64    uint64_t;
+
+void
+get_cpu_idle(uint64_t *res)
+{
+  RestartPerfCntrs(PerfCntrs);
+  return;
+}
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  return (float)0.0;
+}
+
+
+/*
+  InitPerfCntrs() - 
+
+  Changed to no longer access the NT performance registry interfaces.
+  A direct call to NtQuerySystemInformation (an undocumented NT API)
+  is made instead.  Parameters determined by decompilation of ntkrnlmp
+  and ntdll.
+*/
+
+
+PerfObj *InitPerfCntrs()
+{
+  PerfObj *NewPerfCntrs;
+  DWORD NTVersion;
+  DWORD status;
+  SYSTEM_INFO SystemInfo;
+
+  GetSystemInfo(&SystemInfo);
+
+  NewPerfCntrs = (PerfObj *)GlobalAlloc(GPTR, sizeof(PerfObj));
+  assert(NewPerfCntrs != NULL);
+  
+  ZeroMemory((PCHAR)NewPerfCntrs, sizeof(PerfObj));
+  
+  // get NT version
+  NTVersion = GetVersion();
+  if (NTVersion >= 0x80000000) 
+    {
+      fprintf(stderr, "Not running on Windows NT\n");
+      exit(1);
+    }
+  
+  // locate the calls we need in NTDLL
+  //Lint 
+  NtQuerySystemInformation = 
+    (NT_QUERY_SYSTEM_INFORMATION)GetProcAddress( GetModuleHandle("ntdll.dll"),
+						 "NtQuerySystemInformation" );
+
+  if ( !(NtQuerySystemInformation) )
+    {
+      //Lint
+      status = GetLastError();
+      fprintf(stderr, "GetProcAddressFailed, status: %X\n", status);
+      exit(1);
+    }
+  
+  // setup to measure timestamps with the high resolution timers.
+  if (QueryPerformanceFrequency(&TickHz) == FALSE)
+    {
+      fprintf(stderr,"MAIN - QueryPerformanceFrequency Failed!\n");
+      exit(2);   
+    }
+  
+  RestartPerfCntrs(NewPerfCntrs);
+  
+  return(NewPerfCntrs);
+}  /* InitPerfCntrs */
+
+/*
+  RestartPerfCntrs() -
+
+  The Performance counters must be read twice to produce rate and
+  percentage results.  This routine is called before the start of a
+  benchmark to establish the initial counters.  It must be called a
+  second time after the benchmark completes to collect the final state
+  of the performance counters.  ReportPerfCntrs is called to print the
+  results after the benchmark completes.
+*/
+
+void RestartPerfCntrs(PerfObj *PerfCntrs)
+{
+  DWORD returnLength = 0;  //Lint
+  DWORD returnNumCPUs;  //Lint
+  DWORD i;
+  
+  DWORD status;
+  SYSTEM_INFO SystemInfo;
+
+  GetSystemInfo(&SystemInfo);
+  
+  // Move previous data from EndInfo to StartInfo.
+  CopyMemory((PCHAR)&PerfCntrs->StartInfo[0],
+	     (PCHAR)&PerfCntrs->EndInfo[0],
+	     sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)*(MAXCPUS +1));
+  
+  PerfCntrs->StartTime = PerfCntrs->EndTime;
+  
+  // get the current CPUTIME information
+  if ( (status = NtQuerySystemInformation( SystemProcessorPerformanceInformation,
+					   (PCHAR)&PerfCntrs->EndInfo[0], sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)*MAXCPUS,
+					   &returnLength )) != 0) 
+    {
+      fprintf(stderr, "NtQuery failed, status: %X\n", status);
+      exit(1);
+    }
+  
+  PerfCntrs->EndTime = ReadPerformanceCounter();
+  
+  // Validate that NtQuery returned a reasonable amount of data
+  if ((returnLength % sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)) != 0)
+    {
+      fprintf(stderr, "NtQuery didn't return expected amount of data\n");
+      fprintf(stderr, "Expected a multiple of %i, returned %i\n",
+	      sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), returnLength);
+      exit(1);
+    }
+  returnNumCPUs = returnLength / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION); 
+  
+  if (returnNumCPUs != (int)SystemInfo.dwNumberOfProcessors)
+    {
+      fprintf(stderr, "NtQuery didn't return expected amount of data\n");
+      fprintf(stderr, "Expected data for %i CPUs, returned %i\n",
+	      (int)SystemInfo.dwNumberOfProcessors, returnNumCPUs);
+      exit(1);
+    }
+  
+  // Zero entries not returned by NtQuery
+  ZeroMemory((PCHAR)&PerfCntrs->EndInfo[returnNumCPUs],
+	     sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)*
+	     (MAXCPUS +1 - returnNumCPUs));
+  
+  // Total all of the CPUs
+  //      KernelTime needs to be fixed-up; it includes both idle &
+  // true kernel time 
+  //  Note that kernel time also includes DpcTime & InterruptTime, but
+  // I like this. 
+  for (i=0; i < returnNumCPUs; i++)
+    {
+      PerfCntrs->EndInfo[i].KernelTime.QuadPart         -= PerfCntrs->EndInfo[i].IdleTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].IdleTime.QuadPart     += PerfCntrs->EndInfo[i].IdleTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].KernelTime.QuadPart   += PerfCntrs->EndInfo[i].KernelTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].UserTime.QuadPart     += PerfCntrs->EndInfo[i].UserTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].DpcTime.QuadPart      += PerfCntrs->EndInfo[i].DpcTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].InterruptTime.QuadPart += PerfCntrs->EndInfo[i].InterruptTime.QuadPart;
+      PerfCntrs->EndInfo[MAXCPUS].InterruptCount                += PerfCntrs->EndInfo[i].InterruptCount;
+    }
+  
+}   /* RestartPerfCntrs */
+
+/*
+  ReportPerfCntrs() -
+  This routine reports the results of the various performance
+  counters. 
+*/
+
+double ReportPerfCntrs(PerfObj *PerfCntrs)
+{
+  double tot_CPU_Util;
+  int i;
+  int duration;  // in 100 usecs
+  
+  LARGE_INTEGER ActualDuration;
+  
+  SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION        DeltaInfo[MAXCPUS +1];  
+  
+  LARGE_INTEGER   TotalCPUTime[MAXCPUS +1];         
+  
+  SYSTEM_INFO SystemInfo;
+
+  GetSystemInfo(&SystemInfo);
+
+  for (i=0; i <= MAXCPUS; i++)
+    {
+      DeltaInfo[i].IdleTime.QuadPart    = PerfCntrs->EndInfo[i].IdleTime.QuadPart -
+	PerfCntrs->StartInfo[i].IdleTime.QuadPart;
+      DeltaInfo[i].KernelTime.QuadPart          = PerfCntrs->EndInfo[i].KernelTime.QuadPart -
+	PerfCntrs->StartInfo[i].KernelTime.QuadPart;
+      DeltaInfo[i].UserTime.QuadPart    = PerfCntrs->EndInfo[i].UserTime.QuadPart -
+	PerfCntrs->StartInfo[i].UserTime.QuadPart;
+      DeltaInfo[i].DpcTime.QuadPart     = PerfCntrs->EndInfo[i].DpcTime.QuadPart -
+	PerfCntrs->StartInfo[i].DpcTime.QuadPart;
+      DeltaInfo[i].InterruptTime.QuadPart = PerfCntrs->EndInfo[i].InterruptTime.QuadPart -
+	PerfCntrs->StartInfo[i].InterruptTime.QuadPart;
+      DeltaInfo[i].InterruptCount               = PerfCntrs->EndInfo[i].InterruptCount -
+	PerfCntrs->StartInfo[i].InterruptCount;
+      
+      TotalCPUTime[i].QuadPart =      
+	DeltaInfo[i].IdleTime.QuadPart +
+	DeltaInfo[i].KernelTime.QuadPart +
+	DeltaInfo[i].UserTime.QuadPart;
+      // KernelTime already includes DpcTime & InterruptTime!
+      // + DeltaInfo[i].DpcTime.QuadPart  +
+      //  DeltaInfo[i].InterruptTime.QuadPart;
+    }
+  
+  tot_CPU_Util = 100.0*(1.0 - (double)DeltaInfo[MAXCPUS].IdleTime.QuadPart/(double)TotalCPUTime[MAXCPUS].QuadPart);  //Lint
+  
+  // Re-calculate duration, since we may have stoped early due to cntr-C.
+  ActualDuration.QuadPart = PerfCntrs->EndTime.QuadPart - 
+    PerfCntrs->StartTime.QuadPart;
+  
+  // convert to 1/10 milliseconds (100 usec) 
+  ActualDuration.QuadPart = (ActualDuration.QuadPart*10000)/TickHz.QuadPart;
+  duration = ActualDuration.LowPart;
+  
+  if (verbosity > 1)
+    {
+      fprintf(where,"ActualDuration (ms): %d\n", duration/10);
+    }
+  
+  if (verbosity > 1)
+    {
+      fprintf(where, "%% CPU    _Total");
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t CPU %i", i);
+	    }
+	}
+      fprintf(where, "\n");
+      
+      fprintf(where, "Busy      %5.2f", tot_CPU_Util);
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.2f", 
+		      100.0*(1.0 - (double)DeltaInfo[i].IdleTime.QuadPart/(double)TotalCPUTime[i].QuadPart));  //Lint
+	    }
+	}
+      fprintf(where, "\n");
+      
+      fprintf(where, "Kernel    %5.2f", 
+	      100.0*(double)DeltaInfo[MAXCPUS].KernelTime.QuadPart/(double)TotalCPUTime[MAXCPUS].QuadPart);  //Lint
+      
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.2f", 
+		      100.0*(double)DeltaInfo[i].KernelTime.QuadPart/(double)TotalCPUTime[i].QuadPart);  //Lint
+	    }
+	}
+      fprintf(where, "\n");
+      
+      fprintf(where, "User      %5.2f", 
+	      100.0*(double)DeltaInfo[MAXCPUS].UserTime.QuadPart/(double)TotalCPUTime[MAXCPUS].QuadPart);
+      
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.2f", 
+		      100.0*(double)DeltaInfo[i].UserTime.QuadPart/TotalCPUTime[i].QuadPart);  //Lint
+	    }
+	}
+      fprintf(where, "\n");
+      
+      fprintf(where, "Dpc       %5.2f", 
+	      100.0*(double)DeltaInfo[MAXCPUS].DpcTime.QuadPart/(double)TotalCPUTime[MAXCPUS].QuadPart);  //Lint
+      
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.2f", 
+		      100.0*(double)DeltaInfo[i].DpcTime.QuadPart/(double)TotalCPUTime[i].QuadPart);  //Lint
+	    }
+	}
+      fprintf(where, "\n");
+      
+      fprintf(where, "Interrupt %5.2f", 
+	      100.0*(double)DeltaInfo[MAXCPUS].InterruptTime.QuadPart/(double)TotalCPUTime[MAXCPUS].QuadPart);  //Lint
+      
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.2f", 
+		      100.0*(double)DeltaInfo[i].InterruptTime.QuadPart/TotalCPUTime[i].QuadPart);  //Lint
+	    }
+	}
+      fprintf(where, "\n\n");
+      
+      fprintf(where, "Interrupt/Sec. %5.1f", 
+	      (double)DeltaInfo[MAXCPUS].InterruptCount*10000.0/(double)duration);
+      
+      if ((int)SystemInfo.dwNumberOfProcessors > 1)
+	{
+	  for (i=0; i < (int)SystemInfo.dwNumberOfProcessors; i++)
+	    {
+	      fprintf(where, "\t %5.1f", 
+		      (double)DeltaInfo[i].InterruptCount*10000.0/(double)duration);
+	    }
+	}
+      fprintf(where, "\n\n");
+      fflush(where);
+    }
+  
+  return (tot_CPU_Util);
+  
+}  /* ReportPerfCntrs */
+
+/*
+  ClosePerfCntrs() -  
+
+  This routine cleans up the performance counter APIs.
+*/
+
+void ClosePerfCntrs(PerfObj *PerfCntrs)
+{
+        GlobalFree(PerfCntrs);
+
+        NtQuerySystemInformation = NULL;
+}   /* ClosePerfCntrs */
+
+void
+cpu_start_internal(void)
+{
+  RestartPerfCntrs(PerfCntrs);

+}
+
+void
+cpu_stop_internal(void)
+{
+  RestartPerfCntrs(PerfCntrs);

+}
+
+float
+calc_cpu_util_internal(float elapsed_time) 
+{
+  float correction_factor;
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  if (debug) {
+    fprintf(where, "correction factor: %f\n", correction_factor);
+  }
+
+  lib_local_cpu_util = (float)ReportPerfCntrs(PerfCntrs);
+  lib_local_cpu_util *= correction_factor;
+  return lib_local_cpu_util;
+
+}
diff --git a/netcpu_osx.c b/netcpu_osx.c
new file mode 100644
index 0000000..2132be1
--- /dev/null
+++ b/netcpu_osx.c
@@ -0,0 +1,149 @@
+char   netcpu_sysctl_id[]="\
+@(#)netcpu_osx.c  Version 2.4.3";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+#if HAVE_LIMITS_H
+# include <limits.h>
+# ifndef LONG_LONG_MAX
+#  define LONG_LONG_MAX LLONG_MAX
+# endif /* LONG_LONG_MAX */
+#endif
+
+
+#include <errno.h>
+
+#include <mach/host_info.h>
+#include <mach/mach_types.h>
+/* it would seem that on 10.3.9 mach_msg_type_number_t is in
+   <mach/message.h> so we'll see about including that one too.
+   hopefully it still exists in 10.4. if not, we will need to add some
+   .h file checks in configure so we can use "HAVE_mumble" ifdefs
+   here */
+#include <mach/message.h>
+
+#include "netsh.h"
+#include "netlib.h"
+
+#define UNSIGNED_DIFFERENCE(x,y) (x >= y ? x - y : (0 - y) + x )
+
+static host_cpu_load_info_data_t lib_start_ticks;
+static host_cpu_load_info_data_t lib_end_ticks;
+
+static mach_port_t lib_host_port;
+
+void
+cpu_util_init(void) 
+{
+  lib_host_port = mach_host_self();
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  mach_port_deallocate(lib_host_port);
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return OSX;
+}
+
+void
+get_cpu_idle(uint64_t *res)
+{
+    return;
+}
+
+void
+get_host_ticks(host_cpu_load_info_t info)
+{
+  mach_msg_type_number_t count;
+
+  count = HOST_CPU_LOAD_INFO_COUNT;
+  host_statistics(lib_host_port, HOST_CPU_LOAD_INFO, (host_info_t)info, &count);
+  return;
+}
+
+/* calibrate_sysctl  - perform the idle rate calculation using the
+   sysctl call - typically on BSD */
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+    return (float)0.0;   
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  float correction_factor;
+  natural_t	userticks, systicks, idleticks, totalticks;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  if (debug) {
+    fprintf(where, "correction factor: %f\n", correction_factor);
+  }
+
+  userticks = UNSIGNED_DIFFERENCE((lib_end_ticks.cpu_ticks[CPU_STATE_USER] + lib_end_ticks.cpu_ticks[CPU_STATE_NICE]),
+				  (lib_start_ticks.cpu_ticks[CPU_STATE_USER] + lib_start_ticks.cpu_ticks[CPU_STATE_NICE]));
+  systicks = UNSIGNED_DIFFERENCE(lib_end_ticks.cpu_ticks[CPU_STATE_SYSTEM], lib_start_ticks.cpu_ticks[CPU_STATE_SYSTEM]);
+  idleticks = UNSIGNED_DIFFERENCE(lib_end_ticks.cpu_ticks[CPU_STATE_IDLE], lib_start_ticks.cpu_ticks[CPU_STATE_IDLE]);
+  totalticks = userticks + systicks + idleticks;
+
+  lib_local_cpu_util = ((float)userticks + (float)systicks)/(float)totalticks * 100.0f;
+  lib_local_cpu_util *= correction_factor;
+
+  return lib_local_cpu_util;
+
+}
+void
+cpu_start_internal(void)
+{
+    get_host_ticks(&lib_start_ticks);
+}
+
+void
+cpu_stop_internal(void)
+{
+    get_host_ticks(&lib_end_ticks);
+}
diff --git a/netcpu_perfstat.c b/netcpu_perfstat.c
new file mode 100644
index 0000000..f928a25
--- /dev/null
+++ b/netcpu_perfstat.c
@@ -0,0 +1,351 @@
+char   netcpu_perfstat_id[]="\
+@(#)netcpu_perfstat.c Version 2.4.0";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+# ifndef LONG_LONG_MAX
+#  define LONG_LONG_MAX LLONG_MAX
+# endif /* LONG_LONG_MAX */
+#endif 
+
+#include <errno.h>
+
+#include "netsh.h"
+#include "netlib.h"
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibration to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+static uint64_t  lib_start_count[MAXCPUS];
+static uint64_t  lib_end_count[MAXCPUS];
+
+
+void
+cpu_util_init(void) 
+{
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return PERFSTAT;
+}
+
+void
+get_cpu_idle(uint64_t *res)
+{
+  perfstat_cpu_t *perfstat_buffer;
+  perfstat_cpu_t *per_cpu_pointer;
+  perfstat_id_t  name;
+  int i,ret;
+  
+  /* a name of "" will cause us to start from the beginning */
+  strcpy(name.name,"");
+  perfstat_buffer = (perfstat_cpu_t *)malloc(lib_num_loc_cpus *
+					     sizeof(perfstat_cpu_t));
+  if (perfstat_buffer == NULL) {
+    fprintf(where,
+	    "cpu_start: malloc failed errno %d\n",
+	    errno);
+    fflush(where);
+    exit(-1);
+  }
+  
+  /* happiness and joy, keep going */
+  ret = perfstat_cpu(&name,
+		     perfstat_buffer,
+		     sizeof(perfstat_cpu_t),
+		     lib_num_loc_cpus);
+  
+  if ((ret == -1) || 
+      (ret != lib_num_loc_cpus)) {
+    fprintf(where,
+	    "cpu_start: perfstat_cpu failed/count off; errno %d cpus %d count %d\n",
+	    errno,
+	    lib_num_loc_cpus,
+	    ret);
+    fflush(where);
+    exit(-1);
+  }
+  
+  per_cpu_pointer = perfstat_buffer;
+  for (i = 0; i < lib_num_loc_cpus; i++){
+    res[i] = per_cpu_pointer->idle;
+    per_cpu_pointer++;
+  }
+  free(perfstat_buffer);
+  
+  return;
+}
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  unsigned long long
+    firstcnt[MAXCPUS],
+    secondcnt[MAXCPUS];
+
+  float 
+    elapsed,
+    temp_rate,
+    rate[MAXTIMES],
+    local_maxrate;
+
+  long  
+    sec,
+    usec;
+
+  int   
+    i,
+    j;
+  
+  struct  timeval time1, time2 ;
+  struct  timezone tz;
+
+  perfstat_cpu_t  *perfstat_buffer;
+  perfstat_cpu_t  *per_cpu_pointer;
+  perfstat_id_t   name;
+  int ret;
+  
+  if (debug) {
+    fprintf(where,"enter calibrate_perfstat\n");
+    fflush(where);
+  }
+
+  if (iterations > MAXTIMES) {
+    iterations = MAXTIMES;
+  }
+
+  local_maxrate = (float)-1.0;
+  
+  perfstat_buffer = (perfstat_cpu_t *)malloc(lib_num_loc_cpus *
+                                             sizeof(perfstat_cpu_t));
+  if (perfstat_buffer == NULL) {
+    fprintf(where,
+            "calibrate_perfstat: malloc failed errno %d\n",
+            errno);
+    fflush(where);
+    exit(-1);
+  }
+
+  for(i = 0; i < iterations; i++) {
+    rate[i] = (float)0.0;
+    /* a name of "" will cause us to start from the beginning */
+    strcpy(name.name,"");
+     
+    /* happiness and joy, keep going */
+    ret = perfstat_cpu(&name,
+                       perfstat_buffer,
+                       sizeof(perfstat_cpu_t),
+                       lib_num_loc_cpus);
+    
+    if ((ret == -1) || 
+        (ret != lib_num_loc_cpus)) {
+      fprintf(where,
+              "calibrate_perfstat: perfstat_cpu failed/count off; errno %d cpus %d count %d\n",
+              errno,
+              lib_num_loc_cpus,
+              ret);
+      fflush(where);
+      exit(-1);
+    }
+
+    per_cpu_pointer = perfstat_buffer;
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      firstcnt[j] = per_cpu_pointer->idle;
+      per_cpu_pointer++;
+    }
+    gettimeofday (&time1, &tz);
+    sleep(interval);
+    gettimeofday (&time2, &tz);
+
+    if (time2.tv_usec < time1.tv_usec)
+      {
+        time2.tv_usec += 1000000;
+        time2.tv_sec -=1;
+      }
+    sec = time2.tv_sec - time1.tv_sec;
+    usec = time2.tv_usec - time1.tv_usec;
+    elapsed = (float)sec + ((float)usec/(float)1000000.0);
+
+    /* happiness and joy, keep going */
+    ret = perfstat_cpu(&name,
+                       perfstat_buffer,
+                       sizeof(perfstat_cpu_t),
+                       lib_num_loc_cpus);
+    
+    if ((ret == -1) || 
+        (ret != lib_num_loc_cpus)) {
+      fprintf(where,
+              "calibrate_perfstat: perfstat_cpu failed/count off; errno %d cpus %d count %d\n",
+              errno,
+              lib_num_loc_cpus,
+              ret);
+      fflush(where);
+      exit(-1);
+    }
+
+    per_cpu_pointer = perfstat_buffer;
+    
+    if(debug) {
+      fprintf(where, "Calibration for perfstat counter run: %d\n",i);
+      fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
+      fprintf(where,"\telapsed time = %g\n",elapsed);
+    }
+
+    for (j = 0; j < lib_num_loc_cpus; j++) {
+      secondcnt[j] = per_cpu_pointer->idle;
+      per_cpu_pointer++;
+      if(debug) {
+        /* I know that there are situations where compilers know about */
+        /* long long, but the library functions do not... raj 4/95 */
+        fprintf(where,
+                "\tfirstcnt[%d] = 0x%8.8lx%8.8lx secondcnt[%d] = 0x%8.8lx%8.8lx\n",
+                j,
+                firstcnt[j],
+                firstcnt[j],
+                j,
+                secondcnt[j],
+                secondcnt[j]);
+      }
+      /* we assume that it would wrap no more than once. we also */
+      /* assume that the result of subtracting will "fit" raj 4/95 */
+      temp_rate = (secondcnt[j] >= firstcnt[j]) ?
+        (float)(secondcnt[j] - firstcnt[j])/elapsed : 
+          (float)(secondcnt[j]-firstcnt[j]+MAXLONG)/elapsed;
+      if (temp_rate > rate[i]) rate[i] = temp_rate;
+      if(debug) {
+        fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
+        fflush(where);
+      }
+      if (local_maxrate < rate[i]) local_maxrate = rate[i];
+    }
+  }
+  if(debug) {
+    fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
+    fflush(where);
+  }
+  free(perfstat_buffer);
+  return local_maxrate;
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+
+  float actual_rate;
+  float correction_factor;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 +
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  /* this looks just like the looper case. at least I think it */
+  /* should :) raj 4/95 */
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+
+    /* we assume that the two are not more than a long apart. I */
+    /* know that this is bad, but trying to go from long longs to */
+    /* a float (perhaps a double) is boggling my mind right now. */
+    /* raj 4/95 */
+
+    long long
+      diff;
+
+    if (lib_end_count[i] >= lib_start_count[i]) {
+      diff = lib_end_count[i] - lib_start_count[i];
+    }
+    else {
+      diff = lib_end_count[i] - lib_start_count[i] + LONG_LONG_MAX;
+    }
+    actual_rate = (float) diff / lib_elapsed;
+    lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) /
+      lib_local_maxrate * 100;
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+    if (debug) {
+      fprintf(where,
+              "calc_cpu_util: actual_rate on cpu %d is %g max_rate %g cpu %6.2f\n",
+              i,
+              actual_rate,
+              lib_local_maxrate,
+              lib_local_per_cpu_util[i]);
+    }
+  }
+
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  if (debug) {
+    fprintf(where,
+            "calc_cpu_util: average across CPUs is %g\n",lib_local_cpu_util);
+  }
+
+  lib_local_cpu_util *= correction_factor;
+
+  if (debug) {
+    fprintf(where,
+            "calc_cpu_util: returning %g\n",lib_local_cpu_util);
+  }
+
+  return lib_local_cpu_util;
+
+}
+void
+cpu_start_internal(void)
+{
+  get_cpu_idle(lib_start_count);
+  return;
+}
+ 
+void
+cpu_stop_internal(void)
+{
+  get_cpu_idle(lib_end_count);
+}
+
diff --git a/netcpu_procstat.c b/netcpu_procstat.c
new file mode 100644
index 0000000..5bdadea
--- /dev/null
+++ b/netcpu_procstat.c
@@ -0,0 +1,265 @@
+char   netcpu_procstat_id[]="\
+@(#)netcpu_procstat.c (c) Copyright 2005-2007 Version 2.4.3";
+
+/* netcpu_procstat.c
+  
+   Implement the /proc/stat specific portions of netperf CPU
+   utilization measurements. These are broken-out into a separate file
+   to make life much nicer over in netlib.c which had become a maze of
+   twisty, CPU-util-related, #ifdefs, all different.  raj 2005-01-26
+   */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+
+#include <string.h>
+
+#include "netsh.h"
+#include "netlib.h"
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibrarion to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+static uint64_t  lib_start_count[MAXCPUS];
+static uint64_t  lib_end_count[MAXCPUS];
+
+
+/* The max. length of one line of /proc/stat cpu output */
+#define CPU_LINE_LENGTH ((8 * sizeof (long) / 3 + 1) * 4 + 8)
+#define PROC_STAT_FILE_NAME "/proc/stat"
+#define N_CPU_LINES(nr) (nr == 1 ? 1 : 1 + nr)
+
+static int proc_stat_fd = -1;
+static char *proc_stat_buf = NULL;
+static int proc_stat_buflen = 0;
+
+void
+cpu_util_init(void) 
+{
+
+  if (debug) {
+    fprintf(where,
+	    "cpu_util_init enter, proc_stat_fd %d proc_stat_buf %p\n",
+	    proc_stat_fd,
+	    proc_stat_buf);
+    fflush(where);
+  }
+  if (proc_stat_fd < 0) {
+    proc_stat_fd = open (PROC_STAT_FILE_NAME, O_RDONLY, NULL);
+    if (proc_stat_fd < 0) {
+      fprintf (stderr, "Cannot open %s!\n", PROC_STAT_FILE_NAME);
+      exit (1);
+    };
+  };
+
+  if (!proc_stat_buf) {
+    proc_stat_buflen = N_CPU_LINES (lib_num_loc_cpus) * CPU_LINE_LENGTH;
+    if (debug) {
+      fprintf(where,
+	      "lib_num_loc_cpus %d lines %d CPU_LINE_LENGTH %d proc_stat_buflen %d\n",
+	      lib_num_loc_cpus,
+	      N_CPU_LINES(lib_num_loc_cpus),
+	      CPU_LINE_LENGTH,
+	      proc_stat_buflen);
+      fflush(where);
+    }
+    proc_stat_buf = (char *)malloc (proc_stat_buflen);
+    if (!proc_stat_buf) {
+      fprintf (stderr, "Cannot allocate buffer memory!\n");
+      exit (1);
+    }
+  }
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  close(proc_stat_fd);
+  proc_stat_fd = -1;
+  free(proc_stat_buf);
+  proc_stat_buf = NULL;
+  return;
+}
+
+int
+get_cpu_method()
+{
+  return PROC_STAT;
+}
+
+float
+calibrate_idle_rate (int iterations, int interval)
+{
+  if (proc_stat_fd < 0) {
+    proc_stat_fd = open (PROC_STAT_FILE_NAME, O_RDONLY, NULL);
+    if (proc_stat_fd < 0) {
+      fprintf (stderr, "Cannot open %s!\n", PROC_STAT_FILE_NAME);
+      exit (1);
+    };
+  };
+
+  if (!proc_stat_buf) {
+    proc_stat_buflen = N_CPU_LINES (lib_num_loc_cpus) * CPU_LINE_LENGTH;
+    if (debug) {
+      fprintf(where,
+	      "calibrate: lib_num_loc_cpus %d lines %d CPU_LINE_LENGTH %d proc_stat_buflen %d\n",
+	      lib_num_loc_cpus,
+	      N_CPU_LINES(lib_num_loc_cpus),
+	      CPU_LINE_LENGTH,
+	      proc_stat_buflen);
+      fflush(where);
+    }
+    proc_stat_buf = (char *)malloc (proc_stat_buflen);
+    if (!proc_stat_buf) {
+      fprintf (stderr, "Cannot allocate buffer memory!\n");
+      exit (1);
+    };
+  };
+
+  return sysconf (_SC_CLK_TCK);
+}
+
+void
+get_cpu_idle (uint64_t *res)
+{
+  int space;
+  int i;
+  int n = lib_num_loc_cpus;
+  char *p = proc_stat_buf;
+
+  lseek (proc_stat_fd, 0, SEEK_SET);
+  read (proc_stat_fd, p, proc_stat_buflen);
+
+  if (debug) {
+    fprintf(where,"proc_stat_buf '%.*s'\n",proc_stat_buflen,p);
+    fflush(where);
+  }
+  /* Skip first line (total) on SMP */
+  if (n > 1) p = strchr (p, '\n');
+
+  /* Idle time is the 4th space-separated token */
+  for (i = 0; i < n; i++) {
+    for (space = 0; space < 4; space ++) {
+      p = strchr (p, ' ');
+      while (*++p == ' ');
+    };
+    res[i] = strtoul (p, &p, 10);
+    if (debug) {
+      fprintf(where,"res[%d] is %llu\n",i,res[i]);
+      fflush(where);
+    }
+    p = strchr (p, '\n');
+  };
+
+}
+
+/* take the initial timestamp and start collecting CPU utilization if
+   requested */
+
+void
+measure_cpu_start()
+{
+  cpu_method = PROC_STAT;
+  get_cpu_idle(lib_start_count);
+}
+
+/* collect final CPU utilization raw data */
+void
+measure_cpu_stop()
+{
+  get_cpu_idle(lib_end_count);
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+
+  float actual_rate;
+  float correction_factor;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+
+    /* it would appear that on some systems, in loopback, nice is
+     *very* effective, causing the looper process to stop dead in its
+     tracks. if this happens, we need to ensure that the calculation
+     does not go south. raj 6/95 and if we run completely out of idle,
+     the same thing could in theory happen to the USE_KSTAT path. raj
+     8/2000 */ 
+    
+    if (lib_end_count[i] == lib_start_count[i]) {
+      lib_end_count[i]++;
+    }
+    
+    actual_rate = (lib_end_count[i] > lib_start_count[i]) ?
+      (float)(lib_end_count[i] - lib_start_count[i])/lib_elapsed :
+      (float)(lib_end_count[i] - lib_start_count[i] +
+	      MAXLONG)/ lib_elapsed;
+    lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) /
+      lib_local_maxrate * 100;
+    if (debug) {
+      fprintf(where,
+              "calc_cpu_util: actual_rate on processor %d is %f start %llx end %llx util %f\n",
+              i,
+              actual_rate,
+              lib_start_count[i],
+              lib_end_count[i],
+	      lib_local_per_cpu_util[i]);
+    }
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+  }
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  lib_local_cpu_util *= correction_factor;
+  return lib_local_cpu_util;
+}
+
+void
+cpu_start_internal(void)
+{
+  get_cpu_idle(lib_start_count);
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_idle(lib_end_count);
+}
diff --git a/netcpu_pstat.c b/netcpu_pstat.c
new file mode 100644
index 0000000..08f27c1
--- /dev/null
+++ b/netcpu_pstat.c
@@ -0,0 +1,307 @@
+char   netcpu_pstat_id[]="\
+@(#)netcpu_pstat.c (c) Copyright 2005, Hewlett-Packard Company, Version 2.4.0";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif 
+
+#include <sys/dk.h>
+#include <sys/pstat.h>
+
+#ifndef PSTAT_IPCINFO
+# error Sorry, pstat() CPU utilization on 10.0 and later only
+#endif
+
+#include "netsh.h"
+#include "netlib.h"
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibrarion to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+static uint64_t  lib_start_count[MAXCPUS];
+static uint64_t  lib_end_count[MAXCPUS];
+
+void
+cpu_util_init(void) 
+{
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return HP_IDLE_COUNTER;
+}
+
+void
+get_cpu_idle(uint64_t *res)
+{
+      /* get the idle sycle counter for each processor */
+      struct pst_processor *psp;
+      union overlay_u {
+        long long full;
+        long      word[2];
+      } *overlay;
+      
+      psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
+      if (psp == NULL) {
+        printf("malloc(%d) failed!\n", lib_num_loc_cpus * sizeof(*psp));
+        exit(1);
+	  }
+      if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
+        int i;
+        for (i = 0; i < lib_num_loc_cpus; i++) {
+          overlay = (union overlay_u *)&(res[i]);
+          overlay->word[0] = psp[i].psp_idlecycles.psc_hi;
+          overlay->word[1] = psp[i].psp_idlecycles.psc_lo;
+          if(debug) {
+            fprintf(where,
+                    "\tres[%d] = 0x%8.8x%8.8x\n",
+                    i,
+                    hi_32(&res[i]),
+                    lo_32(&res[i]));
+            fflush(where);
+          }
+        }
+        free(psp);
+      }
+}
+
+/* calibrate_pstat
+   Loop a number of iterations, sleeping wait_time seconds each and
+   count how high the idle counter gets each time. Return  the measured
+   cpu rate to the calling routine.  */
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+
+  uint64_t
+    firstcnt[MAXCPUS],
+    secondcnt[MAXCPUS];
+
+  float 
+    elapsed, 
+    temp_rate,
+    rate[MAXTIMES],
+    local_maxrate;
+
+  long  
+    sec,
+    usec;
+
+  int   
+    i,
+    j;
+  
+  long  count;
+
+  struct  timeval time1, time2;
+  struct  timezone tz;
+
+  struct pst_processor *psp;
+  
+  if (iterations > MAXTIMES) {
+    iterations = MAXTIMES;
+  }
+  
+  local_maxrate = -1.0;
+
+  psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
+  if (psp == NULL) {
+    printf("malloc(%d) failed!\n", lib_num_loc_cpus * sizeof(*psp));
+    exit(1);
+  }
+
+  for(i = 0; i < iterations; i++) {
+    rate[i] = 0.0;
+    /* get the idle sycle counter for each processor */
+    if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
+      for (j = 0; j < lib_num_loc_cpus; j++) {
+        union overlay_u {
+          long long full;
+          long      word[2];
+        } *overlay;
+        overlay = (union overlay_u *)&(firstcnt[j]);
+        overlay->word[0] = psp[j].psp_idlecycles.psc_hi;
+        overlay->word[1] = psp[j].psp_idlecycles.psc_lo;
+      }
+    }
+    else {
+      fprintf(where,"pstat_getprocessor failure errno %d\n",errno);
+      fflush(where);
+      exit(1);
+    }
+
+    gettimeofday (&time1, &tz);
+    sleep(interval);
+    gettimeofday (&time2, &tz);
+    
+    if (time2.tv_usec < time1.tv_usec)
+      {
+        time2.tv_usec += 1000000;
+        time2.tv_sec -=1;
+      }
+    sec = time2.tv_sec - time1.tv_sec;
+    usec = time2.tv_usec - time1.tv_usec;
+    elapsed = (float)sec + ((float)usec/(float)1000000.0);
+
+    if(debug) {
+      fprintf(where, "Calibration for counter run: %d\n",i);
+      fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
+      fprintf(where,"\telapsed time = %g\n",elapsed);
+    }
+
+    if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
+      for (j = 0; j < lib_num_loc_cpus; j++) {
+        union overlay_u {
+          long long full;
+          long      word[2];
+        } *overlay;
+        overlay = (union overlay_u *)&(secondcnt[j]);
+        overlay->word[0] = psp[j].psp_idlecycles.psc_hi;
+        overlay->word[1] = psp[j].psp_idlecycles.psc_lo;
+        if(debug) {
+          /* I know that there are situations where compilers know about */
+          /* long long, but the library fucntions do not... raj 4/95 */
+          fprintf(where,
+                  "\tfirstcnt[%d] = 0x%8.8x%8.8x secondcnt[%d] = 0x%8.8x%8.8x\n",
+                  j,
+                  hi_32(&firstcnt[j]),
+                  lo_32(&firstcnt[j]),
+                  j,
+                  hi_32(&secondcnt[j]),
+                  lo_32(&secondcnt[j]));
+        }
+        temp_rate = (secondcnt[j] >= firstcnt[j]) ? 
+          (float)(secondcnt[j] - firstcnt[j] )/elapsed : 
+            (float)(secondcnt[j] - firstcnt[j] + LONG_LONG_MAX)/elapsed;
+        if (temp_rate > rate[i]) rate[i] = temp_rate;
+        if(debug) {
+          fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
+          fflush(where);
+        }
+        if (local_maxrate < rate[i]) local_maxrate = rate[i];
+      }
+    }
+    else {
+      fprintf(where,"pstat failure; errno %d\n",errno);
+      fflush(where);
+      exit(1);
+    }
+  }
+  if(debug) {
+    fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
+    fflush(where);
+  }
+  return local_maxrate;
+
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+
+  float actual_rate;
+  float correction_factor;
+
+  lib_local_cpu_util = (float)0.0;
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  /* this looks just like the looper case. at least I think it */
+  /* should :) raj 4/95 */
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+    
+    /* we assume that the two are not more than a long apart. I */
+    /* know that this is bad, but trying to go from long longs to */
+    /* a float (perhaps a double) is boggling my mind right now. */
+    /* raj 4/95 */
+    
+    long long 
+      diff;
+    
+    if (lib_end_count[i] >= lib_start_count[i]) {
+      diff = lib_end_count[i] - lib_start_count[i];
+    }
+    else {
+      diff = lib_end_count[i] - lib_start_count[i] + LONG_LONG_MAX;
+    }
+    actual_rate = (float) diff / lib_elapsed;
+    lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) /
+      lib_local_maxrate * 100;
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+    if (debug) {
+      fprintf(where,
+	      "calc_cpu_util: actual_rate on cpu %d is %g max_rate %g cpu %6.2f\n",
+	      i,
+	      actual_rate,
+	      lib_local_maxrate,
+	      lib_local_per_cpu_util[i]);
+    }
+  }
+  
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+  
+  if (debug) {
+    fprintf(where,
+	    "calc_cpu_util: average across CPUs is %g\n",lib_local_cpu_util);
+  }
+
+  lib_local_cpu_util *= correction_factor;
+
+  if (debug) {
+    fprintf(where,
+	    "calc_cpu_util: returning %g\n",lib_local_cpu_util);
+  }
+
+  return lib_local_cpu_util;
+
+}
+void
+cpu_start_internal(void)
+{
+  get_cpu_idle(lib_start_count);
+  return;
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_idle(lib_end_count);
+}
diff --git a/netcpu_pstatnew.c b/netcpu_pstatnew.c
new file mode 100644
index 0000000..fd2d036
--- /dev/null
+++ b/netcpu_pstatnew.c
@@ -0,0 +1,398 @@
+char   netcpu_pstatnew_id[]="\
+@(#)netcpu_pstatnew.c (c) Copyright 2005, Hewlett-Packard Company, Version 2.4.1";
+
+/* since we "know" that this interface is available only on 11.23 and
+   later, and that 11.23 and later are strictly 64-bit kernels, we can
+   arbitrarily set _PSTAT64 here and not have to worry about it up in
+   the configure script and makefiles. raj 2005/09/06 */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#include <unistd.h>
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif 
+
+#include <sys/dk.h>
+#include <sys/pstat.h>
+
+/* HP-UX 11.23 seems to have added three other cycle counters to the
+   original psp_idlecycles - one for user, one for kernel and one for
+   interrupt. so, we can now use those to calculate CPU utilization
+   without requiring any calibration phase.  raj 2005-02-16 */ 
+
+#ifndef PSTAT_IPCINFO
+# error Sorry, pstat() CPU utilization on 10.0 and later only
+#endif
+
+typedef struct cpu_time_counters {
+  uint64_t idle;
+  uint64_t user;
+  uint64_t kernel;
+  uint64_t interrupt;
+} cpu_time_counters_t;
+
+uint64_t lib_iticksperclktick;
+
+#include "netsh.h"
+#include "netlib.h"
+
+/* the lib_start_count and lib_end_count arrays hold the starting
+   and ending values of whatever is counting when the system is
+   idle. The rate at which this increments during a test is compared
+   with a previous calibrarion to arrive at a CPU utilization
+   percentage. raj 2005-01-26 */
+
+static cpu_time_counters_t  starting_cpu_counters[MAXCPUS];
+static cpu_time_counters_t  ending_cpu_counters[MAXCPUS];
+static cpu_time_counters_t  delta_cpu_counters[MAXCPUS];
+
+void
+cpu_util_init(void) 
+{
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return HP_IDLE_COUNTER;
+}
+
+void
+get_cpu_counters(cpu_time_counters_t *res)
+{
+      /* get the idle sycle counter for each processor. now while on a
+	 64-bit kernel the ".psc_hi" and ".psc_lo" fields are 64 bits,
+	 only the bottom 32-bits are actually valid.  don't ask me
+	 why, that is just the way it is.  soo, we shift the psc_hi
+	 value by 32 bits and then just sum-in the psc_lo value.  raj
+	 2005/09/06 */ 
+      struct pst_processor *psp;
+
+      psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
+      if (psp == NULL) {
+        printf("malloc(%d) failed!\n", lib_num_loc_cpus * sizeof(*psp));
+        exit(1);
+	  }
+      if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
+        int i;
+	/* we use lib_iticksperclktick in our sanity checking. we
+	   ass-u-me it is the same value for each CPU - famous last
+	   words no doubt. raj 2005/09/06 */
+	lib_iticksperclktick = psp[0].psp_iticksperclktick;
+        for (i = 0; i < lib_num_loc_cpus; i++) {
+          res[i].idle = (((uint64_t)psp[i].psp_idlecycles.psc_hi << 32) +
+			 psp[i].psp_idlecycles.psc_lo);
+          if(debug) {
+            fprintf(where,
+                    "\tidle[%d] = 0x%"PRIx64" ",
+                    i,
+                    res[i].idle);
+            fflush(where);
+          }
+          res[i].user = (((uint64_t)psp[i].psp_usercycles.psc_hi << 32) +
+			 psp[i].psp_usercycles.psc_lo);
+          if(debug) {
+            fprintf(where,
+                    "user[%d] = 0x%"PRIx64" ",
+                    i,
+                    res[i].user);
+            fflush(where);
+          }
+          res[i].kernel = (((uint64_t)psp[i].psp_systemcycles.psc_hi << 32) +
+			    psp[i].psp_systemcycles.psc_lo);
+          if(debug) {
+            fprintf(where,
+                    "kern[%d] = 0x%"PRIx64" ",
+                    i,
+                    res[i].kernel);
+            fflush(where);
+          }
+          res[i].interrupt = (((uint64_t)psp[i].psp_interruptcycles.psc_hi << 32) +
+			      psp[i].psp_interruptcycles.psc_lo);
+          if(debug) {
+            fprintf(where,
+                    "intr[%d] = 0x%"PRIx64"\n",
+                    i,
+                    res[i].interrupt);
+            fflush(where);
+          }
+        }
+        free(psp);
+      }
+}
+
+/* calibrate_pstatnew
+   there really isn't anything much to do here since we have all the
+   counters and use their ratios for CPU util measurement. raj
+   2005-02-16 */
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  return 0.0;
+}
+
+static void
+print_cpu_time_counters(char *name, int instance, cpu_time_counters_t *counters) 
+{
+  fprintf(where,"%s[%d]:\n",name,instance);
+  fprintf(where,
+	  "\t idle %llu\n",counters[instance].idle);
+  fprintf(where,
+	  "\t user %llu\n",counters[instance].user);
+  fprintf(where,
+	  "\t kernel %llu\n",counters[instance].kernel);
+  fprintf(where,
+	  "\t interrupt %llu\n",counters[instance].interrupt);
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  int i;
+
+  uint64_t total_cpu_cycles;
+  uint64_t sanity_cpu_cycles;
+
+#ifndef USE_INTEGER_MATH
+  double fraction_idle;
+  double fraction_user;
+  double fraction_kernel;
+  double fraction_interrupt;
+  double estimated_fraction_interrupt;
+#else
+  uint64_t fraction_idle;
+  uint64_t fraction_user;
+  uint64_t fraction_kernel;
+  uint64_t fraction_interrupt;
+  uint64_t estimated_fraction_interrupt;
+
+#define CALC_PERCENT 100
+#define CALC_TENTH_PERCENT 1000
+#define CALC_HUNDREDTH_PERCENT 10000
+#define CALC_THOUSANDTH_PERCENT 100000
+#define CALC_ACCURACY CALC_THOUSANDTH_PERCENT
+
+#endif /* USE_INTEGER_MATH */
+  float actual_rate;
+  float correction_factor;
+
+  lib_local_cpu_util = (float)0.0;
+
+  /* It is possible that the library measured a time other than */
+  /* the one that the user want for the cpu utilization */
+  /* calculations - for example, tests that were ended by */
+  /* watchdog timers such as the udp stream test. We let these */
+  /* tests tell up what the elapsed time should be. */
+  
+  if (elapsed_time != 0.0) {
+    correction_factor = (float) 1.0 + 
+      ((lib_elapsed - elapsed_time) / elapsed_time);
+  }
+  else {
+    correction_factor = (float) 1.0;
+  }
+
+  /* calculate our sanity check on cycles */
+  if (debug) {
+    fprintf(where,
+	    "lib_elapsed %g _SC_CLK_TCK %d lib_iticksperclktick %"PRIu64"\n",
+	    lib_elapsed,
+	    sysconf(_SC_CLK_TCK),
+	    lib_iticksperclktick);
+  }
+
+  /* Ok, elsewhere I may have said that HP-UX 11.23 does the "right"
+     thing in measuring user, kernel, interrupt and idle all together
+     instead of overlapping interrupt with the others like an OS that
+     shall not be named.  However.... it seems there is a bug in the
+     accounting for interrupt cycles, whereby the cycles do not get
+     properly accounted.  The sum of user, kernel, interrupt and idle
+     does not equal the clock rate multiplied by the elapsed time.
+     Some cycles go missing.
+
+     Since we see agreement between netperf and glance/vsar with the
+     old "pstat" mechanism, we can presume that the accounting for
+     idle cycles is sufficiently accurate.  So, while we will still do
+     math with user, kernel and interrupt cycles, we will only
+     caculate CPU utilization based on the ratio of idle to _real_
+     total cycles.  I am told that a "future release" of HP-UX will
+     fix the interupt cycle accounting.  raj 2005/09/14 */
+
+  /* calculate what the sum of CPU cycles _SHOULD_ be */
+  sanity_cpu_cycles = (uint64_t) ((double)lib_elapsed * 
+    (double) sysconf(_SC_CLK_TCK) * (double)lib_iticksperclktick);
+
+  /* this looks just like the looper case. at least I think it */
+  /* should :) raj 4/95 */
+  for (i = 0; i < lib_num_loc_cpus; i++) {
+    
+    /* we ass-u-me that these counters will never wrap during a
+       netperf run.  this may not be a particularly safe thing to
+       do. raj 2005-01-28 */
+    delta_cpu_counters[i].idle = ending_cpu_counters[i].idle -
+      starting_cpu_counters[i].idle;
+    delta_cpu_counters[i].user = ending_cpu_counters[i].user -
+      starting_cpu_counters[i].user;
+    delta_cpu_counters[i].kernel = ending_cpu_counters[i].kernel -
+      starting_cpu_counters[i].kernel;
+    delta_cpu_counters[i].interrupt = ending_cpu_counters[i].interrupt -
+      starting_cpu_counters[i].interrupt;
+    
+    if (debug) {
+      print_cpu_time_counters("delta_cpu_counters",i,delta_cpu_counters);
+    }
+
+    /* now get the sum, which we ass-u-me does not overflow a 64-bit
+       counter. raj 2005-02-16 */
+    total_cpu_cycles = 
+      delta_cpu_counters[i].idle +
+      delta_cpu_counters[i].user +
+      delta_cpu_counters[i].kernel +
+      delta_cpu_counters[i].interrupt;
+
+    if (debug) {
+      fprintf(where,
+	      "total_cpu_cycles %"PRIu64" sanity_cpu_cycles %"PRIu64" missing %"PRIu64"\n",
+	      total_cpu_cycles,
+	      sanity_cpu_cycles,
+	      sanity_cpu_cycles - total_cpu_cycles);
+    }
+
+    /* since HP-UX 11.23 does the _RIGHT_ thing and idle/user/kernel
+       does _NOT_ overlap with interrupt, we do not have to apply any
+       correction kludge. raj 2005-02-16 */
+
+#ifndef USE_INTEGER_MATH
+    /* when the accounting for interrupt time gets its act together,
+       we can use total_cpu_cycles rather than sanity_cpu_cycles, but
+       until then, use sanity_cpu_ccles. raj 2005/09/14 */
+
+    fraction_idle = (double)delta_cpu_counters[i].idle / 
+      (double)sanity_cpu_cycles;
+
+    fraction_user = (double)delta_cpu_counters[i].user / 
+      (double)sanity_cpu_cycles;
+
+    fraction_kernel = (double) delta_cpu_counters[i].kernel / 
+      (double)sanity_cpu_cycles;
+
+    fraction_interrupt = (double)delta_cpu_counters[i].interrupt / 
+      (double)sanity_cpu_cycles;
+
+    /* ass-u-me that it is only interrupt that is bogus, and assign
+       all the "missing" cycles to it. raj 2005/09/14 */
+    estimated_fraction_interrupt = ((double)delta_cpu_counters[i].interrupt +
+				    (sanity_cpu_cycles - total_cpu_cycles)) / 
+      (double)sanity_cpu_cycles;
+
+    if (debug) {
+      fprintf(where,"\tfraction_idle %g\n",fraction_idle);
+      fprintf(where,"\tfraction_user %g\n",fraction_user);
+      fprintf(where,"\tfraction_kernel %g\n",fraction_kernel);
+      fprintf(where,"\tfraction_interrupt %g WARNING, possibly under-counted!\n",fraction_interrupt);
+      fprintf(where,"\testimated_fraction_interrupt %g\n",
+	      estimated_fraction_interrupt);
+    }
+
+    /* and finally, what is our CPU utilization? */
+    lib_local_per_cpu_util[i] = 100.0 - (fraction_idle * 100.0);
+#else
+    /* and now some fun with integer math.  i initially tried to
+       promote things to long doubled but that didn't seem to result
+       in happiness and joy. raj 2005-01-28 */
+
+    /* multiply by 100 and divide by total and you get whole
+       percentages. multiply by 1000 and divide by total and you get
+       tenths of percentages.  multiply by 10000 and divide by total
+       and you get hundredths of percentages. etc etc etc raj
+       2005-01-28 */
+
+    /* when the accounting for interrupt time gets its act together,
+       we can use total_cpu_cycles rather than sanity_cpu_cycles, but
+       until then, use sanity_cpu_ccles. raj 2005/09/14 */
+
+    fraction_idle = 
+      (delta_cpu_counters[i].idle * CALC_ACCURACY) / sanity_cpu_cycles;
+
+    fraction_user = 
+      (delta_cpu_counters[i].user * CALC_ACCURACY) / sanity_cpu_cycles;
+
+    fraction_kernel = 
+      (delta_cpu_counters[i].kernel * CALC_ACCURACY) / sanity_cpu_cycles;
+
+    fraction_interrupt = 
+      (delta_cpu_counters[i].interrupt * CALC_ACCURACY) / sanity_cpu_cycles;
+
+
+    estimated_fraction_interrupt = 
+      ((delta_cpu_counters[i].interrupt + 
+	(sanity_cpu_cycles - total_cpu_cycles)) * 
+       CALC_ACCURACY) / sanity_cpu_cycles;
+
+    if (debug) {
+      fprintf(where,"\tfraction_idle %"PRIu64"\n",fraction_idle);
+      fprintf(where,"\tfraction_user %"PRIu64"\n",fraction_user);
+      fprintf(where,"\tfraction_kernel %"PRIu64"\n",fraction_kernel);
+      fprintf(where,"\tfraction_interrupt %"PRIu64"WARNING, possibly under-counted!\n",fraction_interrupt);
+      fprintf(where,"\testimated_fraction_interrupt %"PRIu64"\n",
+	      estimated_fraction_interrupt);
+    }
+
+    /* and finally, what is our CPU utilization? */
+    lib_local_per_cpu_util[i] = 100.0 - (((float)fraction_idle / 
+					  (float)CALC_ACCURACY) * 100.0);
+#endif
+    if (debug) {
+      fprintf(where,
+	      "lib_local_per_cpu_util[%d] %g\n",
+	      i,
+	      lib_local_per_cpu_util[i]);
+    }
+    lib_local_cpu_util += lib_local_per_cpu_util[i];
+  }
+  /* we want the average across all n processors */
+  lib_local_cpu_util /= (float)lib_num_loc_cpus;
+
+  lib_local_cpu_util *= correction_factor;
+
+  if (debug) {
+    fprintf(where,
+	    "calc_cpu_util: returning %g\n",lib_local_cpu_util);
+  }
+
+  return lib_local_cpu_util;
+
+}
+void
+cpu_start_internal(void)
+{
+  get_cpu_counters(starting_cpu_counters);
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_counters(ending_cpu_counters);
+}
diff --git a/netcpu_sysctl.c b/netcpu_sysctl.c
new file mode 100644
index 0000000..919f62c
--- /dev/null
+++ b/netcpu_sysctl.c
@@ -0,0 +1,127 @@
+char   netcpu_sysctl_id[]="\
+@(#)netcpu_sysctl.c  Version 2.4.3";
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+#if HAVE_LIMITS_H
+# include <limits.h>
+# ifndef LONG_LONG_MAX
+#  define LONG_LONG_MAX LLONG_MAX
+# endif /* LONG_LONG_MAX */
+#endif
+
+
+#include <errno.h>
+
+/* need to have some sort of check for sys/sysctl.h versus sysctl.h */
+#include <sys/sysctl.h>
+
+
+/* this has been liberally cut and pasted from <sys/resource.h> on
+   FreeBSD. in general, this would be a bad idea, but I don't want to
+   have to do a _KERNEL define to get these and that is what
+   sys/resource.h seems to want. raj 2002-03-03 */
+#define CP_USER         0
+#define CP_NICE         1
+#define CP_SYS          2
+#define CP_INTR         3
+#define CP_IDLE         4
+#define CPUSTATES       5
+
+
+#include "netsh.h"
+#include "netlib.h"
+
+static long lib_start_count[CPUSTATES];
+static long lib_end_count[CPUSTATES];
+
+void
+cpu_util_init(void) 
+{
+  return;
+}
+
+void
+cpu_util_terminate(void)
+{
+  return;
+}
+
+int
+get_cpu_method(void)
+{
+  return SYSCTL;
+}
+
+static void
+get_cpu_time(long *cpu_time)
+{
+  size_t cpu_time_len = CPUSTATES * sizeof (cpu_time[0]);
+
+  if (sysctlbyname("kern.cp_time", cpu_time, &cpu_time_len, NULL, 0) == -1) {
+      fprintf (stderr, "Cannot get CPU time!\n");
+      exit (1);
+  }
+}
+
+/* calibrate_sysctl  - perform the idle rate calculation using the
+   sysctl call - typically on BSD */
+
+float
+calibrate_idle_rate(int iterations, int interval)
+{
+  return sysconf (_SC_CLK_TCK);
+}
+
+float
+calc_cpu_util_internal(float elapsed_time)
+{
+  long sum_idle, sum_busy;
+  int i;
+
+  for (sum_busy = 0, i = 0; i < CPUSTATES; i++) {
+    if (i != CP_IDLE)
+      sum_busy += lib_end_count[i] - lib_start_count[i];
+  }
+
+  sum_idle = lib_end_count[CP_IDLE] - lib_start_count[CP_IDLE];
+  lib_local_cpu_util = (float)sum_busy / (float)(sum_busy + sum_idle);
+  lib_local_cpu_util *= 100.0;
+
+  return lib_local_cpu_util;
+
+}
+void
+cpu_start_internal(void)
+{
+  get_cpu_time(lib_start_count);
+}
+
+void
+cpu_stop_internal(void)
+{
+  get_cpu_time(lib_end_count);
+}
diff --git a/netlib.c b/netlib.c
new file mode 100644
index 0000000..bee93c8
--- /dev/null
+++ b/netlib.c
@@ -0,0 +1,4161 @@
+char    netlib_id[]="\
+@(#)netlib.c (c) Copyright 1993-2007 Hewlett-Packard Company. Version 2.4.3";
+
+
+/****************************************************************/
+/*                                                              */
+/*      netlib.c                                                */
+/*                                                              */
+/*      the common utility routines available to all...         */
+/*                                                              */
+/*      establish_control()     establish the control socket    */
+/*      calibrate_local_cpu()   do local cpu calibration        */
+/*      calibrate_remote_cpu()  do remote cpu calibration       */
+/*      send_request()          send a request to the remote    */
+/*      recv_response()         receive a response from remote  */
+/*      send_response()         send a response to the remote   */
+/*      recv_request()          recv a request from the remote  */
+/*      dump_request()          dump request contents           */
+/*      dump_response()         dump response contents          */
+/*      cpu_start()             start measuring cpu             */
+/*      cpu_stop()              stop measuring cpu              */
+/*      calc_cpu_util()         calculate the cpu utilization   */
+/*      calc_service_demand()   calculate the service demand    */
+/*      calc_thruput()          calulate the tput in units      */
+/*      calibrate()             really calibrate local cpu      */
+/*      identify_local()        print local host information    */
+/*      identify_remote()       print remote host information   */
+/*      format_number()         format the number (KB, MB,etc)  */
+/*      format_units()          return the format in english    */
+/*      msec_sleep()            sleep for some msecs            */
+/*      start_timer()           start a timer                   */
+/*                                                              */
+/*      the routines you get when WANT_DLPI is defined...         */
+/*                                                              */
+/*      dl_open()               open a file descriptor and      */
+/*                              attach to the card              */
+/*      dl_mtu()                find the MTU of the card        */
+/*      dl_bind()               bind the sap do the card        */
+/*      dl_connect()            sender's have of connect        */
+/*      dl_accpet()             receiver's half of connect      */
+/*      dl_set_window()         set the window size             */
+/*      dl_stats()              retrieve statistics             */
+/*      dl_send_disc()          initiate disconnect (sender)    */
+/*      dl_recv_disc()          accept disconnect (receiver)    */
+/****************************************************************/
+
+/****************************************************************/
+/*                                                              */
+/*      Global include files                                    */
+/*                                                              */
+/****************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+ /* It would seem that most of the includes being done here from */
+ /* "sys/" actually have higher-level wrappers at just /usr/include. */
+ /* This is based on a spot-check of a couple systems at my disposal. */
+ /* If you have trouble compiling you may want to add "sys/" raj 10/95 */
+#include <limits.h>
+#include <signal.h>
+#ifdef MPE
+#  define NSIG _NSIG
+#endif /* MPE */
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+#ifdef HAVE_ENDIAN_H
+#include <endian.h>
+#endif
+
+
+#ifndef WIN32
+ /* at some point, I would like to get rid of all these "sys/" */
+ /* includes where appropriate. if you have a system that requires */
+ /* them, speak now, or your system may not comile later revisions of */
+ /* netperf. raj 1/96 */
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/times.h>
+#ifndef MPE
+#include <time.h>
+#include <sys/time.h>
+#endif /* MPE */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <errno.h>
+#include <sys/utsname.h>
+#if !defined(MPE) && !defined(__VMS)
+#include <sys/param.h>
+#endif /* MPE */
+
+#else /* WIN32 */
+
+#include <process.h>
+#include <time.h>
+#include <winsock2.h>
+#define netperf_socklen_t socklen_t
+#include <windows.h>
+
+/* the only time someone should need to define DONT_IPV6 in the
+   "sources" file is if they are trying to compile on Windows 2000 or
+   NT4 and I suspect this may not be their only problem :) */
+#ifndef DONT_IPV6
+#include <ws2tcpip.h>
+#endif
+
+#include <windows.h>
+
+#define SIGALRM (14)
+#define sleep(x) Sleep((x)*1000)
+
+#endif /* WIN32 */
+
+#ifdef _AIX
+#include <sys/select.h>
+#include <sys/sched.h>
+#include <sys/pri.h>
+#define PRIORITY PRI_LOW
+#else/* _AIX */
+#ifdef __sgi 
+#include <sys/prctl.h>
+#include <sys/schedctl.h>
+#define PRIORITY NDPLOMIN
+#endif /* __sgi */
+#endif /* _AIX */
+
+#ifdef WANT_DLPI
+#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__ */
+#endif /* WANT_DLPI */
+
+#ifdef HAVE_MPCTL
+#include <sys/mpctl.h>
+#endif
+
+#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO)
+# include "missing/getaddrinfo.h"
+#endif
+
+
+#ifdef WANT_HISTOGRAM
+#include "hist.h"
+#endif /* WANT_HISTOGRAM */
+/****************************************************************/
+/*                                                              */
+/*      Local Include Files                                     */
+/*                                                              */
+/****************************************************************/
+#define NETLIB
+#include "netlib.h"
+#include "netsh.h"
+#include "netcpu.h"
+
+/****************************************************************/
+/*                                                              */
+/*      Global constants, macros and variables                  */
+/*                                                              */
+/****************************************************************/
+
+#if defined(WIN32) || defined(__VMS)
+struct  timezone {
+        int     dummy ;
+        } ;
+#ifndef __VMS
+SOCKET     win_kludge_socket = INVALID_SOCKET;
+SOCKET     win_kludge_socket2 = INVALID_SOCKET;
+#endif /* __VMS */
+#endif /* WIN32 || __VMS */
+
+#ifndef LONG_LONG_MAX
+#define LONG_LONG_MAX 9223372036854775807LL
+#endif /* LONG_LONG_MAX */
+
+ /* older versions of netperf knew about the HP kernel IDLE counter. */
+ /* this is now obsolete - in favor of either pstat(), times, or a */
+ /* process-level looper process. we also now require support for the */
+ /* "long" integer type. raj 4/95.  */
+
+int 
+  lib_num_loc_cpus,    /* the number of cpus in the system */
+  lib_num_rem_cpus;    /* how many we think are in the remote */
+
+#define PAGES_PER_CHILD 2
+
+int     lib_use_idle;
+int     cpu_method;
+
+struct  timeval         time1, time2;
+struct  timezone        tz;
+float   lib_elapsed,
+        lib_local_maxrate,
+        lib_remote_maxrate,
+        lib_local_cpu_util,
+        lib_remote_cpu_util;
+
+float   lib_local_per_cpu_util[MAXCPUS];
+int     lib_cpu_map[MAXCPUS];
+
+int     *request_array;
+int     *response_array;
+
+/* INVALID_SOCKET == INVALID_HANDLE_VALUE == (unsigned int)(~0) == -1 */
+SOCKET  netlib_control = INVALID_SOCKET;  
+SOCKET  server_sock = INVALID_SOCKET;
+
+/* global variables to hold the value for processor affinity */
+int     local_proc_affinity,remote_proc_affinity = -1;
+
+/* these are to allow netperf to be run easily through those evil,
+   end-to-end breaking things known as firewalls */
+char local_data_port[10];
+char remote_data_port[10];
+
+char *local_data_address=NULL;
+char *remote_data_address=NULL;
+
+int local_data_family=AF_UNSPEC;
+int remote_data_family=AF_UNSPEC;
+
+ /* in the past, I was overlaying a structure on an array of ints. now */
+ /* I am going to have a "real" structure, and point an array of ints */
+ /* at it. the real structure will be forced to the same alignment as */
+ /* the type "double." this change will mean that pre-2.1 netperfs */
+ /* cannot be mixed with 2.1 and later. raj 11/95 */
+
+union   netperf_request_struct  netperf_request;
+union   netperf_response_struct netperf_response;
+
+FILE    *where;
+
+char    libfmt = '?';
+        
+#ifdef WANT_DLPI
+/* 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};
+
+#endif /* WANT_DLPI */
+
+#ifdef WIN32
+HANDLE hAlarm = INVALID_HANDLE_VALUE;
+#endif
+
+int     times_up;
+
+#ifdef WIN32
+ /* we use a getopt implementation from net.sources */
+/*
+ * get option letter from argument vector
+ */
+int
+        opterr = 1,             /* should error messages be printed? */
+        optind = 1,             /* index into parent argv vector */
+        optopt;                 /* character checked for validity */
+char
+        *optarg;                /* argument associated with option */
+
+#define EMSG    ""
+
+#endif /* WIN32 */
+
+static int measuring_cpu;
+int
+netlib_get_page_size(void) {
+
+ /* not all systems seem to have the sysconf for page size. for
+    those  which do not, we will assume that the page size is 8192
+    bytes.  this should be more than enough to be sure that there is
+    no page  or cache thrashing by looper processes on MP
+    systems. otherwise  that's really just too bad - such systems
+    should define  _SC_PAGE_SIZE - raj 4/95 */ 
+
+#ifndef _SC_PAGE_SIZE
+#ifdef WIN32
+
+SYSTEM_INFO SystemInfo;
+
+ GetSystemInfo(&SystemInfo);
+
+ return SystemInfo.dwPageSize;
+#else
+ return(8192L);
+#endif  /* WIN32 */
+#else
+ return(sysconf(_SC_PAGE_SIZE));
+#endif /* _SC_PAGE_SIZE */
+
+}
+
+
+#ifdef WANT_INTERVALS
+static unsigned int usec_per_itvl;
+
+
+void
+stop_itimer()
+
+{
+
+  struct itimerval new_interval;
+  struct itimerval old_interval;
+
+  new_interval.it_interval.tv_sec = 0;
+  new_interval.it_interval.tv_usec = 0;  
+  new_interval.it_value.tv_sec = 0;
+  new_interval.it_value.tv_usec = 0;  
+  if (setitimer(ITIMER_REAL,&new_interval,&old_interval) != 0) {
+    /* there was a problem arming the interval timer */ 
+    perror("netperf: setitimer");
+    exit(1);
+  }
+  return;
+}
+#endif /* WANT_INTERVALS */
+
+
+
+#ifdef WIN32
+static void
+error(char *pch)
+{
+  if (!opterr) {
+    return;             /* without printing */
+    }
+  fprintf(stderr, "%s: %s: %c\n",
+          (NULL != program) ? program : "getopt", pch, optopt);
+}
+
+int
+getopt(int argc, char **argv, char *ostr)
+{
+  static char *place = EMSG;    /* option letter processing */
+  register char *oli;                   /* option letter list index */
+  
+  if (!*place) {
+    /* update scanning pointer */
+      if (optind >= argc || *(place = argv[optind]) != '-' || !*++place) {
+        return EOF; 
+      }
+    if (*place == '-') {
+      /* found "--" */
+        ++optind;
+      place = EMSG ;    /* Added by shiva for Netperf */
+        return EOF;
+    }
+  }
+  
+  /* option letter okay? */
+  if ((optopt = (int)*place++) == (int)':'
+      || !(oli = strchr(ostr, optopt))) {
+    if (!*place) {
+      ++optind;
+    }
+    error("illegal option");
+    return BADCH;
+  }
+  if (*++oli != ':') {  
+    /* don't need argument */
+    optarg = NULL;
+    if (!*place)
+      ++optind;
+  } else {
+    /* need an argument */
+    if (*place) {
+      optarg = place;           /* no white space */
+    } else  if (argc <= ++optind) {
+      /* no arg */
+      place = EMSG;
+      error("option requires an argument");
+      return BADCH;
+    } else {
+      optarg = argv[optind];            /* white space */
+    }
+    place = EMSG;
+    ++optind;
+  }
+  return optopt;                        /* return option letter */
+}
+#endif /* WIN32 */
+
+/*----------------------------------------------------------------------------
+ * WIN32 implementation of perror, does not deal very well with WSA errors
+ * The stdlib.h version of perror only deals with the ancient XENIX error codes.
+ *
+ * +*+SAF Why can't all WSA errors go through GetLastError?  Most seem to...
+ *--------------------------------------------------------------------------*/
+
+#ifdef WIN32
+void PrintWin32Error(FILE *stream, LPSTR text)
+{
+    LPSTR    szTemp;
+    DWORD    dwResult;
+    DWORD    dwError;
+
+    dwError = GetLastError();
+    dwResult = FormatMessage(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
+        NULL, 
+        dwError, 
+        LANG_NEUTRAL, 
+        (LPTSTR)&szTemp, 
+        0, 
+        NULL );
+
+    if (dwResult)
+        fprintf(stream, "%s: %s\n", text, szTemp);
+    else
+        fprintf(stream, "%s: error 0x%x\n", text, dwError);
+	fflush(stream);
+
+    if (szTemp)
+        LocalFree((HLOCAL)szTemp);
+}
+#endif /* WIN32 */
+
+
+char *
+inet_ttos(int type) 
+{
+  switch (type) {
+  case SOCK_DGRAM:
+    return("SOCK_DGRAM");
+    break;
+  case SOCK_STREAM:
+    return("SOCK_STREAM");
+    break;
+  default:
+    return("SOCK_UNKNOWN");
+  }
+}
+
+
+
+char unknown[32];
+
+char *
+inet_ptos(int protocol) {
+  switch (protocol) {
+  case IPPROTO_TCP:
+    return("IPPROTO_TCP");
+    break;
+  case IPPROTO_UDP:
+    return("IPPROTO_UDP");
+    break;
+#if defined(IPPROTO_SCTP)
+  case IPPROTO_SCTP:
+    return("IPPROTO_SCTP");
+    break;
+#endif
+  default:
+    snprintf(unknown,sizeof(unknown),"IPPROTO_UNKNOWN(%d)",protocol);
+    return(unknown);
+  }
+}
+
+/* one of these days, this should not be required */
+#ifndef AF_INET_SDP
+#define AF_INET_SDP 27
+#define PF_INET_SDP AF_INET_SDP
+#endif 
+
+char *
+inet_ftos(int family) 
+{
+  switch(family) {
+  case AF_INET:
+    return("AF_INET");
+    break;
+#if defined(AF_INET6)
+  case AF_INET6:
+    return("AF_INET6");
+    break;
+#endif
+#if defined(AF_INET_SDP)
+  case AF_INET_SDP:
+    return("AF_INET_SDP");
+    break;
+#endif
+  default:
+    return("AF_UNSPEC");
+  }
+}
+
+int
+inet_nton(int af, const void *src, char *dst, int cnt) 
+
+{
+
+  switch (af) {
+  case AF_INET:
+    /* magic constants again... :) */
+    if (cnt >= 4) {
+      memcpy(dst,src,4);
+      return 4;
+    }
+    else {
+      Set_errno(ENOSPC);
+      return(-1);
+    }
+    break;
+#if defined(AF_INET6)
+  case AF_INET6:
+    if (cnt >= 16) {
+      memcpy(dst,src,16);
+      return(16);
+    }
+    else {
+      Set_errno(ENOSPC);
+      return(-1);
+    }
+    break;
+#endif
+  default:
+    Set_errno(EAFNOSUPPORT);
+    return(-1);
+  }
+}
+
+double
+ntohd(double net_double)
+
+{
+  /* we rely on things being nicely packed */
+  union {
+    double whole_thing;
+    unsigned int words[2];
+    unsigned char bytes[8];
+  } conv_rec;
+
+  unsigned char scratch;
+  int i;
+
+  /* on those systems where ntohl is a no-op, we want to return the */
+  /* original value, unchanged */
+
+  if (ntohl(1L) == 1L) {
+    return(net_double);
+  }
+
+  conv_rec.whole_thing = net_double;
+
+  /* we know that in the message passing routines that ntohl will have */
+  /* been called on the 32 bit quantities. we need to put those back */
+  /* the way they belong before we swap */
+  conv_rec.words[0] = htonl(conv_rec.words[0]);
+  conv_rec.words[1] = htonl(conv_rec.words[1]);
+  
+  /* now swap */
+  for (i=0; i<= 3; i++) {
+    scratch = conv_rec.bytes[i];
+    conv_rec.bytes[i] = conv_rec.bytes[7-i];
+    conv_rec.bytes[7-i] = scratch;
+  }
+
+#if defined(__FLOAT_WORD_ORDER) && defined(__BYTE_ORDER)
+  if (__FLOAT_WORD_ORDER != __BYTE_ORDER) {
+    /* Fixup mixed endian floating point machines */
+    unsigned int scratch = conv_rec.words[0];
+    conv_rec.words[0] = conv_rec.words[1];
+    conv_rec.words[1] = scratch;
+  }
+#endif
+
+  return(conv_rec.whole_thing);
+  
+}
+
+double
+htond(double host_double)
+
+{
+  /* we rely on things being nicely packed */
+  union {
+    double whole_thing;
+    unsigned int words[2];
+    unsigned char bytes[8];
+  } conv_rec;
+
+  unsigned char scratch;
+  int i;
+
+  /* on those systems where ntohl is a no-op, we want to return the */
+  /* original value, unchanged */
+
+  if (ntohl(1L) == 1L) {
+    return(host_double);
+  }
+
+  conv_rec.whole_thing = host_double;
+
+  /* now swap */
+  for (i=0; i<= 3; i++) {
+    scratch = conv_rec.bytes[i];
+    conv_rec.bytes[i] = conv_rec.bytes[7-i];
+    conv_rec.bytes[7-i] = scratch;
+  }
+  
+#if defined(__FLOAT_WORD_ORDER) && defined(__BYTE_ORDER)
+  if (__FLOAT_WORD_ORDER != __BYTE_ORDER) {
+    /* Fixup mixed endian floating point machines */
+    unsigned int scratch = conv_rec.words[0];
+    conv_rec.words[0] = conv_rec.words[1];
+    conv_rec.words[1] = scratch;
+  }
+#endif
+
+  /* we know that in the message passing routines htonl will */
+  /* be called on the 32 bit quantities. we need to set things up so */
+  /* that when this happens, the proper order will go out on the */
+  /* network */
+  conv_rec.words[0] = htonl(conv_rec.words[0]);
+  conv_rec.words[1] = htonl(conv_rec.words[1]);
+  
+  return(conv_rec.whole_thing);
+  
+}
+
+
+/* one of these days, this should be abstracted-out just like the CPU
+   util stuff.  raj 2005-01-27 */
+int
+get_num_cpus()
+
+{
+
+  /* on HP-UX, even when we use the looper procs we need the pstat */
+  /* call */ 
+
+  int temp_cpus;
+
+#ifdef __hpux
+#include <sys/pstat.h>
+
+  struct pst_dynamic psd;
+
+  if (pstat_getdynamic((struct pst_dynamic *)&psd, 
+                       (size_t)sizeof(psd), (size_t)1, 0) != -1) {
+    temp_cpus = psd.psd_proc_cnt;
+  }
+  else {
+    temp_cpus = 1;
+  }
+
+#else
+  /* MW: <unistd.h> was included for non-Windows systems above. */
+  /* Thus if _SC_NPROC_ONLN is defined, we should be able to use sysconf. */
+#ifdef _SC_NPROCESSORS_ONLN
+  temp_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+
+#ifdef USE_PERFSTAT
+  temp_cpus = perfstat_cpu(NULL,NULL, sizeof(perfstat_cpu_t), 0);
+#endif /* USE_PERFSTAT */
+
+#else /* no _SC_NPROCESSORS_ONLN */
+
+#ifdef WIN32
+  SYSTEM_INFO SystemInfo;
+  GetSystemInfo(&SystemInfo);
+  
+  temp_cpus = SystemInfo.dwNumberOfProcessors;
+#else
+  /* we need to know some other ways to do this, or just fall-back on */
+  /* a global command line option - raj 4/95 */
+  temp_cpus = shell_num_cpus;
+#endif  /* WIN32 */
+#endif /* _SC_NPROCESSORS_ONLN */
+#endif /*  __hpux */
+
+  if (temp_cpus > MAXCPUS) {
+    fprintf(where,
+            "Sorry, this system has more CPUs (%d) than I can handle (%d).\n",
+            temp_cpus,
+            MAXCPUS);
+    fprintf(where,
+            "Please alter MAXCPUS in netlib.h and recompile.\n");
+    fflush(where);
+    exit(1);
+  }
+
+  return(temp_cpus);
+  
+}  
+
+#ifdef WIN32
+#ifdef __GNUC__
+  #define S64_SUFFIX(x) x##LL
+#else
+  #define S64_SUFFIX(x) x##i64
+#endif
+
+/*
+ * Number of 100 nanosecond units from 1/1/1601 to 1/1/1970
+ */
+#define EPOCH_BIAS  S64_SUFFIX(116444736000000000)
+
+/*
+ * Union to facilitate converting from FILETIME to unsigned __int64
+ */
+typedef union {
+        unsigned __int64 ft_scalar;
+        FILETIME ft_struct;
+} FT;
+
+void
+gettimeofday( struct timeval *tv , struct timezone *not_used )
+{
+        FT nt_time;
+        __int64 UnixTime;  /* microseconds since 1/1/1970 */
+
+        GetSystemTimeAsFileTime( &(nt_time.ft_struct) );
+
+        UnixTime = ((nt_time.ft_scalar - EPOCH_BIAS) / S64_SUFFIX(10));
+        tv->tv_sec = (long)(time_t)(UnixTime / S64_SUFFIX(1000000));
+        tv->tv_usec = (unsigned long)(UnixTime % S64_SUFFIX(1000000));
+}
+#endif /* WIN32 */
+
+     
+
+/************************************************************************/
+/*                                                                      */
+/*      signal catcher                                                  */
+/*                                                                      */
+/************************************************************************/
+
+void
+#if defined(__hpux) 
+catcher(sig, code, scp)
+     int sig;
+     int code;
+     struct sigcontext *scp;
+#else 
+catcher(int sig)
+#endif /* __hpux || __VMS */
+{
+
+#ifdef __hpux
+  if (debug > 2) {
+    fprintf(where,"caught signal %d ",sig);
+    if (scp) {
+      fprintf(where,"while in syscall %d\n",
+              scp->sc_syscall);
+    }
+    else {
+      fprintf(where,"null scp\n");
+    }
+    fflush(where);
+  }
+#endif /* RAJ_DEBUG */
+
+  switch(sig) {
+    
+  case SIGINT:
+    fprintf(where,"netperf: caught SIGINT\n");
+    fflush(where);
+    exit(1);
+    break;
+  case SIGALRM: 
+   if (--test_len_ticks == 0) {
+      /* the test is over */
+      if (times_up != 0) {
+        fprintf(where,"catcher: timer popped with times_up != 0\n");
+        fflush(where);
+      }
+      times_up = 1;
+#if defined(WANT_INTERVALS) && !defined(WANT_SPIN)
+      stop_itimer();
+#endif /* WANT_INTERVALS */
+      break;
+    }
+    else {
+#ifdef WANT_INTERVALS
+#ifdef __hpux
+      /* the test is not over yet and we must have been using the */
+      /* interval timer. if we were in SYS_SIGSUSPEND we want to */
+      /* re-start the system call. Otherwise, we want to get out of */
+      /* the sigsuspend call. I NEED TO KNOW HOW TO DO THIS FOR OTHER */
+      /* OPERATING SYSTEMS. If you know how, please let me know. rick */
+      /* jones <raj@cup.hp.com> */
+      if (scp->sc_syscall != SYS_SIGSUSPEND) {
+        if (debug > 2) {
+          fprintf(where,
+                  "catcher: Time to send burst > interval!\n");
+          fflush(where);
+        }
+        scp->sc_syscall_action = SIG_RESTART;
+      }
+#endif /* __hpux */
+#else /* WANT_INTERVALS */
+      fprintf(where,
+              "catcher: interval timer running unexpectedly!\n");
+      fflush(where);
+      times_up = 1;
+#endif /* WANT_INTERVALS */      
+      break;
+    }
+  }
+  return;
+}
+
+
+void
+install_signal_catchers()
+
+{
+  /* just a simple little routine to catch a bunch of signals */
+
+#ifndef WIN32
+  struct sigaction action;
+  int i;
+
+  fprintf(where,"installing catcher for all signals\n");
+  fflush(where);
+
+  sigemptyset(&(action.sa_mask));
+  action.sa_handler = catcher;
+
+#ifdef SA_INTERRUPT
+  action.sa_flags = SA_INTERRUPT;
+#else /* SA_INTERRUPT */
+  action.sa_flags = 0;
+#endif /* SA_INTERRUPT */
+
+
+  for (i = 1; i <= NSIG; i++) {
+    if (i != SIGALRM) {
+      if (sigaction(i,&action,NULL) != 0) {
+        fprintf(where,
+                "Could not install signal catcher for sig %d, errno %d\n",
+                i,
+                errno);
+        fflush(where);
+
+      }
+    }
+  }
+#else
+  return;
+#endif /* WIN32 */ 
+}
+
+
+#ifdef WIN32
+#define SIGALRM (14)
+void
+emulate_alarm( int seconds )
+{
+	DWORD ErrorCode;
+
+	/* Wait on this event for parm seconds. */
+
+	ErrorCode = WaitForSingleObject(hAlarm, seconds*1000);
+	if (ErrorCode == WAIT_FAILED)
+	{
+		perror("WaitForSingleObject failed");
+		exit(1);
+	}
+
+	if (ErrorCode == WAIT_TIMEOUT)
+	{
+	  /* WaitForSingleObject timed out; this means the timer
+	     wasn't canceled. */
+
+        times_up = 1;
+
+        /* We have yet to find a good way to fully emulate the effects */
+        /* of signals and getting EINTR from system calls under */
+        /* winsock, so what we do here is close the socket out from */
+        /* under the other thread.  It is rather kludgy, but should be */
+        /* sufficient to get this puppy shipped.  The concept can be */
+        /* attributed/blamed :) on Robin raj 1/96 */
+
+        if (win_kludge_socket != INVALID_SOCKET) {
+          closesocket(win_kludge_socket);
+        }
+        if (win_kludge_socket2 != INVALID_SOCKET) {
+          closesocket(win_kludge_socket2);
+        }
+	}
+}
+
+#endif /* WIN32 */
+
+void
+start_timer(int time)
+{
+
+#ifdef WIN32
+	/*+*+SAF What if StartTimer is called twice without the first timer */
+	/*+*+SAF expiring? */
+
+	DWORD  thread_id ;
+	HANDLE tHandle;
+
+	if (hAlarm == (HANDLE) INVALID_HANDLE_VALUE)
+	{
+		/* Create the Alarm event object */
+		hAlarm = CreateEvent( 
+			(LPSECURITY_ATTRIBUTES) NULL,	  /* no security */
+			FALSE,	 /* auto reset event */
+			FALSE,   /* init. state = reset */
+			(void *)NULL);  /* unnamed event object */
+		if (hAlarm == (HANDLE) INVALID_HANDLE_VALUE)
+		{
+			perror("CreateEvent failure");
+			exit(1);
+		}
+	}
+	else
+	{
+		ResetEvent(hAlarm);
+	}
+
+
+	tHandle = CreateThread(0,
+					       0,
+						   (LPTHREAD_START_ROUTINE)emulate_alarm,
+						   (LPVOID)(ULONG_PTR)time,
+						   0,		
+						   &thread_id ) ;
+	CloseHandle(tHandle);
+
+#else /* not WIN32 */
+
+struct sigaction action;
+
+if (debug) {
+  fprintf(where,"About to start a timer for %d seconds.\n",time);
+  fflush(where);
+}
+
+  action.sa_handler = catcher;
+  sigemptyset(&(action.sa_mask));
+  sigaddset(&(action.sa_mask),SIGALRM);
+
+#ifdef SA_INTERRUPT
+  /* on some systems (SunOS 4.blah), system calls are restarted. we do */
+  /* not want that */
+  action.sa_flags = SA_INTERRUPT;
+#else /* SA_INTERRUPT */
+  action.sa_flags = 0;
+#endif /* SA_INTERRUPT */
+
+  if (sigaction(SIGALRM, &action, NULL) < 0) {
+    fprintf(where,"start_timer: error installing alarm handler ");
+    fprintf(where,"errno %d\n",errno);
+    fflush(where);
+    exit(1);
+  }
+
+  /* this is the easy case - just set the timer for so many seconds */ 
+  if (alarm(time) != 0) {
+    fprintf(where,
+            "error starting alarm timer, errno %d\n",
+            errno);
+    fflush(where);
+  }
+#endif /* WIN32 */
+
+  test_len_ticks = 1;
+
+} 
+
+
+ /* this routine will disable any running timer */
+void
+stop_timer()
+{
+#ifndef WIN32
+  alarm(0);
+#else
+  /* at some point we may need some win32 equivalent */
+  	if (hAlarm != (HANDLE) INVALID_HANDLE_VALUE)
+	{
+		SetEvent(hAlarm);
+	}
+#endif /* WIN32 */
+
+}
+
+
+#ifdef WANT_INTERVALS
+ /* this routine will enable the interval timer and set things up so */
+ /* that for a timed test the test will end at the proper time. it */
+ /* should detect the presence of POSIX.4 timer_* routines one of */
+ /* these days */
+void
+start_itimer(unsigned int interval_len_msec )
+{
+
+  unsigned int ticks_per_itvl;
+
+  struct itimerval new_interval;
+  struct itimerval old_interval;
+
+  /* if -DWANT_INTERVALS was used, we will use the ticking of the itimer to */
+  /* tell us when the test is over. while the user will be specifying */
+  /* some number of milliseconds, we know that the interval timer is */
+  /* really in units of 1/HZ. so, to prevent the test from running */
+  /* "long" it would be necessary to keep this in mind when calculating */
+  /* the number of itimer events */
+
+  ticks_per_itvl = ((interval_wate * sysconf(_SC_CLK_TCK) * 1000) / 
+                    1000000);
+
+  if (ticks_per_itvl == 0) ticks_per_itvl = 1;
+
+  /* how many usecs in each interval? */
+  usec_per_itvl = ticks_per_itvl * (1000000 / sysconf(_SC_CLK_TCK));
+
+  /* how many times will the timer pop before the test is over? */
+  if (test_time > 0) {
+    /* this was a timed test */
+    test_len_ticks = (test_time * 1000000) / usec_per_itvl;
+  }
+  else {
+    /* this was not a timed test, use MAXINT */
+    test_len_ticks = INT_MAX;
+  }
+
+  if (debug) {
+    fprintf(where,"setting the interval timer to %d sec %d usec ",
+            usec_per_itvl / 1000000,
+            usec_per_itvl % 1000000);
+    fprintf(where,"test len %d ticks\n",
+            test_len_ticks);
+    fflush(where);
+  }
+
+  /* if this was not a timed test, then we really aught to enable the */
+  /* signal catcher raj 2/95 */
+
+  new_interval.it_interval.tv_sec = usec_per_itvl / 1000000;
+  new_interval.it_interval.tv_usec = usec_per_itvl % 1000000;  
+  new_interval.it_value.tv_sec = usec_per_itvl / 1000000;
+  new_interval.it_value.tv_usec = usec_per_itvl % 1000000;  
+  if (setitimer(ITIMER_REAL,&new_interval,&old_interval) != 0) {
+    /* there was a problem arming the interval timer */ 
+    perror("netperf: setitimer");
+    exit(1);
+  }
+}
+#endif /* WANT_INTERVALS */
+
+void
+netlib_init_cpu_map() {
+
+  int i;
+#ifdef HAVE_MPCTL
+  int num;
+  i = 0;
+  /* I go back and forth on whether this should be the system-wide set
+     of calls, or if the processor set versions (sans the _SYS) should
+     be used.  at the moment I believe that the system-wide version
+     should be used. raj 2006-04-03 */
+  num = mpctl(MPC_GETNUMSPUS_SYS,0,0);
+  lib_cpu_map[i] = mpctl(MPC_GETFIRSTSPU_SYS,0,0);
+  for (i = 1;((i < num) && (i < MAXCPUS)); i++) {
+    lib_cpu_map[i] = mpctl(MPC_GETNEXTSPU_SYS,lib_cpu_map[i-1],0);
+  }
+  /* from here, we set them all to -1 because if we launch more
+     loopers than actual CPUs, well, I'm not sure why :) */
+  for (; i < MAXCPUS; i++) {
+    lib_cpu_map[i] = -1;
+  }
+
+#else
+  /* we assume that there is indeed a contiguous mapping */
+  for (i = 0; i < MAXCPUS; i++) {
+    lib_cpu_map[i] = i;
+  }
+#endif
+}
+
+
+/****************************************************************/
+/*                                                              */
+/*      netlib_init()                                           */
+/*                                                              */
+/*      initialize the performance library...                   */
+/*                                                              */
+/****************************************************************/
+
+void
+netlib_init()
+{
+  int i;
+
+  where            = stdout;
+
+  request_array = (int *)(&netperf_request);
+  response_array = (int *)(&netperf_response);
+
+  for (i = 0; i < MAXCPUS; i++) {
+    lib_local_per_cpu_util[i] = 0.0;
+  }
+
+  /* on those systems where we know that CPU numbers may not start at
+     zero and be contiguous, we provide a way to map from a
+     contiguous, starting from 0 CPU id space to the actual CPU ids.
+     at present this is only used for the netcpu_looper stuff because
+     we ass-u-me that someone setting processor affinity from the
+     netperf commandline will provide a "proper" CPU identifier. raj
+     2006-04-03 */
+
+  netlib_init_cpu_map();
+
+  if (debug) {
+    fprintf(where,
+            "netlib_init: request_array at %p\n",
+            request_array);
+    fprintf(where,
+            "netlib_init: response_array at %p\n",
+            response_array);
+
+    fflush(where);
+  }
+
+}
+
+ /* this routine will conver the string into an unsigned integer. it */
+ /* is used primarily for the command-line options taking a number */
+ /* (such as the socket size) which could be rather large. If someone */
+ /* enters 32M, then the number will be converted to 32 * 1024 * 1024. */
+ /* If they inter 32m, the number will be converted to 32 * 1000 * */
+ /* 1000 */
+unsigned int
+convert(char *string)
+
+{
+  unsigned int base;
+  base = atoi(string);
+  if (strstr(string,"K")) {
+    base *= 1024;
+  }
+  if (strstr(string,"M")) {
+    base *= (1024 * 1024);
+  }
+  if (strstr(string,"G")) {
+    base *= (1024 * 1024 * 1024);
+  }
+  if (strstr(string,"k")) {
+    base *= (1000);
+  }
+  if (strstr(string,"m")) {
+    base *= (1000 * 1000);
+  }
+  if (strstr(string,"g")) {
+    base *= (1000 * 1000 * 1000);
+  }
+  return(base);
+}
+
+/* this routine is like convert, but it is used for an interval time
+   specification instead of stuff like socket buffer or send sizes.
+   it converts everything to microseconds for internal use.  if there
+   is an 'm' at the end it assumes the user provided milliseconds, s
+   will imply seconds, u will imply microseconds.  in the future n
+   will imply nanoseconds but for now it will be ignored. if there is
+   no suffix or an unrecognized suffix, it will be assumed the user
+   provided milliseconds, which was the long-time netperf default. one
+   of these days, we should probably revisit that nanosecond business
+   wrt the return value being just an int rather than a uint64_t or
+   something.  raj 2006-02-06 */
+
+unsigned int
+convert_timespec(char *string) {
+
+  unsigned int base;
+  base = atoi(string);
+  if (strstr(string,"m")) {
+    base *= 1000;
+  }
+  else if (strstr(string,"u")) {
+    base *= (1);
+  }
+  else if (strstr(string,"s")) {
+    base *= (1000 * 1000);
+  }
+  else {
+    base *= (1000);
+  }
+  return(base);
+}
+
+
+ /* this routine will allocate a circular list of buffers for either */
+ /* send or receive operations. each of these buffers will be aligned */
+ /* and offset as per the users request. the circumference of this */
+ /* ring will be controlled by the setting of send_width. the buffers */
+ /* will be filled with data from the file specified in fill_file. if */
+ /* fill_file is an empty string, the buffers will not be filled with */
+ /* any particular data */
+
+struct ring_elt *
+allocate_buffer_ring(int width, int buffer_size, int alignment, int offset)
+{
+
+  struct ring_elt *first_link = NULL;
+  struct ring_elt *temp_link  = NULL;
+  struct ring_elt *prev_link;
+
+  int i;
+  int malloc_size;
+  int bytes_left;
+  int bytes_read;
+  int do_fill;
+
+  FILE *fill_source;
+  char default_fill[] = "netperf";
+  int  fill_cursor = 0;
+
+  malloc_size = buffer_size + alignment + offset;
+
+  /* did the user wish to have the buffers pre-filled with data from a */
+  /* particular source? */
+  if (strcmp(fill_file,"") == 0) {
+    do_fill = 0;
+    fill_source = NULL;
+  }
+  else {
+    do_fill = 1;
+    fill_source = (FILE *)fopen(fill_file,"r");
+    if (fill_source == (FILE *)NULL) {
+      perror("Could not open requested fill file");
+      exit(1);
+    }
+  }
+
+  assert(width >= 1);
+
+  prev_link = NULL;
+  for (i = 1; i <= width; i++) {
+    /* get the ring element */
+    temp_link = (struct ring_elt *)malloc(sizeof(struct ring_elt));
+    if (temp_link == NULL) {
+      printf("malloc(%u) failed!\n", sizeof(struct ring_elt));
+      exit(1);
+    }
+    /* remember the first one so we can close the ring at the end */
+    if (i == 1) {
+      first_link = temp_link;
+    }
+    temp_link->buffer_base = (char *)malloc(malloc_size);
+    if (temp_link == NULL) {
+      printf("malloc(%d) failed!\n", malloc_size);
+      exit(1);
+	}
+
+#ifndef WIN32
+    temp_link->buffer_ptr = (char *)(( (long)(temp_link->buffer_base) + 
+                          (long)alignment - 1) &        
+                         ~((long)alignment - 1));
+#else
+    temp_link->buffer_ptr = (char *)(( (ULONG_PTR)(temp_link->buffer_base) + 
+                          (ULONG_PTR)alignment - 1) &   
+                         ~((ULONG_PTR)alignment - 1));
+#endif
+    temp_link->buffer_ptr += offset;
+    /* is where the buffer fill code goes. */
+    if (do_fill) {
+      char *bufptr = temp_link->buffer_ptr;
+      bytes_left = buffer_size;
+      while (bytes_left) {
+        if (((bytes_read = (int)fread(bufptr,
+				      1,
+				      bytes_left,
+				      fill_source)) == 0) &&
+            (feof(fill_source))){
+          rewind(fill_source);
+        }
+	bufptr += bytes_read;
+        bytes_left -= bytes_read;
+      }
+    }
+    else {
+      /* use the default fill to ID our data traffic on the
+	 network. it ain't exactly pretty, but it should work */
+      int j;
+      char *bufptr = temp_link->buffer_ptr;
+      for (j = 0; j < buffer_size; j++) {
+	bufptr[j] = default_fill[fill_cursor];
+	fill_cursor += 1;
+	/* the Windows DDK compiler with an x86_64 target wants a cast
+	   here */
+	if (fill_cursor >  (int)strlen(default_fill)) {
+	  fill_cursor = 0;
+	}
+      }
+
+    }
+    temp_link->next = prev_link;
+    prev_link = temp_link;
+  }
+  if (first_link) {  /* SAF Prefast made me do it... */
+    first_link->next = temp_link;
+  }
+
+  return(first_link); /* it's a circle, doesn't matter which we return */
+}
+
+/* this routine will dirty the first dirty_count bytes of the
+   specified buffer and/or read clean_count bytes from the buffer. it
+   will go N bytes at a time, the only question is how large should N
+   be and if we should be going continguously, or based on some
+   assumption of cache line size */
+
+void
+access_buffer(char *buffer_ptr,int length, int dirty_count, int clean_count) {
+
+  char *temp_buffer;
+  char *limit;
+  int  i, dirty_totals;
+
+  temp_buffer = buffer_ptr;
+  limit = temp_buffer + length;
+  dirty_totals = 0;
+
+  for (i = 0; 
+       ((i < dirty_count) && (temp_buffer < limit));
+       i++) {
+    *temp_buffer += (char)i;
+    dirty_totals += *temp_buffer;
+    temp_buffer++;
+  }
+
+  for (i = 0; 
+       ((i < clean_count) && (temp_buffer < limit));
+       i++) {
+    dirty_totals += *temp_buffer;
+    temp_buffer++;
+  }
+
+  if (debug > 100) {
+    fprintf(where,
+	    "This was here to try to avoid dead-code elimination %d\n",
+	    dirty_totals);
+    fflush(where);
+  }
+}
+
+
+#ifdef HAVE_ICSC_EXS
+
+#include <sys/mman.h>
+#include <sys/exs.h>
+
+ /* this routine will allocate a circular list of buffers for either */
+ /* send or receive operations. each of these buffers will be aligned */
+ /* and offset as per the users request. the circumference of this */
+ /* ring will be controlled by the setting of send_width. the buffers */
+ /* will be filled with data from the file specified in fill_file. if */
+ /* fill_file is an empty string, the buffers will not be filled with */
+ /* any particular data */
+
+struct ring_elt *
+allocate_exs_buffer_ring (int width, int buffer_size, int alignment, int offset, exs_mhandle_t *mhandlep)
+{
+
+    struct ring_elt *first_link;
+    struct ring_elt *temp_link;
+    struct ring_elt *prev_link;
+
+    int i;
+    int malloc_size;
+    int bytes_left;
+    int bytes_read;
+    int do_fill;
+
+    FILE *fill_source;
+
+    int mmap_size;
+    char *mmap_buffer, *mmap_buffer_aligned;
+
+    malloc_size = buffer_size + alignment + offset;
+
+    /* did the user wish to have the buffers pre-filled with data from a */
+    /* particular source? */
+    if (strcmp (fill_file, "") == 0) {
+        do_fill = 0;
+        fill_source = NULL;
+    } else {
+        do_fill = 1;
+        fill_source = (FILE *) fopen (fill_file, "r");
+        if (fill_source == (FILE *) NULL) {
+            perror ("Could not open requested fill file");
+            exit (1);
+        }
+    }
+
+    assert (width >= 1);
+
+    if (debug) {
+        fprintf (where, "allocate_exs_buffer_ring: "
+                 "width=%d buffer_size=%d alignment=%d offset=%d\n",
+                 width, buffer_size, alignment, offset);
+    }
+
+    /* allocate shared memory */
+    mmap_size = width * malloc_size;
+    mmap_buffer = (char *) mmap ((caddr_t)NULL, mmap_size+NBPG-1,
+                                 PROT_READ|PROT_WRITE,
+                                 MAP_SHARED|MAP_ANONYMOUS, -1, 0);
+    if (mmap_buffer == NULL) {
+        perror ("allocate_exs_buffer_ring: mmap failed");
+        exit (1);
+    }
+    mmap_buffer_aligned = (char *) ((uintptr_t)mmap_buffer & ~(NBPG-1));
+    if (debug) {
+        fprintf (where, "allocate_exs_buffer_ring: "
+                 "mmap buffer size=%d address=0x%p aligned=0x%p\n",
+                 mmap_size, mmap_buffer, mmap_buffer_aligned);
+    }
+
+    /* register shared memory */
+    *mhandlep = exs_mregister ((void *)mmap_buffer_aligned, (size_t)mmap_size, 0);
+    if (*mhandlep == EXS_MHANDLE_INVALID) {
+        perror ("allocate_exs_buffer_ring: exs_mregister failed");
+        exit (1);
+    }
+    if (debug) {
+        fprintf (where, "allocate_exs_buffer_ring: mhandle=%d\n",
+                 *mhandlep);
+    }
+
+    /* allocate ring elements */
+    first_link = (struct ring_elt *) malloc (width * sizeof (struct ring_elt));
+    if (first_link == NULL) {
+        printf ("malloc(%d) failed!\n", width * sizeof (struct ring_elt));
+        exit (1);
+    }
+
+    /* initialize buffer ring */
+    prev_link = first_link + width - 1;
+
+    for (i = 0, temp_link = first_link; i < width; i++, temp_link++) {
+
+        temp_link->buffer_base = (char *) mmap_buffer_aligned + (i*malloc_size);
+#ifndef WIN32
+        temp_link->buffer_ptr = (char *)
+            (((long)temp_link->buffer_base + (long)alignment - 1) &
+             ~((long)alignment - 1));
+#else
+        temp_link->buffer_ptr = (char *)
+            (((ULONG_PTR)temp_link->buffer_base + (ULONG_PTR)alignment - 1) &
+             ~((ULONG_PTR)alignment - 1));
+#endif
+        temp_link->buffer_ptr += offset;
+
+        if (debug) {
+            fprintf (where, "allocate_exs_buffer_ring: "
+                     "buffer: index=%d base=0x%p ptr=0x%p\n",
+                     i, temp_link->buffer_base, temp_link->buffer_ptr);
+        }
+
+        /* is where the buffer fill code goes. */
+        if (do_fill) {
+            bytes_left = buffer_size;
+            while (bytes_left) {
+                if (((bytes_read = (int) fread (temp_link->buffer_ptr,
+                                                1,
+                                                bytes_left,
+                                                fill_source)) == 0) &&
+                    (feof (fill_source))) {
+                    rewind (fill_source);
+                }
+                bytes_left -= bytes_read;
+            }
+        }
+
+        /* do linking */
+        prev_link->next = temp_link;
+        prev_link = temp_link;
+    }
+
+    return (first_link);        /* it's a circle, doesn't matter which we return */
+}
+
+#endif /* HAVE_ICSC_EXS */
+
+
+
+#ifdef HAVE_SENDFILE
+/* this routine will construct a ring of sendfile_ring_elt structs
+   that the routine sendfile_tcp_stream() will use to get parameters
+   to its calls to sendfile(). It will setup the ring to point at the
+   file specified in the global -F option that is already used to
+   pre-fill buffers in the send() case. 08/2000
+
+   if there is no file specified in a global -F option, we will create
+   a tempoarary file and fill it with random data and use that
+   instead.  raj 2007-08-09 */
+
+struct sendfile_ring_elt *
+alloc_sendfile_buf_ring(int width,
+                        int buffer_size,
+                        int alignment,
+                        int offset)
+
+{
+
+  struct sendfile_ring_elt *first_link = NULL;
+  struct sendfile_ring_elt *temp_link  = NULL;
+  struct sendfile_ring_elt *prev_link;
+  
+  int i;
+  int fildes;
+  struct stat statbuf;
+
+  /* if the user has not specified a file with the -F option, we will
+     fail the test. otherwise, go ahead and try to open the
+     file. 08/2000 */
+  if (strcmp(fill_file,"") == 0) {
+    /* use an temp file for the fill file */
+    char *temp_file;
+    int *temp_buffer;
+    
+    /* make sure we have at least an ints worth, even if the user is
+       using an insane buffer size for a sendfile test. we are
+       ass-u-me-ing that malloc will return something at least aligned
+       on an int boundary... */
+    temp_buffer = (int *) malloc(buffer_size + sizeof(int));
+    if (temp_buffer) {
+      /* ok, we have the buffer we are going to write, lets get a
+	 temporary filename */
+      temp_file = tmpnam(NULL);
+      if (NULL != temp_file) {
+	fildes = open(temp_file,O_RDWR | O_EXCL | O_CREAT,0600);
+	if (-1 != fildes) {
+	  int count;
+	  int *int_ptr;
+
+	  /* initialize the random number generator */
+	  srand(getpid());
+
+	  /* unlink the file so it goes poof when we
+	     exit. unless/until shown to be a problem we will
+	     blissfully ignore the return value. raj 2007-08-09 */
+	  unlink(temp_file);
+
+	  /* now fill-out the file with at least buffer_size * width bytes */
+	  for (count = 0; count < width; count++) {
+	    /* fill the buffer with random data.  it doesn't have to be
+	       really random, just "random enough" :) we do this here rather
+	       than up above because we want each write to the file to be
+	       different random data */
+	    int_ptr = temp_buffer;
+	    for (i = 0; i <= buffer_size/sizeof(int); i++) {
+	      *int_ptr = rand();
+	      int_ptr++;
+	    }
+	    if (write(fildes,temp_buffer,buffer_size+sizeof(int)) !=
+		buffer_size + sizeof(int)) {
+	      perror("allocate_sendfile_buf_ring: incomplete write");
+	      exit(-1);
+	    }
+	  }
+	}
+	else {
+	  perror("allocate_sendfile_buf_ring: could not open tempfile");
+	  exit(-1);
+	}
+      }
+      else {
+	perror("allocate_sendfile_buf_ring: could not allocate temp name");
+	exit(-1);
+      }
+    }
+    else {
+      perror("alloc_sendfile_buf_ring: could not allocate buffer for file");
+      exit(-1);
+    }
+  }
+  else {
+    /* the user pointed us at a file, so try it */
+    fildes = open(fill_file , O_RDONLY);
+    if (fildes == -1){
+      perror("alloc_sendfile_buf_ring: Could not open requested file");
+      exit(1);
+    }
+    /* make sure there is enough file there to allow us to make a
+       complete ring. that way we do not need additional logic in the
+       ring setup to deal with wrap-around issues. we might want that
+       someday, but not just now. 08/2000 */
+    if (stat(fill_file,&statbuf) != 0) {
+      perror("alloc_sendfile_buf_ring: could not stat file");
+      exit(1);
+    }
+    if (statbuf.st_size < (width * buffer_size)) {
+      /* the file is too short */
+      fprintf(stderr,"alloc_sendfile_buf_ring: specified file too small.\n");
+      fprintf(stderr,"file must be larger than send_width * send_size\n");
+      fflush(stderr);
+      exit(1);
+    }
+  }
+  
+  /* so, at this point we know that fildes is a descriptor which
+     references a file of sufficient size for our nefarious
+     porpoises. raj 2007-08-09 */
+
+  prev_link = NULL;
+  for (i = 1; i <= width; i++) {
+    /* get the ring element. we should probably make sure the malloc() 
+     was successful, but for now we'll just let the code bomb
+     mysteriously. 08/2000 */
+
+    temp_link = (struct sendfile_ring_elt *)
+      malloc(sizeof(struct sendfile_ring_elt));
+    if (temp_link == NULL) {
+      printf("malloc(%u) failed!\n", sizeof(struct sendfile_ring_elt));
+      exit(1);
+	}
+
+    /* remember the first one so we can close the ring at the end */
+
+    if (i == 1) {
+      first_link = temp_link;
+    }
+
+    /* now fill-in the fields of the structure with the apropriate
+       stuff. just how should we deal with alignment and offset I
+       wonder? until something better comes-up, I think we will just
+       ignore them. 08/2000 */
+
+    temp_link->fildes = fildes;      /* from which file do we send? */
+    temp_link->offset = offset;      /* starting at which offset? */
+    offset += buffer_size;           /* get ready for the next elt */
+    temp_link->length = buffer_size; /* how many bytes to send */
+    temp_link->hdtrl = NULL;         /* no header or trailer */
+    temp_link->flags = 0;            /* no flags */
+
+    /* is where the buffer fill code went. */
+
+    temp_link->next = prev_link;
+    prev_link = temp_link;
+  }
+  /* close the ring */
+  first_link->next = temp_link;
+  
+  return(first_link); /* it's a dummy ring */
+}
+
+#endif /* HAVE_SENDFILE */
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     dump_request()                                                  */
+ /*                                                                     */
+ /* display the contents of the request array to the user. it will      */
+ /* display the contents in decimal, hex, and ascii, with four bytes    */
+ /* per line.                                                           */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+dump_request()
+{
+int counter = 0;
+fprintf(where,"request contents:\n");
+for (counter = 0; counter < ((sizeof(netperf_request)/4)-3); counter += 4) {
+  fprintf(where,"%d:\t%8x %8x %8x %8x \t|%4.4s| |%4.4s| |%4.4s| |%4.4s|\n",
+          counter,
+          request_array[counter],
+          request_array[counter+1],
+          request_array[counter+2],
+          request_array[counter+3],
+          (char *)&request_array[counter],
+          (char *)&request_array[counter+1],
+          (char *)&request_array[counter+2],
+          (char *)&request_array[counter+3]);
+}
+fflush(where);
+}
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     dump_response()                                                 */
+ /*                                                                     */
+ /* display the content of the response array to the user. it will      */
+ /* display the contents in decimal, hex, and ascii, with four bytes    */
+ /* per line.                                                           */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+dump_response()
+{
+int counter = 0;
+
+fprintf(where,"response contents\n");
+for (counter = 0; counter < ((sizeof(netperf_response)/4)-3); counter += 4) {
+  fprintf(where,"%d:\t%8x %8x %8x %8x \t>%4.4s< >%4.4s< >%4.4s< >%4.4s<\n",
+          counter,
+          response_array[counter],
+          response_array[counter+1],
+          response_array[counter+2],
+          response_array[counter+3],
+          (char *)&response_array[counter],
+          (char *)&response_array[counter+1],
+          (char *)&response_array[counter+2],
+          (char *)&response_array[counter+3]);
+}
+fflush(where);
+}
+
+ /*
+
+      format_number()                                                 
+                                                                    
+  return a pointer to a formatted string containing the value passed
+  translated into the units specified. It assumes that the base units
+  are bytes. If the format calls for bits, it will use SI units (10^)
+  if the format calls for bytes, it will use CS units (2^)...  This
+  routine should look familiar to uses of the latest ttcp...
+
+  we would like to use "t" or "T" for transactions, but probably
+  should leave those for terabits and terabytes respectively, so for
+  transactions, we will use "x" which will, by default, do absolutely
+  nothing to the result.  why?  so we don't have to special case code
+  elsewhere such as in the TCP_RR-as-bidirectional test case.
+
+ */
+ 
+
+char *
+format_number(double number)
+{
+  static  char    fmtbuf[64];
+        
+  switch (libfmt) {
+  case 'K':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f" , number / 1024.0);
+    break;
+  case 'M':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number / 1024.0 / 1024.0);
+    break;
+  case 'G':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number / 1024.0 / 1024.0 / 1024.0);
+    break;
+  case 'k':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number * 8 / 1000.0);
+    break;
+  case 'm':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number * 8 / 1000.0 / 1000.0);
+    break;
+  case 'g':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number * 8 / 1000.0 / 1000.0 / 1000.0);
+    break;
+  case 'x':
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number);
+    break;
+  default:
+    snprintf(fmtbuf, sizeof(fmtbuf),  "%-7.2f", number / 1024.0);
+  }
+
+  return fmtbuf;
+}
+
+char
+format_cpu_method(int method)
+{
+
+  char method_char;
+
+  switch (method) {
+  case CPU_UNKNOWN:
+    method_char = 'U';
+    break;
+  case HP_IDLE_COUNTER:
+    method_char = 'I';
+    break;
+  case PSTAT:
+    method_char = 'P';
+    break;
+  case KSTAT:
+    method_char = 'K';
+    break;
+  case KSTAT_10:
+    method_char = 'M';
+    break;
+  case PERFSTAT:
+    method_char = 'E';
+    break;
+  case TIMES:             /* historical only, completely unsuitable
+			     for netperf's purposes */
+    method_char = 'T';
+    break;
+  case GETRUSAGE:         /* historical only, completely unsuitable
+			     for netperf;s purposes */
+    method_char = 'R';
+    break;
+  case LOOPER:
+    method_char = 'L';
+    break;
+  case NT_METHOD:
+    method_char = 'N';
+    break;
+  case PROC_STAT:
+    method_char = 'S';
+    break;
+  case SYSCTL:
+    method_char = 'C';
+    break;
+  case OSX:
+    method_char = 'O';
+    break;
+  default:
+    method_char = '?';
+  }
+  
+  return method_char;
+
+}
+
+char *
+format_units()
+{
+  static        char    unitbuf[64];
+  
+  switch (libfmt) {
+  case 'K':
+    strcpy(unitbuf, "KBytes");
+    break;
+  case 'M':
+    strcpy(unitbuf, "MBytes");
+    break;
+  case 'G':
+    strcpy(unitbuf, "GBytes");
+    break;
+  case 'k':
+    strcpy(unitbuf, "10^3bits");
+    break;
+  case 'm':
+    strcpy(unitbuf, "10^6bits");
+    break;
+  case 'g':
+    strcpy(unitbuf, "10^9bits");
+    break;
+  case 'x':
+    strcpy(unitbuf, "Trans");
+    break;
+    
+  default:
+    strcpy(unitbuf, "KBytes");
+  }
+  
+  return unitbuf;
+}
+
+
+/****************************************************************/
+/*                                                              */
+/*      shutdown_control()                                      */
+/*                                                              */
+/* tear-down the control connection between me and the server.  */
+/****************************************************************/
+
+void 
+shutdown_control()
+{
+
+  char  *buf = (char *)&netperf_response;
+  int   buflen = sizeof(netperf_response);
+
+  /* stuff for select, use fd_set for better compliance */
+  fd_set        readfds;
+  struct        timeval timeout;
+
+  if (debug) {
+    fprintf(where,
+            "shutdown_control: shutdown of control connection requested.\n");
+    fflush(where);
+  }
+
+  /* first, we say that we will be sending no more data on the */
+  /* connection */
+  if (shutdown(netlib_control,1) == SOCKET_ERROR) {
+    Print_errno(where,
+            "shutdown_control: error in shutdown");
+    fflush(where);
+    exit(1);
+  }
+
+  /* Now, we hang on a select waiting for the socket to become */
+  /* readable to receive the shutdown indication from the remote. this */
+  /* will be "just" like the recv_response() code */
+
+  /* we only select once. it is assumed that if the response is split */
+  /* (which should not be happening, that we will receive the whole */
+  /* thing and not have a problem ;-) */
+
+  FD_ZERO(&readfds);
+  FD_SET(netlib_control,&readfds);
+  timeout.tv_sec  = 60; /* wait one minute then punt */
+  timeout.tv_usec = 0;
+
+  /* select had better return one, or there was either a problem or a */
+  /* timeout... */
+  if (select(FD_SETSIZE,
+             &readfds,
+             0,
+             0,
+             &timeout) != 1) {
+    Print_errno(where,
+            "shutdown_control: no response received");
+    fflush(where);
+    exit(1);
+  }
+
+  /* we now assume that the socket has come ready for reading */
+  recv(netlib_control, buf, buflen,0);
+
+}
+
+/* 
+  bind_to_specific_processor will bind the calling process to the
+  processor in "processor"  It has lots of ugly ifdefs to deal with
+  all the different ways systems do processor affinity.  this is a
+  generalization of work initially done by stephen burger.  raj
+  2004/12/13 */
+
+void
+bind_to_specific_processor(int processor_affinity, int use_cpu_map)
+{
+
+  int mapped_affinity;
+
+  /* this is in place because the netcpu_looper processor affinity
+     ass-u-me-s a contiguous CPU id space starting with 0. for the
+     regular netperf/netserver affinity, we ass-u-me the user has used
+     a suitable CPU id even when the space is not contiguous and
+     starting from zero */
+  if (use_cpu_map) {
+    mapped_affinity = lib_cpu_map[processor_affinity];
+  }
+  else {
+    mapped_affinity = processor_affinity;
+  }
+
+#ifdef HAVE_MPCTL
+  /* indeed, at some point it would be a good idea to check the return
+     status and pass-along notification of error... raj 2004/12/13 */
+  mpctl(MPC_SETPROCESS_FORCE, mapped_affinity, getpid());
+#elif HAVE_PROCESSOR_BIND
+#include <sys/types.h>
+#include <sys/processor.h>
+#include <sys/procset.h>
+  processor_bind(P_PID,P_MYID,mapped_affinity,NULL);
+#elif HAVE_BINDPROCESSOR
+#include <sys/processor.h>
+  /* this is the call on AIX.  It takes a "what" of BINDPROCESS or
+     BINDTHRAD, then "who" and finally "where" which is a CPU number
+     or it seems PROCESSOR_CLASS_ANY there also seems to be a mycpu()
+     call to return the current CPU assignment.  this is all based on
+     the sys/processor.h include file.  from empirical testing, it
+     would seem that the my_cpu() call returns the current CPU on
+     which we are running rather than the CPU binding, so it's return
+     value will not tell you if you are bound vs unbound. */
+  bindprocessor(BINDPROCESS,getpid(),(cpu_t)mapped_affinity);
+#elif HAVE_SCHED_SETAFFINITY
+#include <sched.h>
+  /* in theory this should cover systems with more CPUs than bits in a
+     long, without having to specify __USE_GNU.  we "cheat" by taking
+     defines from /usr/include/bits/sched.h, which we ass-u-me is
+     included by <sched.h>.  If they are not there we will just
+     fall-back on what we had before, which is to use just the size of
+     an unsigned long. raj 2006-09-14 */
+
+#if defined(__CPU_SETSIZE)
+#define NETPERF_CPU_SETSIZE __CPU_SETSIZE
+#define NETPERF_CPU_SET(cpu, cpusetp)  __CPU_SET(cpu, cpusetp)
+#define NETPERF_CPU_ZERO(cpusetp)      __CPU_ZERO (cpusetp)
+  typedef cpu_set_t netperf_cpu_set_t;
+#else
+#define NETPERF_CPU_SETSIZE sizeof(unsigned long)
+#define NETPERF_CPU_SET(cpu, cpusetp) *cpusetp = 1 << cpu
+#define NETPERF_CPU_ZERO(cpusetp) *cpusetp = (unsigned long)0
+  typedef unsigned long netperf_cpu_set_t;
+#endif
+
+  netperf_cpu_set_t   netperf_cpu_set;
+  unsigned int        len = sizeof(netperf_cpu_set);
+
+  if (mapped_affinity < 8*sizeof(netperf_cpu_set)) {
+    NETPERF_CPU_ZERO(&netperf_cpu_set);
+    NETPERF_CPU_SET(mapped_affinity,&netperf_cpu_set);
+    
+    if (sched_setaffinity(getpid(), len, &netperf_cpu_set)) {
+      if (debug) {
+	fprintf(stderr, "failed to set PID %d's CPU affinity errno %d\n",
+		getpid(),errno);
+	fflush(stderr);
+      }
+    }
+  }
+  else {
+    if (debug) {
+	fprintf(stderr,
+		"CPU number larger than pre-compiled limits. Consider a recompile.\n");
+	fflush(stderr);
+      }
+  }
+      
+#elif HAVE_BIND_TO_CPU_ID
+  /* this is the one for Tru64 */
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/processor.h>
+
+  /* really should be checking a return code one of these days. raj
+     2005/08/31 */ 
+
+  bind_to_cpu_id(getpid(), mapped_affinity,0);
+
+#elif WIN32
+
+  {
+    ULONG_PTR AffinityMask;
+    ULONG_PTR ProcessAffinityMask;
+    ULONG_PTR SystemAffinityMask;
+    
+    if ((mapped_affinity < 0) || 
+	(mapped_affinity > MAXIMUM_PROCESSORS)) {
+      fprintf(where,
+	      "Invalid processor_affinity specified: %d\n", mapped_affinity);      fflush(where);
+      return;
+    }
+    
+    if (!GetProcessAffinityMask(
+				GetCurrentProcess(), 
+				&ProcessAffinityMask, 
+				&SystemAffinityMask))
+      {
+	perror("GetProcessAffinityMask failed");
+	fflush(stderr);
+	exit(1);
+      }
+    
+    AffinityMask = (ULONG_PTR)1 << mapped_affinity;
+    
+    if (AffinityMask & ProcessAffinityMask) {
+      if (!SetThreadAffinityMask( GetCurrentThread(), AffinityMask)) {
+	perror("SetThreadAffinityMask failed");
+	fflush(stderr);
+      }
+    } else if (debug) {
+      fprintf(where,
+	      "Processor affinity set to CPU# %d\n", mapped_affinity);
+      fflush(where);
+    }
+  }
+
+#else
+  if (debug) {
+    fprintf(where,
+	    "Processor affinity not available for this platform!\n");
+    fflush(where);
+  }
+#endif
+}
+
+
+/*
+ * Sets a socket to non-blocking operation.
+ */
+int
+set_nonblock (SOCKET sock)
+{
+#ifdef WIN32
+  unsigned long flags = 1;
+  return (ioctlsocket(sock, FIONBIO, &flags) != SOCKET_ERROR);
+#else
+  return (fcntl(sock, F_SETFL, O_NONBLOCK) != -1);
+#endif
+}
+
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     send_request()                                                  */
+ /*                                                                     */
+ /* send a netperf request on the control socket to the remote half of  */
+ /* the connection. to get us closer to intervendor interoperability,   */
+ /* we will call htonl on each of the int that compose the message to   */
+ /* be sent. the server-half of the connection will call the ntohl      */
+ /* routine to undo any changes that may have been made...              */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+send_request()
+{
+  int   counter=0;
+  
+  /* display the contents of the request if the debug level is high */
+  /* enough. otherwise, just send the darned thing ;-) */
+  
+  if (debug > 1) {
+    fprintf(where,"entered send_request...contents before htonl:\n");
+    dump_request();
+  }
+
+  /* pass the processor affinity request value to netserver */
+  /* this is a kludge and I know it.  sgb 8/11/04           */
+
+  netperf_request.content.dummy = remote_proc_affinity;
+
+  /* put the entire request array into network order. We do this */
+  /* arbitrarily rather than trying to figure-out just how much */
+  /* of the request array contains real information. this should */
+  /* be simpler, and at any rate, the performance of sending */
+  /* control messages for this benchmark is not of any real */
+  /* concern. */ 
+  
+  for (counter=0;counter < sizeof(netperf_request)/4; counter++) {
+    request_array[counter] = htonl(request_array[counter]);
+  }
+  
+  if (debug > 1) {
+    fprintf(where,"send_request...contents after htonl:\n");
+    dump_request();
+
+    fprintf(where,
+            "\nsend_request: about to send %u bytes from %p\n",
+            sizeof(netperf_request),
+            &netperf_request);
+    fflush(where);
+  }
+
+  if (send(netlib_control,
+           (char *)&netperf_request,
+           sizeof(netperf_request),
+           0) != sizeof(netperf_request)) {
+    perror("send_request: send call failure");
+    
+    exit(1);
+  }
+}
+
+/***********************************************************************/
+ /*                                                                     */
+ /*     send_response()                                                 */
+ /*                                                                     */
+ /* send a netperf response on the control socket to the remote half of */
+ /* the connection. to get us closer to intervendor interoperability,   */
+ /* we will call htonl on each of the int that compose the message to   */
+ /* be sent. the other half of the connection will call the ntohl       */
+ /* routine to undo any changes that may have been made...              */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+send_response()
+{
+  int   counter=0;
+  int	bytes_sent;
+
+  /* display the contents of the request if the debug level is high */
+  /* enough. otherwise, just send the darned thing ;-) */
+
+  if (debug > 1) {
+    fprintf(where,
+            "send_response: contents of %u ints before htonl\n",
+            sizeof(netperf_response)/4);
+    dump_response();
+  }
+
+  /* put the entire response_array into network order. We do this */
+  /* arbitrarily rather than trying to figure-out just how much of the */
+  /* request array contains real information. this should be simpler, */
+  /* and at any rate, the performance of sending control messages for */
+  /* this benchmark is not of any real concern. */
+  
+  for (counter=0;counter < sizeof(netperf_response)/4; counter++) {
+    response_array[counter] = htonl(response_array[counter]);
+  }
+  
+  if (debug > 1) {
+    fprintf(where,
+            "send_response: contents after htonl\n");
+    dump_response();
+    fprintf(where,
+            "about to send %u bytes from %p\n",
+            sizeof(netperf_response),
+            &netperf_response);
+    fflush(where);
+  }
+
+  /*KC*/
+  if ((bytes_sent = send(server_sock,
+           (char *)&netperf_response,
+           sizeof(netperf_response),
+           0)) != sizeof(netperf_response)) {
+    perror("send_response: send call failure");
+	fprintf(where, "BytesSent: %d\n", bytes_sent);
+    exit(1);
+  }
+  
+}
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     recv_request()                                                  */
+ /*                                                                     */
+ /* receive the remote's request on the control socket. we will put     */
+ /* the entire response into host order before giving it to the         */
+ /* calling routine. hopefully, this will go most of the way to         */
+ /* insuring intervendor interoperability. if there are any problems,   */
+ /* we will just punt the entire situation.                             */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+recv_request()
+{
+int     tot_bytes_recvd,
+        bytes_recvd, 
+        bytes_left;
+char    *buf = (char *)&netperf_request;
+int     buflen = sizeof(netperf_request);
+int     counter;
+
+tot_bytes_recvd = 0;    
+ bytes_recvd = 0;     /* nt_lint; bytes_recvd uninitialized if buflen == 0 */
+bytes_left      = buflen;
+while ((tot_bytes_recvd != buflen) &&
+       ((bytes_recvd = recv(server_sock, buf, bytes_left,0)) > 0 )) {
+  tot_bytes_recvd += bytes_recvd;
+  buf             += bytes_recvd;
+  bytes_left      -= bytes_recvd;
+}
+
+/* put the request into host order */
+
+for (counter = 0; counter < sizeof(netperf_request)/sizeof(int); counter++) {
+  request_array[counter] = ntohl(request_array[counter]);
+}
+
+if (debug) {
+  fprintf(where,
+          "recv_request: received %d bytes of request.\n",
+          tot_bytes_recvd);
+  fflush(where);
+}
+
+if (bytes_recvd == SOCKET_ERROR) {
+  Print_errno(where,
+          "recv_request: error on recv");
+  fflush(where);
+  exit(1);
+}
+
+if (bytes_recvd == 0) {
+  /* the remote has shutdown the control connection, we should shut it */
+  /* down as well and exit */
+
+  if (debug) {
+    fprintf(where,
+            "recv_request: remote requested shutdown of control\n");
+    fflush(where);
+  }
+
+  if (netlib_control != INVALID_SOCKET) {
+        shutdown_control();
+  }
+  exit(0);
+}
+
+if (tot_bytes_recvd < buflen) {
+  if (debug > 1)
+    dump_request();
+
+  fprintf(where,
+          "recv_request: partial request received of %d bytes\n",
+          tot_bytes_recvd);
+  fflush(where);
+  exit(1);
+}
+
+ if (debug > 1) {
+   dump_request();
+ } 
+
+  /* get the processor affinity request value from netperf */
+  /* this is a kludge and I know it.  sgb 8/11/04          */
+
+  local_proc_affinity = netperf_request.content.dummy;
+
+  if (local_proc_affinity != -1) {
+    bind_to_specific_processor(local_proc_affinity,0);
+  } 
+
+}
+
+ /*
+
+      recv_response_timed()                                           
+                                                                    
+ receive the remote's response on the control socket. we will put the
+ entire response into host order before giving it to the calling
+ routine. hopefully, this will go most of the way to insuring
+ intervendor interoperability. if there are any problems, we will just
+ punt the entire situation.
+                                                                    
+ The call to select at the beginning is to get us out of hang
+ situations where the remote gives-up but we don't find-out about
+ it. This seems to happen only rarely, but it would be nice to be
+ somewhat robust ;-)
+
+ The "_timed" part is to allow the caller to add (or I suppose
+ subtract) from the length of timeout on the select call. this was
+ added since not all the CPU utilization mechanisms require a 40
+ second calibration, and we used to have an aribtrary 40 second sleep
+ in "calibrate_remote_cpu" - since we don't _always_ need that, we
+ want to simply add 40 seconds to the select() timeout from that call,
+ but don't want to change all the "recv_response" calls in the code
+ right away.  sooo, we push the functionality of the old
+ recv_response() into a new recv_response_timed(addl_timout) call, and
+ have recv_response() call recv_response_timed(0).  raj 2005-05-16
+
+ */
+
+
+void
+recv_response_timed(int addl_time)
+{
+int     tot_bytes_recvd,
+        bytes_recvd = 0, 
+        bytes_left;
+char    *buf = (char *)&netperf_response;
+int     buflen = sizeof(netperf_response);
+int     counter;
+
+ /* stuff for select, use fd_set for better compliance */
+fd_set  readfds;
+struct  timeval timeout;
+
+tot_bytes_recvd = 0;    
+bytes_left      = buflen;
+
+/* zero out the response structure */
+
+/* BUG FIX SJB 2/4/93 - should be < not <= */
+for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) {
+        response_array[counter] = 0;
+}
+
+ /* we only select once. it is assumed that if the response is split */
+ /* (which should not be happening, that we will receive the whole */
+ /* thing and not have a problem ;-) */
+
+FD_ZERO(&readfds);
+FD_SET(netlib_control,&readfds);
+timeout.tv_sec  = 120 + addl_time;  /* wait at least two minutes
+                                      before punting - the USE_LOOPER
+                                      CPU stuff may cause remote's to
+                                      have a bit longer time of it
+                                      than 60 seconds would allow.
+                                      triggered by fix from Jeff
+                                      Dwork. */
+timeout.tv_usec = 0;
+
+ /* select had better return one, or there was either a problem or a */
+ /* timeout... */
+
+if ((counter = select(FD_SETSIZE,
+                      &readfds,
+                      0,
+                      0,
+                      &timeout)) != 1) {
+  fprintf(where,
+          "netperf: receive_response: no response received. errno %d counter %d\n",
+          errno,
+          counter);
+  exit(1);
+}
+
+while ((tot_bytes_recvd != buflen) &&
+       ((bytes_recvd = recv(netlib_control, buf, bytes_left,0)) > 0 )) {
+  tot_bytes_recvd += bytes_recvd;
+  buf             += bytes_recvd;
+  bytes_left      -= bytes_recvd;
+}
+
+if (debug) {
+  fprintf(where,"recv_response: received a %d byte response\n",
+          tot_bytes_recvd);
+  fflush(where);
+}
+
+/* put the response into host order */
+
+for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) {
+  response_array[counter] = ntohl(response_array[counter]);
+}
+
+if (bytes_recvd == SOCKET_ERROR) {
+        perror("recv_response");
+        exit(1);
+}
+if (tot_bytes_recvd < buflen) {
+  fprintf(stderr,
+          "recv_response: partial response received: %d bytes\n",
+          tot_bytes_recvd);
+  fflush(stderr);
+  if (debug > 1)
+    dump_response();
+  exit(1);
+}
+if (debug > 1) {
+  dump_response();
+}
+}
+
+void
+recv_response() 
+{
+  recv_response_timed(0);
+}
+
+
+
+#if defined(USE_PSTAT) || defined (USE_SYSCTL)
+int
+hi_32(big_int)
+     long long *big_int;
+{
+  union overlay_u {
+    long long  dword;
+    long       words[2];
+  } *overlay;
+
+  overlay = (union overlay_u *)big_int;
+  /* on those systems which are byte swapped, we really wish to */
+  /* return words[1] - at least I think so - raj 4/95 */
+  if (htonl(1L) == 1L) {
+    /* we are a "normal" :) machine */
+    return(overlay->words[0]);
+  }
+  else {
+    return(overlay->words[1]);
+  }
+}
+
+int
+lo_32(big_int)
+     long long *big_int;
+{
+  union overlay_u {
+    long long  dword;
+    long       words[2];
+  } *overlay;
+
+  overlay = (union overlay_u *)big_int;
+  /* on those systems which are byte swapped, we really wish to */
+  /* return words[0] - at least I think so - raj 4/95 */
+  if (htonl(1L) == 1L) {
+    /* we are a "normal" :) machine */
+    return(overlay->words[1]);
+  }
+  else {
+    return(overlay->words[0]);
+  }
+}
+
+#endif /* USE_PSTAT || USE_SYSCTL */
+
+
+void libmain()
+{
+fprintf(where,"hello world\n");
+fprintf(where,"debug: %d\n",debug);
+}
+
+
+void
+set_sock_buffer (SOCKET sd, enum sock_buffer which, int requested_size, int *effective_sizep)
+{
+#ifdef SO_SNDBUF
+  int optname = (which == SEND_BUFFER) ? SO_SNDBUF : SO_RCVBUF;
+  netperf_socklen_t sock_opt_len;
+
+  /* seems that under Windows, setting a value of zero is how one
+     tells the stack you wish to enable copy-avoidance. Knuth only
+     knows what it will do on other stacks, but it might be
+     interesting to find-out, so we won't bother #ifdef'ing the change
+     to allow asking for 0 bytes. Courtesy of SAF, 2007-05  raj
+     2007-05-31 */
+  if (requested_size >= 0) {
+    if (setsockopt(sd, SOL_SOCKET, optname,
+		   (char *)&requested_size, sizeof(int)) < 0) {
+      fprintf(where, "netperf: set_sock_buffer: %s option: errno %d\n",
+	      (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+    if (debug > 1) {
+      fprintf(where, "netperf: set_sock_buffer: %s of %d requested.\n",
+	      (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF",
+	      requested_size);
+      fflush(where);
+    }
+  }
+
+  /* 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. */
+
+  sock_opt_len = sizeof(netperf_socklen_t);
+  if (getsockopt(sd, SOL_SOCKET, optname, (char *)effective_sizep,
+		 &sock_opt_len) < 0) {
+    fprintf(where, "netperf: set_sock_buffer: getsockopt %s: errno %d\n",
+	    (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF", errno);
+    fflush(where);
+    *effective_sizep = -1;
+  }
+
+  if (debug) {
+    fprintf(where, "netperf: set_sock_buffer: "
+	    "%s socket size determined to be %d\n",
+	    (which == SEND_BUFFER) ? "send" : "receive", *effective_sizep);
+    fflush(where);
+  }
+#else /* SO_SNDBUF */
+  *effective_size = -1;
+#endif /* SO_SNDBUF */
+}
+
+void
+dump_addrinfo(FILE *dumploc, struct addrinfo *info,
+              char *host, char *port, int family)
+{
+  struct sockaddr *ai_addr;
+  struct addrinfo *temp;
+  temp=info;
+
+  fprintf(dumploc, "getaddrinfo returned the following for host '%s' ", host);
+  fprintf(dumploc, "port '%s' ", port);
+  fprintf(dumploc, "family %s\n", inet_ftos(family));
+  while (temp) {
+    /* seems that Solaris 10 GA bits will not give a canonical name
+       for ::0 or 0.0.0.0, and their fprintf() cannot deal with a null
+       pointer, so we have to check for a null pointer.  probably a
+       safe thing to do anyway, eventhough it was not necessary on
+       linux or hp-ux. raj 2005-02-09 */
+    if (temp->ai_canonname) {
+      fprintf(dumploc,
+	      "\tcannonical name: '%s'\n",temp->ai_canonname);
+    }
+    else {
+      fprintf(dumploc,
+	      "\tcannonical name: '%s'\n","(nil)");
+    }
+    fprintf(dumploc,
+            "\tflags: %x family: %s: socktype: %s protocol %s addrlen %d\n",
+            temp->ai_flags,
+            inet_ftos(temp->ai_family),
+            inet_ttos(temp->ai_socktype),
+            inet_ptos(temp->ai_protocol),
+            temp->ai_addrlen);
+    ai_addr = temp->ai_addr;
+    if (ai_addr != NULL) {
+      fprintf(dumploc,
+              "\tsa_family: %s sadata: %d %d %d %d %d %d\n",
+              inet_ftos(ai_addr->sa_family),
+              (u_char)ai_addr->sa_data[0],
+              (u_char)ai_addr->sa_data[1],
+              (u_char)ai_addr->sa_data[2],
+              (u_char)ai_addr->sa_data[3],
+              (u_char)ai_addr->sa_data[4],
+              (u_char)ai_addr->sa_data[5]);
+    }
+    temp = temp->ai_next;
+  }
+  fflush(dumploc);
+}
+
+/*
+  establish_control()
+
+set-up the control connection between netperf and the netserver so we
+can actually run some tests. if we cannot establish the control
+connection, that may or may not be a good thing, so we will let the
+caller decide what to do.
+
+to assist with pesky end-to-end-unfriendly things like firewalls, we
+allow the caller to specify both the remote hostname and port, and the
+local addressing info.  i believe that in theory it is possible to
+have an IPv4 endpoint and an IPv6 endpoint communicate with one
+another, but for the time being, we are only going to take-in one
+requested address family parameter. this means that the only way
+(iirc) that we might get a mixed-mode connection would be if the
+address family is specified as AF_UNSPEC, and getaddrinfo() returns
+different families for the local and server names.
+
+the "names" can also be IP addresses in ASCII string form.
+
+raj 2003-02-27 */
+
+SOCKET
+establish_control_internal(char *hostname,
+			   char *port,
+			   int   remfam,
+			   char *localhost,
+			   char *localport,
+			   int   locfam)
+{
+  int not_connected;
+  SOCKET control_sock;
+  int count;
+  int error;
+
+  struct addrinfo   hints;
+  struct addrinfo  *local_res;
+  struct addrinfo  *remote_res;
+  struct addrinfo  *local_res_temp;
+  struct addrinfo  *remote_res_temp;
+
+  if (debug) {
+    fprintf(where,
+            "establish_control called with host '%s' port '%s' remfam %s\n",
+            hostname,
+            port,
+            inet_ftos(remfam));
+    fprintf(where,
+            "\t\tlocal '%s' port '%s' locfam %s\n",
+            localhost,
+            localport,
+            inet_ftos(locfam));
+    fflush(where);
+  }
+
+  /* first, we do the remote */
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = remfam;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_protocol = IPPROTO_TCP;
+  hints.ai_flags = 0|AI_CANONNAME;
+  count = 0;
+  do {
+    error = getaddrinfo((char *)hostname,
+                        (char *)port,
+                        &hints,
+                        &remote_res);
+    count += 1;
+    if (error == EAI_AGAIN) {
+      if (debug) {
+        fprintf(where,"Sleeping on getaddrinfo EAI_AGAIN\n");
+        fflush(where);
+      }
+      sleep(1);
+    }
+  } while ((error == EAI_AGAIN) && (count <= 5));
+
+  if (error) {
+    printf("establish control: could not resolve remote '%s' port '%s' af %s",
+           hostname,
+           port,
+           inet_ftos(remfam));
+    printf("\n\tgetaddrinfo returned %d %s\n",
+           error,
+           gai_strerror(error));
+    return(INVALID_SOCKET);
+  }
+
+  if (debug) {
+    dump_addrinfo(where, remote_res, hostname, port, remfam);
+  }
+
+  /* now we do the local */
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = locfam;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_protocol = IPPROTO_TCP;
+  hints.ai_flags = AI_PASSIVE|AI_CANONNAME;
+  count = 0;
+  do {
+    count += 1;
+    error = getaddrinfo((char *)localhost,
+                           (char *)localport,
+                           &hints,
+                           &local_res);
+    if (error == EAI_AGAIN) {
+      if (debug) {
+        fprintf(where,
+                "Sleeping on getaddrinfo(%s,%s) EAI_AGAIN count %d \n",
+                localhost,
+                localport,
+                count);
+        fflush(where);
+      }
+      sleep(1);
+    }
+  } while ((error == EAI_AGAIN) && (count <= 5));
+
+  if (error) {
+    printf("establish control: could not resolve local '%s' port '%s' af %s",
+           localhost,
+           localport,
+           inet_ftos(locfam));
+    printf("\n\tgetaddrinfo returned %d %s\n",
+           error,
+           gai_strerror(error));
+    return(INVALID_SOCKET);
+  }
+
+  if (debug) {
+    dump_addrinfo(where, local_res, localhost, localport, locfam);
+  }
+
+  not_connected = 1;
+  local_res_temp = local_res;
+  remote_res_temp = remote_res;
+  /* we want to loop through all the possibilities. looping on the
+     local addresses will be handled within the while loop.  I suppose
+     these is some more "C-expert" way to code this, but it has not
+     lept to mind just yet :)  raj 2003-02024 */
+
+  while (remote_res_temp != NULL) {
+
+    /* I am guessing that we should use the address family of the
+       local endpoint, and we will not worry about mixed family types
+       - presumeably the stack or other transition mechanisms will be
+       able to deal with that for us. famous last words :)  raj 2003-02-26 */
+    control_sock = socket(local_res_temp->ai_family,
+                          SOCK_STREAM,
+                          0);
+    if (control_sock == INVALID_SOCKET) {
+      /* at some point we'll need a more generic "display error"
+         message for when/if we use GUIs and the like. unlike a bind
+         or connect failure, failure to allocate a socket is
+         "immediately fatal" and so we return to the caller. raj 2003-02-24 */
+      if (debug) {
+        perror("establish_control: unable to allocate control socket");
+      }
+      return(INVALID_SOCKET);
+    }
+
+    /* if we are going to control the local enpoint addressing, we
+       need to call bind. of course, we should probably be setting one
+       of the SO_REUSEmumble socket options? raj 2005-02-04 */
+    if (bind(control_sock,
+	     local_res_temp->ai_addr,
+	     local_res_temp->ai_addrlen) == 0) {
+      if (debug) {
+	fprintf(where,
+		"bound control socket to %s and %s\n",
+		localhost,
+		localport);
+      }
+
+      if (connect(control_sock,
+		  remote_res_temp->ai_addr,
+		  remote_res_temp->ai_addrlen) == 0) {
+	/* we have successfully connected to the remote netserver */
+	if (debug) {
+	  fprintf(where,
+		  "successful connection to remote netserver at %s and %s\n",
+		  hostname,
+		  port);
+	}
+	not_connected = 0;
+	/* this should get us out of the while loop */
+	break;
+      } else {
+	/* the connect call failed */
+	if (debug) {
+	  fprintf(where,
+		  "establish_control: connect failed, errno %d %s\n",
+		  errno,
+		  strerror(errno));
+	  fprintf(where, "    trying next address combination\n");
+	  fflush(where);
+	}
+      }
+    }
+    else {
+      /* the bind failed */
+      if (debug) {
+	fprintf(where,
+		"establish_control: bind failed, errno %d %s\n",
+		errno,
+		strerror(errno));
+	fprintf(where, "    trying next address combination\n");
+	fflush(where);
+      }
+    }
+
+    if ((local_res_temp = local_res_temp->ai_next) == NULL) {
+      /* wrap the local and move to the next server, don't forget to
+         close the current control socket. raj 2003-02-24 */
+      local_res_temp = local_res;
+      /* the outer while conditions will deal with the case when we
+         get to the end of all the possible remote addresses. */
+      remote_res_temp = remote_res_temp->ai_next;
+      /* it is simplest here to just close the control sock. since
+         this is not a performance critical section of code, we
+         don't worry about overheads for socket allocation or
+         close. raj 2003-02-24 */
+    }
+    close(control_sock);
+  }
+
+  /* we no longer need the addrinfo stuff */
+  freeaddrinfo(local_res);
+  freeaddrinfo(remote_res);
+
+  /* so, we are either connected or not */
+  if (not_connected) {
+    fprintf(where, "establish control: are you sure there is a netserver listening on %s at port %s?\n",hostname,port);
+    fflush(where);
+    return(INVALID_SOCKET);
+  }
+  /* at this point, we are connected.  we probably want some sort of
+     version check with the remote at some point. raj 2003-02-24 */
+  return(control_sock);
+}
+
+void
+establish_control(char *hostname,
+		  char *port,
+		  int   remfam,
+		  char *localhost,
+		  char *localport,
+		  int   locfam)
+
+{
+
+  netlib_control = establish_control_internal(hostname,
+					      port,
+					      remfam,
+					      localhost,
+					      localport,
+					      locfam);
+  if (netlib_control == INVALID_SOCKET) {
+    fprintf(where,
+	    "establish_control could not establish the control connection from %s port %s address family %s to %s port %s address family %s\n",
+	    localhost,localport,inet_ftos(locfam),
+	    hostname,port,inet_ftos(remfam));
+    fflush(where);
+    exit(INVALID_SOCKET);
+  }
+}
+
+
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     get_id()                                                        */
+ /*                                                                     */
+ /* Return a string to the calling routine that contains the            */
+ /* identifying information for the host we are running on. This        */
+ /* information will then either be displayed locally, or returned to   */
+ /* a remote caller for display there.                                  */
+ /*                                                                     */
+ /***********************************************************************/
+
+char *
+get_id()
+{
+	static char id_string[80];
+#ifdef WIN32
+char                    system_name[MAX_COMPUTERNAME_LENGTH+1] ;
+DWORD                   name_len = MAX_COMPUTERNAME_LENGTH + 1 ;
+#else
+struct  utsname         system_name;
+#endif /* WIN32 */
+
+#ifdef WIN32
+ SYSTEM_INFO SystemInfo;
+ GetSystemInfo( &SystemInfo ) ;
+ if ( !GetComputerName(system_name , &name_len) )
+   strcpy(system_name , "no_name") ;
+#else
+ if (uname(&system_name) <0) {
+   perror("identify_local: uname");
+   exit(1);
+ }
+#endif /* WIN32 */
+
+ snprintf(id_string, sizeof(id_string),
+#ifdef WIN32
+	  "%-15s%-15s%d.%d%d",
+	  "Windows NT",
+	  system_name ,
+	  GetVersion() & 0xFF ,
+	  GetVersion() & 0xFF00 ,
+	  SystemInfo.dwProcessorType
+	  
+#else
+	  "%-15s%-15s%-15s%-15s%-15s",
+	  system_name.sysname,
+	  system_name.nodename,
+	  system_name.release,
+	  system_name.version,
+	  system_name.machine
+#endif /* WIN32 */
+	  );
+ return (id_string);
+}
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     identify_local()                                                */
+ /*                                                                     */
+ /* Display identifying information about the local host to the user.   */
+ /* At first release, this information will be the same as that which   */
+ /* is returned by the uname -a command, with the exception of the      */
+ /* idnumber field, which seems to be a non-POSIX item, and hence       */
+ /* non-portable.                                                       */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+identify_local()
+{
+
+char *local_id;
+
+local_id = get_id();
+
+fprintf(where,"Local Information \n\
+Sysname       Nodename       Release        Version        Machine\n");
+
+fprintf(where,"%s\n",
+       local_id);
+
+}
+
+
+ /***********************************************************************/
+ /*                                                                     */
+ /*     identify_remote()                                               */
+ /*                                                                     */
+ /* Display identifying information about the remote host to the user.  */
+ /* At first release, this information will be the same as that which   */
+ /* is returned by the uname -a command, with the exception of the      */
+ /* idnumber field, which seems to be a non-POSIX item, and hence       */
+ /* non-portable. A request is sent to the remote side, which will      */
+ /* return a string containing the utsname information in a             */
+ /* pre-formatted form, which is then displayed after the header.       */
+ /*                                                                     */
+ /***********************************************************************/
+
+void
+identify_remote()
+{
+
+char    *remote_id="";
+
+/* send a request for node info to the remote */
+netperf_request.content.request_type = NODE_IDENTIFY;
+
+send_request();
+
+/* and now wait for the reply to come back */
+
+recv_response();
+
+if (netperf_response.content.serv_errno) {
+        Set_errno(netperf_response.content.serv_errno);
+        perror("identify_remote: on remote");
+        exit(1);
+}
+
+fprintf(where,"Remote Information \n\
+Sysname       Nodename       Release        Version        Machine\n");
+
+fprintf(where,"%s",
+       remote_id);
+}
+
+void
+cpu_start(int measure_cpu)
+{
+
+  gettimeofday(&time1,
+               &tz);
+  
+  if (measure_cpu) {
+    cpu_util_init();
+    measuring_cpu = 1;
+    cpu_method = get_cpu_method();
+    cpu_start_internal();
+  }
+}
+
+
+void
+cpu_stop(int measure_cpu, float *elapsed)
+
+{
+
+  int     sec,
+    usec;
+
+  if (measure_cpu) {
+    cpu_stop_internal();
+    cpu_util_terminate();
+  }
+  
+  gettimeofday(&time2,
+	       &tz);
+  
+  if (time2.tv_usec < time1.tv_usec) {
+    time2.tv_usec += 1000000;
+    time2.tv_sec  -= 1;
+  }
+  
+  sec     = time2.tv_sec - time1.tv_sec;
+  usec    = time2.tv_usec - time1.tv_usec;
+  lib_elapsed     = (float)sec + ((float)usec/(float)1000000.0);
+  
+  *elapsed = lib_elapsed;
+  
+}
+
+
+double
+calc_thruput_interval(double units_received,double elapsed)
+
+{
+  double        divisor;
+
+  /* We will calculate the thruput in libfmt units/second */
+  switch (libfmt) {
+  case 'K':
+    divisor = 1024.0;
+    break;
+  case 'M':
+    divisor = 1024.0 * 1024.0;
+    break;
+  case 'G':
+    divisor = 1024.0 * 1024.0 * 1024.0;
+    break;
+  case 'k':
+    divisor = 1000.0 / 8.0;
+    break;
+  case 'm':
+    divisor = 1000.0 * 1000.0 / 8.0;
+    break;
+  case 'g':
+    divisor = 1000.0 * 1000.0 * 1000.0 / 8.0;
+    break;
+    
+  default:
+    divisor = 1024.0;
+  }
+  
+  return (units_received / divisor / elapsed);
+
+}
+
+double
+calc_thruput(double units_received)
+
+{
+  return(calc_thruput_interval(units_received,lib_elapsed));
+}
+
+/* these "_omni" versions are ones which understand 'x' as a unit,
+   meaning transactions/s.  we have a separate routine rather than
+   convert the existing routine so we don't have to go and change
+   _all_ the nettest_foo.c files at one time.  raj 2007-06-08 */
+
+double
+calc_thruput_interval_omni(double units_received,double elapsed)
+
+{
+  double        divisor;
+
+  /* We will calculate the thruput in libfmt units/second */
+  switch (libfmt) {
+  case 'K':
+    divisor = 1024.0;
+    break;
+  case 'M':
+    divisor = 1024.0 * 1024.0;
+    break;
+  case 'G':
+    divisor = 1024.0 * 1024.0 * 1024.0;
+    break;
+  case 'k':
+    divisor = 1000.0 / 8.0;
+    break;
+  case 'm':
+    divisor = 1000.0 * 1000.0 / 8.0;
+    break;
+  case 'g':
+    divisor = 1000.0 * 1000.0 * 1000.0 / 8.0;
+    break;
+  case 'x':
+    divisor = 1.0;
+    break;
+
+  default:
+    fprintf(where,
+	    "WARNING calc_throughput_internal_omni: unknown units %c\n",
+	    libfmt);
+    fflush(where);
+    divisor = 1024.0;
+  }
+  
+  return (units_received / divisor / elapsed);
+
+}
+
+double
+calc_thruput_omni(double units_received)
+
+{
+  return(calc_thruput_interval_omni(units_received,lib_elapsed));
+}
+
+
+
+
+
+float 
+calc_cpu_util(float elapsed_time)
+{
+  return(calc_cpu_util_internal(elapsed_time));
+}
+
+float 
+calc_service_demand_internal(double unit_divisor,
+			     double units_sent,
+			     float elapsed_time,
+			     float cpu_utilization,
+			     int num_cpus)
+
+{
+
+  double service_demand;
+  double thruput;
+
+  if (debug) {
+    fprintf(where,"calc_service_demand called:  units_sent = %f\n",
+            units_sent);
+    fprintf(where,"                             elapsed_time = %f\n",
+            elapsed_time);
+    fprintf(where,"                             cpu_util = %f\n",
+            cpu_utilization);
+    fprintf(where,"                             num cpu = %d\n",
+            num_cpus);
+    fflush(where);
+  }
+
+  if (num_cpus == 0) num_cpus = lib_num_loc_cpus;
+  
+  if (elapsed_time == 0.0) {
+    elapsed_time = lib_elapsed;
+  }
+  if (cpu_utilization == 0.0) {
+    cpu_utilization = lib_local_cpu_util;
+  }
+  
+  thruput = (units_sent / 
+             (double) unit_divisor / 
+             (double) elapsed_time);
+
+  /* on MP systems, it is necessary to multiply the service demand by */
+  /* the number of CPU's. at least, I believe that to be the case:) */
+  /* raj 10/95 */
+
+  /* thruput has a "per second" component. if we were using 100% ( */
+  /* 100.0) of the CPU in a second, that would be 1 second, or 1 */
+  /* millisecond, so we multiply cpu_utilization by 10 to go to */
+  /* milliseconds, or 10,000 to go to micro seconds. With revision */
+  /* 2.1, the service demand measure goes to microseconds per unit. */
+  /* raj 12/95 */ 
+  service_demand = (cpu_utilization*10000.0/thruput) * 
+    (float) num_cpus;
+  
+  if (debug) {
+    fprintf(where,"calc_service_demand using:   units_sent = %f\n",
+            units_sent);
+    fprintf(where,"                             elapsed_time = %f\n",
+            elapsed_time);
+    fprintf(where,"                             cpu_util = %f\n",
+            cpu_utilization);
+    fprintf(where,"                             num cpu = %d\n",
+            num_cpus);
+    fprintf(where,"calc_service_demand got:     thruput = %f\n",
+            thruput);
+    fprintf(where,"                             servdem = %f\n",
+            service_demand);
+    fflush(where);
+  }
+  return (float)service_demand;
+}
+
+float calc_service_demand(double units_sent,
+                          float elapsed_time,
+                          float cpu_utilization,
+                          int num_cpus)
+
+{
+
+  double unit_divisor = (double)1024.0;
+
+  return(calc_service_demand_internal(unit_divisor,
+				      units_sent,
+				      elapsed_time,
+				      cpu_utilization,
+				      num_cpus));
+}
+
+float calc_service_demand_trans(double units_sent,
+				float elapsed_time,
+				float cpu_utilization,
+				int num_cpus)
+
+{
+
+  double unit_divisor = (double)1.0;
+
+  return(calc_service_demand_internal(unit_divisor,
+				      units_sent,
+				      elapsed_time,
+				      cpu_utilization,
+				      num_cpus));
+}
+
+
+
+float
+calibrate_local_cpu(float local_cpu_rate)
+{
+  
+  lib_num_loc_cpus = get_num_cpus();
+
+  lib_use_idle = 0;
+#ifdef USE_LOOPER
+  cpu_util_init();
+  lib_use_idle = 1;
+#endif /* USE_LOOPER */
+
+  if (local_cpu_rate > 0) {
+    /* The user think that he knows what the cpu rate is. We assume */
+    /* that all the processors of an MP system are essentially the */
+    /* same - for this reason we do not have a per processor maxrate. */
+    /* if the machine has processors which are different in */
+    /* performance, the CPU utilization will be skewed. raj 4/95 */
+    lib_local_maxrate = local_cpu_rate;
+  }
+  else {
+    /* if neither USE_LOOPER nor USE_PSTAT are defined, we return a */
+    /* 0.0 to indicate that times or getrusage should be used. raj */
+    /* 4/95 */
+    lib_local_maxrate = (float)0.0;
+#if defined(USE_PROC_STAT) || defined(USE_LOOPER) || defined(USE_PSTAT) || defined(USE_KSTAT) || defined(USE_PERFSTAT) || defined(USE_SYSCTL)
+    lib_local_maxrate = calibrate_idle_rate(4,10);
+#endif
+  }
+  return lib_local_maxrate;
+}
+
+
+float
+calibrate_remote_cpu()
+{
+  float remrate;
+
+  netperf_request.content.request_type = CPU_CALIBRATE;
+  send_request();
+  /* we know that calibration will last at least 40 seconds, so go to */
+  /* sleep for that long so the 60 second select in recv_response will */
+  /* not pop. raj 7/95 */
+
+  /* we know that CPU calibration may last as long as 40 seconds, so
+     make sure we "select" for at least that long while looking for
+     the response. raj 2005-05-16 */
+  recv_response_timed(40);
+
+  if (netperf_response.content.serv_errno) {
+    /* initially, silently ignore remote errors and pass */
+    /* back a zero to the caller this should allow us to */
+    /* mix rev 1.0 and rev 1.1 netperfs... */
+    return((float)0.0);
+  }
+  else {
+    /* the rate is the first word of the test_specific data */
+    bcopy((char *)netperf_response.content.test_specific_data,
+          (char *)&remrate,
+          sizeof(remrate));
+    bcopy((char *)netperf_response.content.test_specific_data + sizeof(remrate),
+	  (char *)&lib_num_rem_cpus,
+	  sizeof(lib_num_rem_cpus));
+/*    remrate = (float) netperf_response.content.test_specific_data[0]; */
+    return(remrate);
+  }     
+}
+
+#ifndef WIN32
+/* WIN32 requires that at least one of the file sets to select be non-null. */
+/* Since msec_sleep routine is only called by nettest_dlpi & nettest_unix,  */
+/* let's duck this issue. */
+
+int
+msec_sleep( int msecs )
+{
+  int           rval ;
+
+  struct timeval timeout;
+
+  timeout.tv_sec = msecs / 1000;
+  timeout.tv_usec = (msecs - (msecs/1000) *1000) * 1000;
+  if ((rval = select(0,
+             0,
+             0,
+             0,
+             &timeout))) {
+    if ( SOCKET_EINTR(rval) ) {
+      return(1);
+    }
+    perror("msec_sleep: select");
+    exit(1);
+  }
+  return(0);
+}
+#endif /* WIN32 */
+
+#ifdef WANT_HISTOGRAM
+/* hist.c
+
+   Given a time difference in microseconds, increment one of 61
+   different buckets: 
+
+   0 - 9 in increments of 1 usec
+   0 - 9 in increments of 10 usecs
+   0 - 9 in increments of 100 usecs
+   1 - 9 in increments of 1 msec
+   1 - 9 in increments of 10 msecs
+   1 - 9 in increments of 100 msecs
+   1 - 9 in increments of 1 sec
+   1 - 9 in increments of 10 sec
+   > 100 secs
+   
+   This will allow any time to be recorded to within an accuracy of
+   10%, and provides a compact  representation for capturing the
+   distribution of a large number of time differences (e.g.
+   request-response latencies).
+   
+   Colin Low  10/6/93
+   Rick Jones 2004-06-15 extend to unit and ten usecs
+*/
+
+/* #include "sys.h" */
+
+/*#define HIST_TEST*/
+
+HIST 
+HIST_new(void){
+   HIST h;
+   if((h = (HIST) malloc(sizeof(struct histogram_struct))) == NULL) {
+     perror("HIST_new - malloc failed");
+     exit(1);
+   }
+   HIST_clear(h);
+   return h;
+}
+
+void 
+HIST_clear(HIST h){
+   int i;
+   for(i = 0; i < 10; i++){
+      h->unit_usec[i] = 0;
+      h->ten_usec[i] = 0;
+      h->hundred_usec[i] = 0;
+      h->unit_msec[i] = 0;
+      h->ten_msec[i] = 0;
+      h->hundred_msec[i] = 0;
+      h->unit_sec[i] = 0;
+      h->ten_sec[i] = 0;
+   }
+   h->ridiculous = 0;
+   h->total = 0;
+}
+
+void 
+HIST_add(register HIST h, int time_delta){
+   register int val;
+   h->total++;
+   val = time_delta;
+   if(val <= 9) h->unit_usec[val]++;
+   else {
+     val = val/10;
+     if(val <= 9) h->ten_usec[val]++;
+     else {
+       val = val/10;
+       if(val <= 9) h->hundred_usec[val]++;
+       else {
+	 val = val/10;
+	 if(val <= 9) h->unit_msec[val]++;
+	 else {
+	   val = val/10;
+	   if(val <= 9) h->ten_msec[val]++;
+	   else {
+	     val = val/10;
+	     if(val <= 9) h->hundred_msec[val]++;
+	     else {
+               val = val/10;
+               if(val <= 9) h->unit_sec[val]++;
+               else {
+		 val = val/10;
+		 if(val <= 9) h->ten_sec[val]++;
+		 else h->ridiculous++;
+               }
+	     }
+	   }
+	 }
+       }
+     }
+   }
+}
+
+#define RB_printf printf
+
+void 
+output_row(FILE *fd, char *title, int *row){
+   register int i;
+   RB_printf("%s", title);
+   for(i = 0; i < 10; i++) RB_printf(": %4d", row[i]);
+   RB_printf("\n");
+}
+
+int
+sum_row(int *row) {
+  int sum = 0;
+  int i;
+  for (i = 0; i < 10; i++) sum += row[i];
+  return(sum);
+}
+
+void 
+HIST_report(HIST h){
+#ifndef OLD_HISTOGRAM
+   output_row(stdout, "UNIT_USEC     ", h->unit_usec);
+   output_row(stdout, "TEN_USEC      ", h->ten_usec);
+   output_row(stdout, "HUNDRED_USEC  ", h->hundred_usec);
+#else
+   h->hundred_usec[0] += sum_row(h->unit_usec);
+   h->hundred_usec[0] += sum_row(h->ten_usec);
+   output_row(stdout, "TENTH_MSEC    ", h->hundred_usec);
+#endif
+   output_row(stdout, "UNIT_MSEC     ", h->unit_msec);
+   output_row(stdout, "TEN_MSEC      ", h->ten_msec);
+   output_row(stdout, "HUNDRED_MSEC  ", h->hundred_msec);
+   output_row(stdout, "UNIT_SEC      ", h->unit_sec);
+   output_row(stdout, "TEN_SEC       ", h->ten_sec);
+   RB_printf(">100_SECS: %d\n", h->ridiculous);
+   RB_printf("HIST_TOTAL:      %d\n", h->total);
+}
+
+#endif
+
+/* with the advent of sit-and-spin intervals support, we might as well
+   make these things available all the time, not just for demo or
+   histogram modes. raj 2006-02-06 */
+#ifdef HAVE_GETHRTIME
+
+void
+HIST_timestamp(hrtime_t *timestamp)
+{
+  *timestamp = gethrtime();
+}
+
+int
+delta_micro(hrtime_t *begin, hrtime_t *end)
+{
+  long nsecs;
+  nsecs = (*end) - (*begin);
+  return(nsecs/1000);
+}
+
+#elif defined(HAVE_GET_HRT)
+#include "hrt.h"
+
+void
+HIST_timestamp(hrt_t *timestamp)
+{
+  *timestamp = get_hrt();
+}
+
+int
+delta_micro(hrt_t *begin, hrt_t *end)
+{
+
+  return((int)get_hrt_delta(*end,*begin));
+
+}
+#elif defined(WIN32)
+void HIST_timestamp(LARGE_INTEGER *timestamp)
+{
+	QueryPerformanceCounter(timestamp);
+}
+
+int delta_micro(LARGE_INTEGER *begin, LARGE_INTEGER *end)
+{
+	LARGE_INTEGER DeltaTimestamp;
+	static LARGE_INTEGER TickHz = {0,0};
+
+	if (TickHz.QuadPart == 0) 
+	{
+		QueryPerformanceFrequency(&TickHz);
+	}
+
+	/*+*+ Rick; this will overflow after ~2000 seconds, is that
+	  good enough? Spencer: Yes, that should be more than good
+	  enough for histogram support */
+
+	DeltaTimestamp.QuadPart = (end->QuadPart - begin->QuadPart) * 
+	  1000000/TickHz.QuadPart;
+	assert((DeltaTimestamp.HighPart == 0) && 
+	       ((int)DeltaTimestamp.LowPart >= 0));
+
+	return (int)DeltaTimestamp.LowPart;
+}
+
+#else
+
+void
+HIST_timestamp(struct timeval *timestamp)
+{
+  gettimeofday(timestamp,NULL);
+}
+
+ /* return the difference (in micro seconds) between two timeval */
+ /* timestamps */
+int
+delta_micro(struct timeval *begin,struct timeval *end)
+
+{
+
+  int usecs, secs;
+
+  if (end->tv_usec < begin->tv_usec) {
+    /* borrow a second from the tv_sec */
+    end->tv_usec += 1000000;
+    end->tv_sec--;
+  }
+  usecs = end->tv_usec - begin->tv_usec;
+  secs  = end->tv_sec - begin->tv_sec;
+
+  usecs += (secs * 1000000);
+
+  return(usecs);
+
+}
+#endif /* HAVE_GETHRTIME */
+
+
+#ifdef WANT_DLPI
+
+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;
+{
+}
+#endif /* WANT_DLPI*/
+
+ /* these routines for confidence intervals are courtesy of IBM. They */
+ /* have been modified slightly for more general usage beyond TCP/UDP */
+ /* tests. raj 11/94 I would suspect that this code carries an IBM */
+ /* copyright that is much the same as that for the original HP */
+ /* netperf code */
+int     confidence_iterations; /* for iterations */
+
+double  
+  result_confid=-10.0,
+  loc_cpu_confid=-10.0,
+  rem_cpu_confid=-10.0,
+
+  measured_sum_result=0.0, 
+  measured_square_sum_result=0.0,
+  measured_mean_result=0.0, 
+  measured_var_result=0.0, 
+
+  measured_sum_local_cpu=0.0,
+  measured_square_sum_local_cpu=0.0,
+  measured_mean_local_cpu=0.0,
+  measured_var_local_cpu=0.0, 
+
+  measured_sum_remote_cpu=0.0,
+  measured_square_sum_remote_cpu=0.0,
+  measured_mean_remote_cpu=0.0,
+  measured_var_remote_cpu=0.0, 
+  
+  measured_sum_local_service_demand=0.0,
+  measured_square_sum_local_service_demand=0.0,
+  measured_mean_local_service_demand=0.0,
+  measured_var_local_service_demand=0.0,
+
+  measured_sum_remote_service_demand=0.0,
+  measured_square_sum_remote_service_demand=0.0,
+  measured_mean_remote_service_demand=0.0,
+  measured_var_remote_service_demand=0.0,
+
+  measured_sum_local_time=0.0,
+  measured_square_sum_local_time=0.0,
+  measured_mean_local_time=0.0,
+  measured_var_local_time=0.0,
+
+  measured_mean_remote_time=0.0, 
+  
+  measured_fails,
+  measured_local_results,
+  confidence=-10.0;
+/*  interval=0.1; */
+
+/************************************************************************/
+/*                                                                      */
+/*      Constants for Confidence Intervals                              */
+/*                                                                      */
+/************************************************************************/
+void 
+init_stat()
+{
+        measured_sum_result=0.0;
+        measured_square_sum_result=0.0;
+        measured_mean_result=0.0;
+        measured_var_result=0.0;
+
+        measured_sum_local_cpu=0.0;
+        measured_square_sum_local_cpu=0.0;
+        measured_mean_local_cpu=0.0;
+        measured_var_local_cpu=0.0;
+
+        measured_sum_remote_cpu=0.0;
+        measured_square_sum_remote_cpu=0.0;
+        measured_mean_remote_cpu=0.0;
+        measured_var_remote_cpu=0.0;
+
+        measured_sum_local_service_demand=0.0;
+        measured_square_sum_local_service_demand=0.0;
+        measured_mean_local_service_demand=0.0;
+        measured_var_local_service_demand=0.0;
+
+        measured_sum_remote_service_demand=0.0;
+        measured_square_sum_remote_service_demand=0.0;
+        measured_mean_remote_service_demand=0.0;
+        measured_var_remote_service_demand=0.0;
+
+        measured_sum_local_time=0.0;
+        measured_square_sum_local_time=0.0;
+        measured_mean_local_time=0.0;
+        measured_var_local_time=0.0;
+
+        measured_mean_remote_time=0.0;
+
+        measured_fails = 0.0;
+        measured_local_results=0.0,
+        confidence=-10.0;
+}
+
+ /* this routine does a simple table lookup for some statistical */
+ /* function that I would remember if I stayed awake in my probstats */
+ /* class... raj 11/94 */
+double 
+confid(int level, int freedom)
+{
+double  t99[35],t95[35];
+
+   t95[1]=12.706;
+   t95[2]= 4.303;
+   t95[3]= 3.182;
+   t95[4]= 2.776;
+   t95[5]= 2.571;
+   t95[6]= 2.447;
+   t95[7]= 2.365;
+   t95[8]= 2.306;
+   t95[9]= 2.262;
+   t95[10]= 2.228;
+   t95[11]= 2.201;
+   t95[12]= 2.179;
+   t95[13]= 2.160;
+   t95[14]= 2.145;
+   t95[15]= 2.131;
+   t95[16]= 2.120;
+   t95[17]= 2.110;
+   t95[18]= 2.101;
+   t95[19]= 2.093;
+   t95[20]= 2.086;
+   t95[21]= 2.080;
+   t95[22]= 2.074;
+   t95[23]= 2.069;
+   t95[24]= 2.064;
+   t95[25]= 2.060;
+   t95[26]= 2.056;
+   t95[27]= 2.052;
+   t95[28]= 2.048;
+   t95[29]= 2.045;
+   t95[30]= 2.042;
+   
+   t99[1]=63.657;
+   t99[2]= 9.925;
+   t99[3]= 5.841;
+   t99[4]= 4.604;
+   t99[5]= 4.032;
+   t99[6]= 3.707;
+   t99[7]= 3.499;
+   t99[8]= 3.355;
+   t99[9]= 3.250;
+   t99[10]= 3.169;
+   t99[11]= 3.106;
+   t99[12]= 3.055;
+   t99[13]= 3.012;
+   t99[14]= 2.977;
+   t99[15]= 2.947;
+   t99[16]= 2.921;
+   t99[17]= 2.898;
+   t99[18]= 2.878;
+   t99[19]= 2.861;
+   t99[20]= 2.845;
+   t99[21]= 2.831;
+   t99[22]= 2.819;
+   t99[23]= 2.807;
+   t99[24]= 2.797;
+   t99[25]= 2.787;
+   t99[26]= 2.779;
+   t99[27]= 2.771;
+   t99[28]= 2.763;
+   t99[29]= 2.756;
+   t99[30]= 2.750;
+   
+   if(level==95){
+        return(t95[freedom]);
+   } else if(level==99){
+        return(t99[freedom]);
+   } else{
+        return(0);
+   }
+}
+
+void
+calculate_confidence(int confidence_iterations,
+                     float time,
+                     double result,
+                     float loc_cpu,
+                     float rem_cpu,
+                     float loc_sd,
+                     float rem_sd)
+{
+
+  if (debug) {
+    fprintf(where,
+            "calculate_confidence: itr  %d; time %f; res  %f\n",
+            confidence_iterations,
+            time,
+            result);
+    fprintf(where,
+            "                               lcpu %f; rcpu %f\n",
+            loc_cpu,
+            rem_cpu);
+    fprintf(where,
+            "                               lsdm %f; rsdm %f\n",
+            loc_sd,
+            rem_sd);
+    fflush(where);
+  }
+
+  /* the test time */
+  measured_sum_local_time               += 
+    (double) time;
+  measured_square_sum_local_time        += 
+    (double) time*time;
+  measured_mean_local_time              =  
+    (double) measured_sum_local_time/confidence_iterations;
+  measured_var_local_time               =  
+    (double) measured_square_sum_local_time/confidence_iterations
+      -measured_mean_local_time*measured_mean_local_time;
+  
+  /* the test result */
+  measured_sum_result           += 
+    (double) result;
+  measured_square_sum_result    += 
+    (double) result*result;
+  measured_mean_result          =  
+    (double) measured_sum_result/confidence_iterations;
+  measured_var_result           =  
+    (double) measured_square_sum_result/confidence_iterations
+      -measured_mean_result*measured_mean_result;
+
+  /* local cpu utilization */
+  measured_sum_local_cpu        += 
+    (double) loc_cpu;
+  measured_square_sum_local_cpu += 
+    (double) loc_cpu*loc_cpu;
+  measured_mean_local_cpu       = 
+    (double) measured_sum_local_cpu/confidence_iterations;
+  measured_var_local_cpu        = 
+    (double) measured_square_sum_local_cpu/confidence_iterations
+      -measured_mean_local_cpu*measured_mean_local_cpu;
+
+  /* remote cpu util */
+  measured_sum_remote_cpu       +=
+    (double) rem_cpu;
+  measured_square_sum_remote_cpu+=
+    (double) rem_cpu*rem_cpu;
+  measured_mean_remote_cpu      = 
+    (double) measured_sum_remote_cpu/confidence_iterations;
+  measured_var_remote_cpu       = 
+    (double) measured_square_sum_remote_cpu/confidence_iterations
+      -measured_mean_remote_cpu*measured_mean_remote_cpu;
+
+  /* local service demand */
+  measured_sum_local_service_demand     +=
+    (double) loc_sd;
+  measured_square_sum_local_service_demand+=
+    (double) loc_sd*loc_sd;
+  measured_mean_local_service_demand    = 
+    (double) measured_sum_local_service_demand/confidence_iterations;
+  measured_var_local_service_demand     = 
+    (double) measured_square_sum_local_service_demand/confidence_iterations
+      -measured_mean_local_service_demand*measured_mean_local_service_demand;
+
+  /* remote service demand */
+  measured_sum_remote_service_demand    +=
+    (double) rem_sd;
+  measured_square_sum_remote_service_demand+=
+    (double) rem_sd*rem_sd;
+  measured_mean_remote_service_demand   = 
+    (double) measured_sum_remote_service_demand/confidence_iterations;
+  measured_var_remote_service_demand    = 
+    (double) measured_square_sum_remote_service_demand/confidence_iterations
+      -measured_mean_remote_service_demand*measured_mean_remote_service_demand;
+
+  if(confidence_iterations>1){ 
+     result_confid= (double) interval - 
+       2.0 * confid(confidence_level,confidence_iterations-1)* 
+         sqrt(measured_var_result/(confidence_iterations-1.0)) / 
+           measured_mean_result;
+
+     loc_cpu_confid= (double) interval - 
+       2.0 * confid(confidence_level,confidence_iterations-1)* 
+         sqrt(measured_var_local_cpu/(confidence_iterations-1.0)) / 
+           measured_mean_local_cpu;
+
+     rem_cpu_confid= (double) interval - 
+       2.0 * confid(confidence_level,confidence_iterations-1)*
+         sqrt(measured_var_remote_cpu/(confidence_iterations-1.0)) / 
+           measured_mean_remote_cpu;
+
+     if(debug){
+       printf("Conf_itvl %2d: results:%4.1f%% loc_cpu:%4.1f%% rem_cpu:%4.1f%%\n",
+              confidence_iterations,
+              (interval-result_confid)*100.0,
+              (interval-loc_cpu_confid)*100.0,
+              (interval-rem_cpu_confid)*100.0);
+     }
+
+     /* if the user has requested that we only wait for the result to
+	be confident rather than the result and CPU util(s) then do
+	so. raj 2007-08-08 */
+     if (!result_confidence_only) {
+       confidence = min(min(result_confid,loc_cpu_confid),rem_cpu_confid);
+     }
+     else {
+       confidence = result_confid;
+     }
+  }
+}
+
+ /* here ends the IBM code */
+
+void
+retrieve_confident_values(float *elapsed_time,
+                          double *thruput,
+                          float *local_cpu_utilization,
+                          float *remote_cpu_utilization,
+                          float *local_service_demand,
+                          float *remote_service_demand)
+
+{
+  *elapsed_time            = (float)measured_mean_local_time;
+  *thruput                 = measured_mean_result;
+  *local_cpu_utilization   = (float)measured_mean_local_cpu;
+  *remote_cpu_utilization  = (float)measured_mean_remote_cpu;
+  *local_service_demand    = (float)measured_mean_local_service_demand;
+  *remote_service_demand   = (float)measured_mean_remote_service_demand;
+}
+
+ /* display_confidence() is called when we could not achieve the */
+ /* desirec confidence in the results. it will print the achieved */
+ /* confidence to "where" raj 11/94 */
+void
+display_confidence()
+
+{
+  fprintf(where,
+          "!!! WARNING\n");
+  fprintf(where,
+          "!!! Desired confidence was not achieved within ");
+  fprintf(where,
+          "the specified iterations.\n");
+  fprintf(where,
+          "!!! This implies that there was variability in ");
+  fprintf(where,
+          "the test environment that\n");
+  fprintf(where,
+          "!!! must be investigated before going further.\n");
+  fprintf(where,
+          "!!! Confidence intervals: Throughput      : %4.1f%%\n",
+          100.0 * (interval - result_confid));
+  fprintf(where,
+          "!!!                       Local CPU util  : %4.1f%%\n",
+          100.0 * (interval - loc_cpu_confid));
+  fprintf(where,
+          "!!!                       Remote CPU util : %4.1f%%\n\n",
+          100.0 * (interval - rem_cpu_confid));
+}
+
diff --git a/netlib.h b/netlib.h
new file mode 100644
index 0000000..5b6900e
--- /dev/null
+++ b/netlib.h
@@ -0,0 +1,621 @@
+/*
+        Copyright (C) 1993-2005 Hewlett-Packard Company
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined(HAVE_SYS_SOCKET_H)
+# include <sys/socket.h>
+#endif
+#if defined(HAVE_NETDB_H)
+# include <netdb.h>
+#endif
+#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO)
+# include "missing/getaddrinfo.h"
+#endif
+
+#define PAD_TIME 4
+/* library routine specifc defines                                      */
+#define         MAXSPECDATA     62      /* how many ints worth of data  */
+                                        /* can tests send...            */
+#define         MAXTIMES        4       /* how many times may we loop   */
+                                        /* to calibrate                 */
+#define         MAXCPUS         256     /* how many CPU's can we track */
+#define         MAXMESSAGESIZE  65536
+#define         MAXALIGNMENT    16384
+#define         MAXOFFSET        4096
+#define         DATABUFFERLEN   MAXMESSAGESIZE+MAXALIGNMENT+MAXOFFSET
+
+#define         DEBUG_ON                1
+#define         DEBUG_OFF               2
+#define         DEBUG_OK                3
+#define         NODE_IDENTIFY           4
+#define         CPU_CALIBRATE           5
+
+#define         DO_TCP_STREAM           10
+#define         TCP_STREAM_RESPONSE     11
+#define         TCP_STREAM_RESULTS      12
+
+#define         DO_TCP_RR               13
+#define         TCP_RR_RESPONSE         14
+#define         TCP_RR_RESULTS          15
+
+#define         DO_UDP_STREAM           16
+#define         UDP_STREAM_RESPONSE     17
+#define         UDP_STREAM_RESULTS      18
+
+#define         DO_UDP_RR               19
+#define         UDP_RR_RESPONSE         20
+#define         UDP_RR_RESULTS          21
+
+#define         DO_DLPI_CO_STREAM       22
+#define         DLPI_CO_STREAM_RESPONSE 23
+#define         DLPI_CO_STREAM_RESULTS  24
+
+#define         DO_DLPI_CO_RR           25
+#define         DLPI_CO_RR_RESPONSE     26
+#define         DLPI_CO_RR_RESULTS      27
+
+#define         DO_DLPI_CL_STREAM       28
+#define         DLPI_CL_STREAM_RESPONSE 29
+#define         DLPI_CL_STREAM_RESULTS  30
+
+#define         DO_DLPI_CL_RR           31
+#define         DLPI_CL_RR_RESPONSE     32
+#define         DLPI_CL_RR_RESULTS      33
+
+#define         DO_TCP_CRR              34
+#define         TCP_CRR_RESPONSE        35
+#define         TCP_CRR_RESULTS         36
+
+#define         DO_STREAM_STREAM        37
+#define         STREAM_STREAM_RESPONSE  38
+#define         STREAM_STREAM_RESULTS   39
+
+#define         DO_STREAM_RR            40
+#define         STREAM_RR_RESPONSE      41
+#define         STREAM_RR_RESULTS       42
+
+#define         DO_DG_STREAM            43
+#define         DG_STREAM_RESPONSE      44
+#define         DG_STREAM_RESULTS       45
+
+#define         DO_DG_RR                46
+#define         DG_RR_RESPONSE          47
+#define         DG_RR_RESULTS           48
+
+#define         DO_FORE_STREAM          49
+#define         FORE_STREAM_RESPONSE    50
+#define         FORE_STREAM_RESULTS     51
+
+#define         DO_FORE_RR              52
+#define         FORE_RR_RESPONSE        53
+#define         FORE_RR_RESULTS         54
+
+#define         DO_HIPPI_STREAM         55
+#define         HIPPI_STREAM_RESPONSE   56
+#define         HIPPI_STREAM_RESULTS    57
+
+#define         DO_HIPPI_RR             52
+#define         HIPPI_RR_RESPONSE       53
+#define         HIPPI_RR_RESULTS        54
+
+#define         DO_XTI_TCP_STREAM       55
+#define         XTI_TCP_STREAM_RESPONSE 56
+#define         XTI_TCP_STREAM_RESULTS  57
+
+#define         DO_XTI_TCP_RR           58
+#define         XTI_TCP_RR_RESPONSE     59
+#define         XTI_TCP_RR_RESULTS      60
+
+#define         DO_XTI_UDP_STREAM       61
+#define         XTI_UDP_STREAM_RESPONSE 62
+#define         XTI_UDP_STREAM_RESULTS  63
+
+#define         DO_XTI_UDP_RR           64
+#define         XTI_UDP_RR_RESPONSE     65
+#define         XTI_UDP_RR_RESULTS      66
+
+#define         DO_XTI_TCP_CRR          67
+#define         XTI_TCP_CRR_RESPONSE    68
+#define         XTI_TCP_CRR_RESULTS     69
+
+#define         DO_TCP_TRR              70
+#define         TCP_TRR_RESPONSE        71
+#define         TCP_TRR_RESULTS         72
+
+#define         DO_TCP_NBRR             73
+#define         TCP_NBRR_RESPONSE       74
+#define         TCP_NBRR_RESULTS        75
+
+#define         DO_TCPIPV6_STREAM           76
+#define         TCPIPV6_STREAM_RESPONSE     77
+#define         TCPIPV6_STREAM_RESULTS      78
+
+#define         DO_TCPIPV6_RR               79
+#define         TCPIPV6_RR_RESPONSE         80
+#define         TCPIPV6_RR_RESULTS          81
+
+#define         DO_UDPIPV6_STREAM           82
+#define         UDPIPV6_STREAM_RESPONSE     83
+#define         UDPIPV6_STREAM_RESULTS      84
+
+#define         DO_UDPIPV6_RR               85
+#define         UDPIPV6_RR_RESPONSE         86
+#define         UDPIPV6_RR_RESULTS          87
+
+#define         DO_TCPIPV6_CRR              88
+#define         TCPIPV6_CRR_RESPONSE        89
+#define         TCPIPV6_CRR_RESULTS         90
+
+#define         DO_TCPIPV6_TRR              91
+#define         TCPIPV6_TRR_RESPONSE        92
+#define         TCPIPV6_TRR_RESULTS         93
+
+#define         DO_TCP_MAERTS               94
+#define         TCP_MAERTS_RESPONSE         95
+#define         TCP_MAERTS_RESULTS          96
+
+#define         DO_LWPSTR_STREAM           100
+#define         LWPSTR_STREAM_RESPONSE     110
+#define         LWPSTR_STREAM_RESULTS      120
+
+#define         DO_LWPSTR_RR               130
+#define         LWPSTR_RR_RESPONSE         140
+#define         LWPSTR_RR_RESULTS          150
+
+#define         DO_LWPDG_STREAM            160
+#define         LWPDG_STREAM_RESPONSE      170
+#define         LWPDG_STREAM_RESULTS       180
+
+#define         DO_LWPDG_RR                190
+#define         LWPDG_RR_RESPONSE          200
+#define         LWPDG_RR_RESULTS           210
+
+#define         DO_TCP_CC                  300
+#define         TCP_CC_RESPONSE            301
+#define         TCP_CC_RESULTS             302
+
+/* The DNS_RR test has been removed from netperf but we leave these
+   here for historical purposes.  Those wanting to do DNS_RR tests
+   should use netperf4 instead. */
+#define         DO_DNS_RR                  400
+#define         DNS_RR_RESPONSE            401
+#define         DNS_RR_RESULTS             402
+
+#define         DO_SCTP_STREAM             500
+#define         SCTP_STREAM_RESPONSE       501
+#define         SCTP_STREAM_RESULT         502
+
+#define         DO_SCTP_STREAM_MANY        510
+#define         SCTP_STREAM_MANY_RESPONSE  511
+#define         SCTP_STREAM_MANY_RESULT    512
+
+#define         DO_SCTP_RR                 520
+#define         SCTP_RR_RESPONSE           521
+#define         SCTP_RR_RESULT             502
+
+#define         DO_SCTP_RR_MANY            530
+#define         SCTP_RR_MANY_RESPONSE      531
+#define         SCTP_RR_MANY_RESULT        532
+
+#define         DO_SDP_STREAM              540
+#define         SDP_STREAM_RESPONSE        541
+#define         SDP_STREAM_RESULTS         542
+
+#define         DO_SDP_RR                  543
+#define         SDP_RR_RESPONSE            544
+#define         SDP_RR_RESULTS             545
+
+#define         DO_SDP_MAERTS              546
+#define         SDP_MAERTS_RESPONSE        547
+#define         SDP_MAERTS_RESULTS         548
+
+#define         DO_SDP_CRR                 549
+#define         SDP_CRR_RESPONSE           550
+#define         SDP_CRR_RESULTS            551
+
+#define         DO_SDP_CC                  552
+#define         SDP_CC_RESPONSE            553
+#define         SDP_CC_RESULTS             554
+
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+
+enum sock_buffer{
+  SEND_BUFFER,
+  RECV_BUFFER
+};
+
+ /* some of the fields in these structures are going to be doubles and */
+ /* such. so, we probably want to ensure that they will start on */
+ /* "double" boundaries. this will break compatability to pre-2.1 */
+ /* releases, but then, backwards compatability has never been a */
+ /* stated goal of netperf. raj 11/95 */
+
+union netperf_request_struct {
+  struct {
+    int     request_type;
+    int     dummy;
+    int     test_specific_data[MAXSPECDATA];
+  } content;
+  double dummy;
+};
+
+union netperf_response_struct {
+  struct {
+    int response_type;
+    int serv_errno;
+    int test_specific_data[MAXSPECDATA];
+  } content;
+  double dummy;
+};
+
+struct ring_elt {
+  struct ring_elt *next;  /* next element in the ring */
+  char *buffer_base;      /* in case we have to free it at somepoint */
+  char *buffer_ptr;       /* the aligned and offset pointer */
+};
+
+/* +*+ SAF  Sorry about the hacks with errno; NT made me do it :(
+
+ WinNT does define an errno.
+ It is mostly a legacy from the XENIX days.
+
+ Depending upon the version of the C run time that is linked in, it is
+ either a simple variable (like UNIX code expects), but more likely it
+ is the address of a procedure to return the error number.  So any
+ code that sets errno is likely to be overwriting the address of this
+ procedure.  Worse, only a tiny fraction of NT's errors get set
+ through errno.
+
+ So I have changed the netperf code to use a define Set_errno when
+ that is it's intent.  On non-windows platforms this is just an
+ assignment to errno.  But on NT this calls SetLastError.
+
+ I also define errno (now only used on right side of assignments)
+ on NT to be GetLastError.
+
+ Similarly, perror is defined on NT, but it only accesses the same
+ XENIX errors that errno covers.  So on NT this is redefined to be
+ Perror and it expands all GetLastError texts. */
+
+
+#ifdef WIN32
+/* INVALID_SOCKET == INVALID_HANDLE_VALUE == (unsigned int)(~0) */
+/* SOCKET_ERROR == -1 */
+#define ENOTSOCK WSAENOTSOCK
+#define EINTR    WSAEINTR
+#define ENOBUFS  WSAENOBUFS
+#define EWOULDBLOCK    WSAEWOULDBLOCK
+#define EAFNOSUPPORT  WSAEAFNOSUPPORT
+/* I don't use a C++ style of comment because it upsets some C
+   compilers, possibly even when it is inside an ifdef WIN32... */
+/* from public\sdk\inc\crt\errno.h */
+#define ENOSPC          28
+
+#ifdef errno
+/* delete the one from stdlib.h  */
+/*#define errno       (*_errno()) */
+#undef errno
+#endif
+#define errno GetLastError()
+#define Set_errno(num) SetLastError((num))
+
+#define perror(text) PrintWin32Error(stderr, (text))
+#define Print_errno(stream, text) PrintWin32Error((stream), (text))
+
+extern void PrintWin32Error(FILE *stream, LPSTR text);
+
+#if !defined(NT_PERF) && !defined(USE_LOOPER)
+#define NT_PERF
+#endif
+#else
+/* Really shouldn't use manifest constants! */
+/*+*+SAF There are other examples of "== -1" and "<0" that probably */
+/*+*+SAF should be cleaned up as well. */
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+
+#define SOCKET int
+#define Set_errno(num) errno = (num)
+
+#define Print_errno(stream, text) fprintf((stream), "%s  errno %d\n", (text), errno)
+#endif
+
+/* Robin & Rick's kludge to try to have a timer signal EINTR by closing  */
+/* the socket from another thread can also return several other errors. */
+/* Let's define a macro to hide all of this. */
+
+#ifndef WIN32
+#define SOCKET_EINTR(return_value) (errno == EINTR)
+#define SOCKET_EADDRINUSE(return_value) (errno == EADDRINUSE)
+#define SOCKET_EADDRNOTAVAIL(return_value) (errno == EADDRNOTAVAIL)
+
+#else
+
+/* not quite sure I like the extra cases for WIN32 but that is what my
+   WIN32 expert sugested.  I'm not sure what WSA's to put for
+   EADDRINUSE */
+
+#define SOCKET_EINTR(return_value) \
+		(((return_value) == SOCKET_ERROR) && \
+	     ((errno == EINTR) || \
+	      (errno == WSAECONNABORTED) || \
+	      (errno == WSAECONNRESET) ))
+#define SOCKET_EADDRINUSE(return_value) \
+		(((return_value) == SOCKET_ERROR) && \
+	     ((errno == WSAEADDRINUSE) ))
+#define SOCKET_EADDRNOTAVAIL(return_value) \
+		(((return_value) == SOCKET_ERROR) && \
+	     ((errno == WSAEADDRNOTAVAIL) ))
+#endif
+
+#ifdef HAVE_SENDFILE
+
+struct sendfile_ring_elt {
+  struct sendfile_ring_elt *next; /* next element in the ring */
+  int fildes;                     /* the file descriptor of the source
+				     file */ 
+  off_t offset;                   /* the offset from the beginning of
+				     the file for this send */
+  size_t length;                  /* the number of bytes to send -
+				     this is redundant with the
+				     send_size variable but I decided
+				     to include it anyway */
+  struct iovec *hdtrl;            /* a pointer to a header/trailer
+				     that we do not initially use and
+				     so should be set to NULL when the 
+				     ring is setup. */
+  int flags;                      /* the flags to pass to sendfile() - 
+				     presently unused and should be
+				     set to zero when the ring is
+				     setup. */
+};
+
+#endif /* HAVE_SENDFILE */
+
+ /* the diferent codes to denote the type of CPU utilization */
+ /* methods used */
+#define CPU_UNKNOWN     0
+#define HP_IDLE_COUNTER 1
+#define PSTAT           2
+#define TIMES           3
+#define LOOPER          4
+#define GETRUSAGE       5
+#define NT_METHOD       6
+#define KSTAT           7
+#define PROC_STAT       8
+#define SYSCTL          9
+#define PERFSTAT       10
+#define KSTAT_10       11
+#define OSX            12
+
+#define BADCH ('?')
+
+#ifndef NETLIB
+#ifdef WIN32
+#ifndef _GETOPT_
+#define _GETOPT_
+
+int getopt(int argc, char **argv, char *optstring);
+
+extern char *optarg;		/* returned arg to go with this option */
+extern int optind;		/* index to next argv element to process */
+extern int opterr;		/* should error messages be printed? */
+extern int optopt;		/* */
+
+#endif /* _GETOPT_ */
+
+extern  SOCKET     win_kludge_socket, win_kludge_socket2;
+#endif /* WIN32 */
+
+extern  int   local_proc_affinity, remote_proc_affinity;
+
+/* these are to allow netperf to be run easily through those evil,
+   end-to-end breaking things known as firewalls */
+extern char local_data_port[10];
+extern char remote_data_port[10];
+
+extern char *local_data_address;
+extern char *remote_data_address;
+
+extern int local_data_family;
+extern int remote_data_family;
+
+extern  union netperf_request_struct netperf_request;
+extern  union netperf_response_struct netperf_response;
+
+extern  float    lib_local_cpu_util;
+extern  float    lib_elapsed;
+extern  float    lib_local_maxrate;
+
+extern  char    libfmt;
+
+extern  int     cpu_method;
+extern  int     lib_num_loc_cpus;
+extern  int     lib_num_rem_cpus;
+extern  SOCKET  server_sock;
+extern  int     times_up;
+extern  FILE    *where;
+extern  int     loops_per_msec;
+extern  float   lib_local_per_cpu_util[];
+  
+extern  void    netlib_init();
+extern  int     netlib_get_page_size();
+extern  void    install_signal_catchers();
+extern  void    establish_control(char hostname[], 
+				  char port[], 
+				  int af,
+				  char local_hostname[],
+				  char local_port[],
+				  int local_af);
+extern  void    shutdown_control();
+extern  void    init_stat();
+extern  void    send_request();
+extern  void    recv_response();
+extern  void    send_response();
+extern  void    recv_request();
+extern  void    dump_request();
+extern  void    dump_addrinfo(FILE *dumploc, struct addrinfo *info,
+			      char *host, char *port, int family);
+extern  void    start_timer(int time);
+extern  void    stop_timer();
+extern  void    cpu_start(int measure_cpu);
+extern  void    cpu_stop(int measure_cpu, float *elapsed);
+extern  void	calculate_confidence(int confidence_iterations,
+		     float time,
+		     double result,
+		     float loc_cpu,
+		     float rem_cpu,
+		     float loc_sd,
+		     float rem_sd);
+extern  void	retrieve_confident_values(float *elapsed_time,
+			  double *thruput,
+			  float *local_cpu_utilization,
+			  float *remote_cpu_utilization,
+			  float *local_service_demand,
+			  float *remote_service_demand);
+extern  void    display_confidence();
+extern  void    set_sock_buffer(SOCKET sd,
+				enum sock_buffer which,
+				int requested_size,
+				int *effective_sizep);
+extern  char   *format_units();
+
+extern  char    *inet_ftos(int family);
+extern  char    *inet_ttos(int type);
+extern  char    *inet_ptos(int protocol);
+extern  double  ntohd(double net_double);
+extern  double  htond(double host_double);
+extern  int     inet_nton(int af, const void *src, char *dst, int cnt);
+extern  void    libmain();
+extern  double  calc_thruput(double units_received);
+extern  double  calc_thruput_interval(double units_received,double elapsed);
+extern  double  calc_thruput_omni(double units_received);
+extern  double  calc_thruput_interval_omni(double units_received,double elapsed);
+extern  float   calibrate_local_cpu(float local_cpu_rate);
+extern  float   calibrate_remote_cpu();
+extern  void    bind_to_specific_processor(int processor_affinity,int use_cpu_map);
+extern int      set_nonblock (SOCKET sock);
+
+#ifndef WIN32
+
+/* WIN32 requires that at least one of the file sets to select be
+ non-null.  Since msec_sleep routine is only called by nettest_dlpi &
+ nettest_unix, let's duck this issue. */
+
+extern int msec_sleep( int msecs );
+#endif  /* WIN32 */
+extern  float   calc_cpu_util(float elapsed_time);
+extern  float	calc_service_demand(double units_sent,
+				    float elapsed_time,
+				    float cpu_utilization,
+				    int num_cpus);
+extern  float	calc_service_demand_trans(double units_sent,
+					  float elapsed_time,
+					  float cpu_utilization,
+					  int num_cpus);
+#if defined(__hpux)
+extern  void    catcher(int, siginfo_t *,void *);
+#else
+extern  void    catcher(int);
+#endif /* __hpux */
+extern  struct ring_elt *allocate_buffer_ring();
+extern void access_buffer(char *buffer_ptr,
+			  int length,
+			  int dirty_count,
+			  int clean_count);
+
+#ifdef HAVE_ICSC_EXS
+extern  struct ring_elt *allocate_exs_buffer_ring();
+#endif /* HAVE_ICSC_EXS */
+#ifdef HAVE_SENDFILE
+extern  struct sendfile_ring_elt *alloc_sendfile_buf_ring();
+#endif /* HAVE_SENDFILE */
+#ifdef WANT_DLPI
+/* it seems that AIX in its finite wisdom has some bogus define in an
+   include file which defines "rem_addr" which then screws-up this extern
+   unless we change the names to protect the guilty. reported by Eric
+   Jones */
+extern int dl_connect(int fd, unsigned char *remote_addr, int remote_addr_len);
+extern int dl_bind(int fd, int sap, int mode, char *dlsap_ptr, int *dlsap_len);
+extern  int     dl_open(char devfile[], int ppa);
+#endif /* WANT_DLPI */
+extern  char    format_cpu_method(int method);
+extern unsigned int convert(char *string);
+extern unsigned int convert_timespec(char *string);
+
+#ifdef WANT_INTERVALS
+extern void start_itimer(unsigned int interval_len_msec);
+#endif
+ /* these are all for the confidence interval stuff */
+extern double confidence;
+
+#endif
+
+#ifdef WIN32
+#define close(x)	closesocket(x)
+#define strcasecmp(a,b) _stricmp(a,b)
+#define getpid() ((int)GetCurrentProcessId())
+#endif
+
+#ifdef WIN32
+#if 0
+/* Should really use safe string functions; but not for now... */
+#include <strsafe.h>
+/* Microsoft has deprecated _snprintf; it isn't guarenteed to null terminate the result buffer. */
+/* They want us to call StringCbPrintf instead; it always null terminates the string. */
+#endif
+
+#define snprintf _snprintf
+#endif
+
+/* Define a macro to align a buffer with an offset from a power of 2
+   boundary. */
+
+#ifndef WIN32
+#define ULONG_PTR unsigned long
+#endif
+
+#define ALIGN_BUFFER(BufPtr, Align, Offset) \
+  (char *)(( (ULONG_PTR)(BufPtr) + \
+			(ULONG_PTR) (Align) -1) & \
+			~((ULONG_PTR) (Align) - 1)) + (ULONG_PTR)(Offset)
+
+ /* if your system has bcopy and bzero, include it here, otherwise, we */
+ /* will try to use memcpy aand memset. fix from Bruce Barnett @ GE. */
+#if defined(hpux) || defined (__VMS)
+#define HAVE_BCOPY
+#define HAVE_BZERO
+#endif
+
+#ifdef WIN32
+#define HAVE_MIN
+#else
+#define _stdcall
+#define _cdecl
+#endif
+
+#ifndef HAVE_BCOPY
+#define bcopy(s,d,h) memcpy((d),(s),(h))
+#endif /* HAVE_BCOPY */
+
+#ifndef HAVE_BZERO
+#define bzero(p,h) memset((p),0,(h))
+#endif /* HAVE_BZERO */
+
+#ifndef HAVE_MIN
+#define min(a,b) ((a < b) ? a : b)
+#endif /* HAVE_MIN */
+
+#ifdef USE_PERFSTAT
+# include <libperfstat.h>
+#endif
diff --git a/netperf.c b/netperf.c
new file mode 100644
index 0000000..84717ac
--- /dev/null
+++ b/netperf.c
@@ -0,0 +1,284 @@
+/*
+ 
+	   Copyright (C) 1993-2007 Hewlett-Packard Company
+                         ALL RIGHTS RESERVED.
+ 
+  The enclosed software and documentation includes copyrighted works
+  of Hewlett-Packard Co. For as long as you comply with the following
+  limitations, you are hereby authorized to (i) use, reproduce, and
+  modify the software and documentation, and to (ii) distribute the
+  software and documentation, including modifications, for
+  non-commercial purposes only.
+      
+  1.  The enclosed software and documentation is made available at no
+      charge in order to advance the general development of
+      high-performance networking products.
+ 
+  2.  You may not delete any copyright notices contained in the
+      software or documentation. All hard copies, and copies in
+      source code or object code form, of the software or
+      documentation (including modifications) must contain at least
+      one of the copyright notices.
+ 
+  3.  The enclosed software and documentation has not been subjected
+      to testing and quality control and is not a Hewlett-Packard Co.
+      product. At a future time, Hewlett-Packard Co. may or may not
+      offer a version of the software and documentation as a product.
+  
+  4.  THE SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS".
+      HEWLETT-PACKARD COMPANY DOES NOT WARRANT THAT THE USE,
+      REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
+      DOCUMENTATION WILL NOT INFRINGE A THIRD PARTY'S INTELLECTUAL
+      PROPERTY RIGHTS. HP DOES NOT WARRANT THAT THE SOFTWARE OR
+      DOCUMENTATION IS ERROR FREE. HP DISCLAIMS ALL WARRANTIES,
+      EXPRESS AND IMPLIED, WITH REGARD TO THE SOFTWARE AND THE
+      DOCUMENTATION. HP SPECIFICALLY DISCLAIMS ALL WARRANTIES OF
+      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+  
+  5.  HEWLETT-PACKARD COMPANY WILL NOT IN ANY EVENT BE LIABLE FOR ANY
+      DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+      (INCLUDING LOST PROFITS) RELATED TO ANY USE, REPRODUCTION,
+      MODIFICATION, OR DISTRIBUTION OF THE SOFTWARE OR DOCUMENTATION.
+ 
+*/
+char	netperf_id[]="\
+@(#)netperf.c (c) Copyright 1993-2007 Hewlett-Packard Company. Version 2.4.3";
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+/* FreeBSD doesn't like socket.h before types are set. */
+#if __FreeBSD__
+# include <sys/types.h>
+#endif
+
+#ifndef WIN32
+/* this should only be temporary */
+#include <sys/socket.h>
+#endif
+
+#ifdef WIN32
+#include <winsock2.h>
+#include <windows.h>
+#endif /* WIN32 */
+
+#include "netsh.h"
+#include "netlib.h"
+#include "nettest_bsd.h"
+
+#ifdef WANT_UNIX
+#include "nettest_unix.h"
+#endif /* WANT_UNIX */
+
+#ifdef WANT_XTI
+#include "nettest_xti.h"
+#endif /* WANT_XTI */
+
+#ifdef WANT_DLPI
+#include "nettest_dlpi.h"
+#endif /* WANT_DLPI */
+
+#ifdef WANT_SDP
+#include "nettest_sdp.h"
+#endif
+
+/* The DNS tests have been removed from netperf2. Those wanting to do
+   DNS_RR tests should use netperf4 instead. */
+
+#ifdef DO_DNS
+#error DNS tests have been removed from netperf. Use netperf4 instead
+#endif /* DO_DNS */
+
+#ifdef WANT_SCTP
+#include "nettest_sctp.h"
+#endif
+
+ /* this file contains the main for the netperf program. all the other */
+ /* routines can be found in the file netsh.c */
+
+
+int _cdecl
+main(int argc, char *argv[])
+{
+
+#ifdef WIN32
+  WSADATA	wsa_data ;
+  
+  /* Initialize the winsock lib ( version 2.2 ) */
+  if ( WSAStartup(MAKEWORD(2,2), &wsa_data) == SOCKET_ERROR ){
+    printf("WSAStartup() failed : %d\n", GetLastError()) ;
+    return 1 ;
+  }
+#endif /* WIN32 */
+  
+  netlib_init();
+  set_defaults();
+  scan_cmd_line(argc,argv);
+  
+  if (debug) {
+    dump_globals();
+    install_signal_catchers();
+  }
+  
+  if (debug) {
+    printf("remotehost is %s and port %s\n",host_name,test_port);
+    fflush(stdout);
+  }
+  
+  
+  if (!no_control) {
+    establish_control(host_name,test_port,address_family,
+		      local_host_name,local_test_port,local_address_family);
+  }
+  
+  if (strcasecmp(test_name,"TCP_STREAM") == 0) {
+    send_tcp_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"TCP_MAERTS") == 0) {
+    send_tcp_maerts(host_name);
+  }
+#ifdef HAVE_ICSC_EXS
+  else if (strcasecmp(test_name,"EXS_TCP_STREAM") == 0) {
+    send_exs_tcp_stream(host_name);
+  }
+#endif /* HAVE_ICSC_EXS */
+#ifdef HAVE_SENDFILE
+  else if (strcasecmp(test_name,"TCP_SENDFILE") == 0) {
+    sendfile_tcp_stream(host_name);
+  }
+#endif /* HAVE_SENDFILE */
+  else if (strcasecmp(test_name,"TCP_RR") == 0) {
+    send_tcp_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"TCP_CRR") == 0) {
+    send_tcp_conn_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"TCP_CC") == 0) {
+    send_tcp_cc(host_name);
+  }
+#ifdef DO_1644
+  else if (strcasecmp(test_name,"TCP_TRR") == 0) {
+    send_tcp_tran_rr(host_name);
+  }
+#endif /* DO_1644 */
+#ifdef DO_NBRR
+  else if (strcasecmp(test_name,"TCP_NBRR") == 0) {
+    send_tcp_nbrr(host_name);
+  }
+#endif /* DO_NBRR */
+  else if (strcasecmp(test_name,"UDP_STREAM") == 0) {
+    send_udp_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"UDP_RR") == 0) {
+    send_udp_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"LOC_CPU") == 0) {
+    loc_cpu_rate();
+  }
+  else if (strcasecmp(test_name,"REM_CPU") == 0) {
+    rem_cpu_rate();
+  }
+#ifdef WANT_DLPI
+  else if (strcasecmp(test_name,"DLCO_RR") == 0) {
+    send_dlpi_co_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"DLCL_RR") == 0) {
+    send_dlpi_cl_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"DLCO_STREAM") == 0) {
+    send_dlpi_co_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"DLCL_STREAM") == 0) {
+    send_dlpi_cl_stream(host_name);
+  }
+#endif /* WANT_DLPI */
+#ifdef WANT_UNIX
+  else if (strcasecmp(test_name,"STREAM_RR") == 0) {
+    send_stream_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"DG_RR") == 0) {
+    send_dg_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"STREAM_STREAM") == 0) {
+    send_stream_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"DG_STREAM") == 0) {
+    send_dg_stream(host_name);
+  }
+#endif /* WANT_UNIX */
+#ifdef WANT_XTI
+  else if (strcasecmp(test_name,"XTI_TCP_STREAM") == 0) {
+    send_xti_tcp_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"XTI_TCP_RR") == 0) {
+    send_xti_tcp_rr(host_name);
+  }
+  else if (strcasecmp(test_name,"XTI_UDP_STREAM") == 0) {
+    send_xti_udp_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"XTI_UDP_RR") == 0) {
+    send_xti_udp_rr(host_name);
+  }
+#endif /* WANT_XTI */
+  
+#ifdef WANT_SCTP
+  else if (strcasecmp(test_name, "SCTP_STREAM") == 0) {
+    send_sctp_stream(host_name);
+  }       
+  else if (strcasecmp(test_name, "SCTP_RR") == 0) {
+    send_sctp_rr(host_name);
+  }
+  else if (strcasecmp(test_name, "SCTP_STREAM_MANY") == 0) {
+    send_sctp_stream_1toMany(host_name);
+  }
+  else if (strcasecmp(test_name, "SCTP_RR_MANY") == 0) {
+    send_sctp_stream_1toMany(host_name);
+  }
+#endif
+  
+#ifdef DO_DNS
+  else if (strcasecmp(test_name,"DNS_RR") == 0) {
+    fprintf(stderr,
+	  "DNS tests can now be found in netperf4.\n");
+    fflush(stderr);
+    exit(-1);
+  }
+#endif /* DO_DNS */
+#ifdef WANT_SDP
+  else if (strcasecmp(test_name,"SDP_STREAM") == 0) {
+    send_sdp_stream(host_name);
+  }
+  else if (strcasecmp(test_name,"SDP_MAERTS") == 0) {
+    send_sdp_maerts(host_name);
+  }
+  else if (strcasecmp(test_name,"SDP_RR") == 0) {
+    send_sdp_rr(host_name);
+  }
+#endif /* WANT_SDP */
+  else {
+    printf("The test you requested is unknown to this netperf.\n");
+    printf("Please verify that you have the correct test name, \n");
+    printf("and that test family has been compiled into this netperf.\n");
+    exit(1);
+  }
+  
+  if (!no_control) {
+    shutdown_control();
+  }
+  
+#ifdef WIN32
+  /* Cleanup the winsock lib */
+  WSACleanup();
+#endif
+  
+  return(0);
+}
+
+
diff --git a/netperf_version.h b/netperf_version.h
new file mode 100644
index 0000000..b2b9fdc
--- /dev/null
+++ b/netperf_version.h
@@ -0,0 +1 @@
+#define NETPERF_VERSION "2.4.4"
diff --git a/netserver.c b/netserver.c
new file mode 100644
index 0000000..02be3ce
--- /dev/null
+++ b/netserver.c
@@ -0,0 +1,1022 @@
+/*
+ 
+	   Copyright (C) 1993-2007 Hewlett-Packard Company
+                         ALL RIGHTS RESERVED.
+ 
+  The enclosed software and documentation includes copyrighted works
+  of Hewlett-Packard Co. For as long as you comply with the following
+  limitations, you are hereby authorized to (i) use, reproduce, and
+  modify the software and documentation, and to (ii) distribute the
+  software and documentation, including modifications, for
+  non-commercial purposes only.
+      
+  1.  The enclosed software and documentation is made available at no
+      charge in order to advance the general development of
+      high-performance networking products.
+ 
+  2.  You may not delete any copyright notices contained in the
+      software or documentation. All hard copies, and copies in
+      source code or object code form, of the software or
+      documentation (including modifications) must contain at least
+      one of the copyright notices.
+ 
+  3.  The enclosed software and documentation has not been subjected
+      to testing and quality control and is not a Hewlett-Packard Co.
+      product. At a future time, Hewlett-Packard Co. may or may not
+      offer a version of the software and documentation as a product.
+  
+  4.  THE SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS".
+      HEWLETT-PACKARD COMPANY DOES NOT WARRANT THAT THE USE,
+      REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
+      DOCUMENTATION WILL NOT INFRINGE A THIRD PARTY'S INTELLECTUAL
+      PROPERTY RIGHTS. HP DOES NOT WARRANT THAT THE SOFTWARE OR
+      DOCUMENTATION IS ERROR FREE. HP DISCLAIMS ALL WARRANTIES,
+      EXPRESS AND IMPLIED, WITH REGARD TO THE SOFTWARE AND THE
+      DOCUMENTATION. HP SPECIFICALLY DISCLAIMS ALL WARRANTIES OF
+      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+  
+  5.  HEWLETT-PACKARD COMPANY WILL NOT IN ANY EVENT BE LIABLE FOR ANY
+      DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+      (INCLUDING LOST PROFITS) RELATED TO ANY USE, REPRODUCTION,
+      MODIFICATION, OR DISTRIBUTION OF THE SOFTWARE OR DOCUMENTATION.
+ 
+*/
+
+#include "netperf_version.h"
+
+char	netserver_id[]="\
+@(#)netserver.c (c) Copyright 1993-2007 Hewlett-Packard Co. Version 2.4.3";
+
+ /***********************************************************************/
+ /*									*/
+ /*	netserver.c							*/
+ /*									*/
+ /*	This is the server side code for the netperf test package. It	*/
+ /* will operate either stand-alone, or as a child of inetd. In this	*/
+ /* way, we insure that it can be installed on systems with or without	*/
+ /* root permissions (editing inetd.conf). Essentially, this code is	*/
+ /* the analog to the netsh.c code.					*/
+ /*									*/
+ /***********************************************************************/
+
+
+/************************************************************************/
+/*									*/
+/*	Global include files						*/
+/*									*/
+/************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if HAVE_STRING_H
+# if !STDC_HEADERS && HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif
+#include <sys/types.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <errno.h>
+#include <signal.h>
+#endif
+#if !defined(WIN32) && !defined(__VMS)
+#include <sys/ipc.h>
+#endif /* !defined(WIN32) && !defined(__VMS) */
+#include <fcntl.h>
+#ifdef WIN32
+#include <time.h>
+#include <winsock2.h>
+#define netperf_socklen_t socklen_t
+/* we need to find some other way to decide to include ws2 */
+/* if you are trying to compile on Windows 2000 or NT 4 you will */
+/* probably have to define DONT_IPV6 */
+#ifndef DONT_IPV6
+#include <ws2tcpip.h>
+#endif  /* DONT_IPV6 */
+#include <windows.h>
+#define sleep(x) Sleep((x)*1000)
+#else
+#ifndef MPE
+#include <sys/time.h>
+#endif /* MPE */
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <unistd.h>
+#ifndef DONT_WAIT
+#include <sys/wait.h>
+#endif /* DONT_WAIT */
+#endif /* WIN32 */
+#include <stdlib.h>
+#ifdef __VMS
+#include <tcpip$inetdef.h> 
+#include <unixio.h> 
+#endif /* __VMS */
+#include "netlib.h"
+#include "nettest_bsd.h"
+
+#ifdef WANT_UNIX
+#include "nettest_unix.h"
+#endif /* WANT_UNIX */
+
+#ifdef WANT_DLPI
+#include "nettest_dlpi.h"
+#endif /* WANT_DLPI */
+
+#ifdef WANT_SCTP
+#include "nettest_sctp.h"
+#endif
+
+#include "netsh.h"
+
+#ifndef DEBUG_LOG_FILE
+#ifndef WIN32
+#define DEBUG_LOG_FILE "/tmp/netperf.debug"
+#else
+#define DEBUG_LOG_FILE "c:\\temp\\netperf.debug"
+#endif  /* WIN32 */
+#endif /* DEBUG_LOG_FILE */
+
+ /* some global variables */
+
+FILE	*afp;
+char    listen_port[10];
+extern	char	*optarg;
+extern	int	optind, opterr;
+
+#ifndef WIN32
+#define SERVER_ARGS "dL:n:p:v:V46"
+#else
+#define SERVER_ARGS "dL:n:p:v:V46I:i:"
+#endif
+
+/* perhaps one day we will use this as part of only opening a debug
+   log file if debug is set, of course we have to be wary of the base
+   use of "where" and so probably always need "where" pointing
+   "somewhere" or other. */
+void
+open_debug_file() 
+{
+#ifndef WIN32
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+  char FileName[PATH_MAX];   /* for opening the debug log file */
+  strcpy(FileName, DEBUG_LOG_FILE);
+
+  if (where != NULL) fflush(where);
+
+  snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%d", getpid());
+  if ((where = fopen(FileName, "w")) == NULL) {
+    perror("netserver: debug file");
+    exit(1);
+  }
+
+  chmod(FileName,0644);
+#endif
+
+}
+ /* This routine implements the "main event loop" of the netperf	*/
+ /* server code. Code above it will have set-up the control connection	*/
+ /* so it can just merrily go about its business, which is to		*/
+ /* "schedule" performance tests on the server.				*/
+
+void 
+process_requests()
+{
+  
+  float	temp_rate;
+  
+  if (debug)    open_debug_file();
+
+
+  while (1) {
+    recv_request();
+
+    switch (netperf_request.content.request_type) {
+      
+    case DEBUG_ON:
+      netperf_response.content.response_type = DEBUG_OK;
+      /*  dump_request already present in recv_request; redundant? */
+      if (!debug) {
+	debug++;
+	open_debug_file();
+	dump_request();
+      }
+      send_response();
+      break;
+      
+    case DEBUG_OFF:
+      if (debug)
+	debug--;
+      netperf_response.content.response_type = DEBUG_OK;
+      send_response();
+      /* +SAF why??? */
+      if (!debug) 
+      {
+	fclose(where);
+#if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
+	/* For Unix: reopen the debug write file descriptor to "/dev/null" */
+	/* and redirect stdout to it.					   */
+	fflush (stdout);
+	where = fopen ("/dev/null", "w");
+	if (where == NULL)
+	{
+	  perror ("netserver: reopening debug fp for writing: /dev/null");
+	  exit   (1);
+	}
+	if (close (STDOUT_FILENO) == -1)
+	{
+	  perror ("netserver: closing stdout file descriptor");
+	  exit   (1);
+	}
+	if (dup (fileno (where))  == -1)
+	{
+	  perror ("netserver: duplicate /dev/null write file descr. to stdout");
+	  exit   (1);
+	}
+#endif /* !WIN32 !MPE !__VMS */
+      }
+      break;
+      
+    case CPU_CALIBRATE:
+      netperf_response.content.response_type = CPU_CALIBRATE;
+      temp_rate = calibrate_local_cpu(0.0);
+      bcopy((char *)&temp_rate,
+	    (char *)netperf_response.content.test_specific_data,
+	    sizeof(temp_rate));
+      bcopy((char *)&lib_num_loc_cpus,
+	    (char *)netperf_response.content.test_specific_data + sizeof(temp_rate),
+	    sizeof(lib_num_loc_cpus));
+      if (debug) {
+	fprintf(where,"netserver: sending CPU information:");
+	fprintf(where,"rate is %g num cpu %d\n",temp_rate,lib_num_loc_cpus);
+	fflush(where);
+      }
+      
+      /* we need the cpu_start, cpu_stop in the looper case to kill the */
+      /* child proceses raj 7/95 */
+      
+#ifdef USE_LOOPER
+      cpu_start(1);
+      cpu_stop(1,&temp_rate);
+#endif /* USE_LOOPER */
+      
+      send_response();
+      break;
+      
+    case DO_TCP_STREAM:
+      recv_tcp_stream();
+      break;
+      
+    case DO_TCP_MAERTS:
+      recv_tcp_maerts();
+      break;
+      
+    case DO_TCP_RR:
+      recv_tcp_rr();
+      break;
+      
+    case DO_TCP_CRR:
+      recv_tcp_conn_rr();
+      break;
+      
+    case DO_TCP_CC:
+      recv_tcp_cc();
+      break;
+      
+#ifdef DO_1644
+    case DO_TCP_TRR:
+      recv_tcp_tran_rr();
+      break;
+#endif /* DO_1644 */
+      
+#ifdef DO_NBRR
+    case DO_TCP_NBRR:
+      recv_tcp_nbrr();
+      break;
+#endif /* DO_NBRR */
+      
+    case DO_UDP_STREAM:
+      recv_udp_stream();
+      break;
+      
+    case DO_UDP_RR:
+      recv_udp_rr();
+      break;
+      
+#ifdef WANT_DLPI
+
+    case DO_DLPI_CO_RR:
+      recv_dlpi_co_rr();
+      break;
+      
+    case DO_DLPI_CL_RR:
+      recv_dlpi_cl_rr();
+      break;
+
+    case DO_DLPI_CO_STREAM:
+      recv_dlpi_co_stream();
+      break;
+
+    case DO_DLPI_CL_STREAM:
+      recv_dlpi_cl_stream();
+      break;
+
+#endif /* WANT_DLPI */
+
+#ifdef WANT_UNIX
+
+    case DO_STREAM_STREAM:
+      recv_stream_stream();
+      break;
+      
+    case DO_STREAM_RR:
+      recv_stream_rr();
+      break;
+      
+    case DO_DG_STREAM:
+      recv_dg_stream();
+      break;
+      
+    case DO_DG_RR:
+      recv_dg_rr();
+      break;
+      
+#endif /* WANT_UNIX */
+
+#ifdef WANT_XTI
+    case DO_XTI_TCP_STREAM:
+      recv_xti_tcp_stream();
+      break;
+      
+    case DO_XTI_TCP_RR:
+      recv_xti_tcp_rr();
+      break;
+      
+    case DO_XTI_UDP_STREAM:
+      recv_xti_udp_stream();
+      break;
+      
+    case DO_XTI_UDP_RR:
+      recv_xti_udp_rr();
+      break;
+
+#endif /* WANT_XTI */
+
+#ifdef WANT_SCTP
+    case DO_SCTP_STREAM:
+      recv_sctp_stream();
+      break;
+      
+    case DO_SCTP_STREAM_MANY:
+      recv_sctp_stream_1toMany();
+      break;
+
+    case DO_SCTP_RR:
+      recv_sctp_rr();
+      break;
+
+    case DO_SCTP_RR_MANY:
+      recv_sctp_rr_1toMany();
+      break;
+#endif
+
+#ifdef WANT_SDP
+    case DO_SDP_STREAM:
+      recv_sdp_stream();
+      break;
+
+    case DO_SDP_MAERTS:
+      recv_sdp_maerts();
+      break;
+
+    case DO_SDP_RR:
+      recv_sdp_rr();
+      break;
+#endif 
+
+    default:
+      fprintf(where,"unknown test number %d\n",
+	      netperf_request.content.request_type);
+      fflush(where);
+      netperf_response.content.serv_errno=998;
+      send_response();
+      break;
+      
+    }
+  }
+}
+
+/*	
+ set_up_server()
+
+ set-up the server listen socket. we only call this routine if the 
+ user has specified a port number on the command line or we believe we
+ are not a child of inetd or its platform-specific equivalent */
+
+/*KC*/
+
+void 
+set_up_server(char hostname[], char port[], int af)
+{ 
+
+  struct addrinfo     hints;
+  struct addrinfo     *local_res;
+  struct addrinfo     *local_res_temp;
+
+  struct sockaddr_storage     peeraddr;
+  netperf_socklen_t                 peeraddr_len = sizeof(peeraddr);
+  
+  SOCKET server_control;
+  int on=1;
+  int count;
+  int error;
+  int not_listening;
+
+#if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
+  FILE *rd_null_fp;    /* Used to redirect from "/dev/null". */
+  FILE *wr_null_fp;    /* Used to redirect to   "/dev/null". */
+#endif /* !WIN32 !MPE !__VMS */
+
+  if (debug) {
+    fprintf(stderr,
+            "set_up_server called with host '%s' port '%s' remfam %d\n",
+            hostname,
+	    port,
+            af);
+    fflush(stderr);
+  }
+
+  memset(&hints,0,sizeof(hints));
+  hints.ai_family = af;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_protocol = IPPROTO_TCP;
+  hints.ai_flags = AI_PASSIVE;
+
+  count = 0;
+  do {
+    error = getaddrinfo((char *)hostname,
+                        (char *)port,
+                        &hints,
+                        &local_res);
+    count += 1;
+    if (error == EAI_AGAIN) {
+      if (debug) {
+        fprintf(stderr,"Sleeping on getaddrinfo EAI_AGAIN\n");
+        fflush(stderr);
+      }
+      sleep(1);
+    }
+  } while ((error == EAI_AGAIN) && (count <= 5));
+
+  if (error) {
+    fprintf(stderr,
+	    "set_up_server: could not resolve remote '%s' port '%s' af %d",
+	    hostname,
+	    port,
+	    af);
+    fprintf(stderr,"\n\tgetaddrinfo returned %d %s\n",
+	    error,
+	    gai_strerror(error));
+    exit(-1);
+  }
+
+  if (debug) {
+    dump_addrinfo(stderr, local_res, hostname, port, af);
+  }
+
+  not_listening = 1;
+  local_res_temp = local_res;
+
+  while((local_res_temp != NULL) && (not_listening)) {
+
+    fprintf(stderr,
+	    "Starting netserver at port %s\n",
+	    port);
+
+    server_control = socket(local_res_temp->ai_family,SOCK_STREAM,0);
+
+    if (server_control == INVALID_SOCKET) {
+      perror("set_up_server could not allocate a socket");
+      exit(-1);
+    }
+
+    /* happiness and joy, keep going */
+    if (setsockopt(server_control, 
+		   SOL_SOCKET, 
+		   SO_REUSEADDR, 
+		   (char *)&on , 
+		   sizeof(on)) == SOCKET_ERROR) {
+      if (debug) {
+	perror("warning: set_up_server could not set SO_REUSEADDR");
+      }
+    }
+    /* still happy and joyful */
+
+    if ((bind (server_control, 
+	       local_res_temp->ai_addr, 
+	       local_res_temp->ai_addrlen) != SOCKET_ERROR) &&
+	(listen (server_control,5) != SOCKET_ERROR))  {
+      not_listening = 0;
+      break;
+    }
+    else {
+      /* we consider a bind() or listen() failure a transient and try
+	 the next address */
+      if (debug) {
+	perror("warning: set_up_server failed a bind or listen call\n");
+      }
+      local_res_temp = local_res_temp->ai_next;
+      continue;
+    }
+  }
+
+  if (not_listening) {
+    fprintf(stderr,
+	    "set_up_server could not establish a listen endpoint for %s port %s with family %s\n",
+	    host_name,
+	    port,
+	    inet_ftos(af));
+    fflush(stderr);
+    exit(-1);
+  }
+  else {
+    printf("Starting netserver at hostname %s port %s and family %s\n",
+	   hostname,
+	   port,
+	   inet_ftos(af));
+  }
+
+  /*
+    setpgrp();
+    */
+
+#if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
+  /* Flush the standard I/O file descriptors before forking. */
+  fflush (stdin);
+  fflush (stdout);
+  fflush (stderr);
+  switch (fork())
+    {
+    case -1:  	
+      perror("netperf server error");
+      exit(1);
+      
+    case 0:	
+      /* Redirect stdin from "/dev/null". */
+      rd_null_fp = fopen ("/dev/null", "r");
+      if (rd_null_fp == NULL)
+      {
+	perror ("netserver: opening for reading: /dev/null");
+	exit   (1);
+      }
+      if (close (STDIN_FILENO) == -1)
+      {
+	perror ("netserver: closing stdin file descriptor");
+	exit   (1);
+      }
+      if (dup (fileno (rd_null_fp)) == -1)
+      {
+	perror ("netserver: duplicate /dev/null read file descr. to stdin");
+	exit   (1);
+      }
+
+      /* Redirect stdout to the debug write file descriptor. */
+      if (close (STDOUT_FILENO) == -1)
+      {
+	perror ("netserver: closing stdout file descriptor");
+	exit   (1);
+      }
+      if (dup (fileno (where))  == -1)
+      {
+	perror ("netserver: duplicate the debug write file descr. to stdout");
+	exit   (1);
+      }
+
+      /* Redirect stderr to "/dev/null". */
+      wr_null_fp = fopen ("/dev/null", "w");
+      if (wr_null_fp == NULL)
+      {
+	perror ("netserver: opening for writing: /dev/null");
+	exit   (1);
+      }
+      if (close (STDERR_FILENO) == -1)
+      {
+	perror ("netserver: closing stderr file descriptor");
+	exit   (1);
+      }
+      if (dup (fileno (wr_null_fp))  == -1)
+      {
+	perror ("netserver: dupicate /dev/null write file descr. to stderr");
+	exit   (1);
+      }
+ 
+#ifndef NO_SETSID
+      setsid();
+#else
+      setpgrp();
+#endif /* NO_SETSID */
+
+ /* some OS's have SIGCLD defined as SIGCHLD */
+#ifndef SIGCLD
+#define SIGCLD SIGCHLD
+#endif /* SIGCLD */
+
+      signal(SIGCLD, SIG_IGN);
+      
+#endif /* !WIN32 !MPE !__VMS */
+
+      for (;;)
+	{
+	  if ((server_sock=accept(server_control,
+				  (struct sockaddr *)&peeraddr,
+				  &peeraddr_len)) == INVALID_SOCKET)
+	    {
+	      printf("server_control: accept failed errno %d\n",errno);
+	      exit(1);
+	    }
+#if defined(MPE) || defined(__VMS)
+	  /*
+	   * Since we cannot fork this process , we cant fire any threads
+	   * as they all share the same global data . So we better allow
+	   * one request at at time 
+	   */
+	  process_requests() ;
+#elif WIN32
+		{
+			BOOL b;
+			char cmdline[80];
+			PROCESS_INFORMATION pi;
+			STARTUPINFO si;
+			int i;
+
+			memset(&si, 0 , sizeof(STARTUPINFO));
+			si.cb = sizeof(STARTUPINFO);
+
+			/* Pass the server_sock as stdin for the new process. */
+			/* Hopefully this will continue to be created with the OBJ_INHERIT attribute. */
+			si.hStdInput = (HANDLE)server_sock;
+			si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+			si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+			si.dwFlags = STARTF_USESTDHANDLES;
+
+			/* Build cmdline for child process */
+			strcpy(cmdline, program);
+			if (verbosity > 1) {
+				snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -v %d", verbosity);
+			}
+			for (i=0; i < debug; i++) {
+				snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -d");
+			}
+			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -I %x", (int)(UINT_PTR)server_sock);
+			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -i %x", (int)(UINT_PTR)server_control);
+			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -i %x", (int)(UINT_PTR)where);
+
+			b = CreateProcess(NULL,	 /* Application Name */
+					cmdline,
+					NULL,    /* Process security attributes */
+					NULL,    /* Thread security attributes */
+					TRUE,    /* Inherit handles */
+					0,	   /* Creation flags  PROCESS_QUERY_INFORMATION,  */
+					NULL,    /* Enviornment */
+					NULL,    /* Current directory */
+					&si,	   /* StartupInfo */
+					&pi);
+			if (!b)
+			{
+				perror("CreateProcessfailure: ");
+				exit(1);
+			}
+
+			/* We don't need the thread or process handles any more; let them */
+			/* go away on their own timeframe. */
+
+			CloseHandle(pi.hThread);
+			CloseHandle(pi.hProcess);
+
+			/* And close the server_sock since the child will own it. */
+
+			close(server_sock);
+		}
+#else
+      signal(SIGCLD, SIG_IGN);
+	  
+	  switch (fork())
+	    {
+	    case -1:
+	      /* something went wrong */
+	      exit(1);
+	    case 0:
+	      /* we are the child process */
+	      close(server_control);
+	      process_requests();
+	      exit(0);
+	      break;
+	    default:
+	      /* we are the parent process */
+	      close(server_sock);
+	      /* we should try to "reap" some of our children. on some */
+	      /* systems they are being left as defunct processes. we */
+	      /* will call waitpid, looking for any child process, */
+	      /* with the WNOHANG feature. when waitpid return a zero, */
+	      /* we have reaped all the children there are to reap at */
+	      /* the moment, so it is time to move on. raj 12/94 */
+#ifndef DONT_WAIT
+#ifdef NO_SETSID
+	      /* Only call "waitpid()" if "setsid()" is not used. */
+	      while(waitpid(-1, NULL, WNOHANG) > 0) { }
+#endif /* NO_SETSID */
+#endif /* DONT_WAIT */
+	      break;
+	    }
+#endif /* !WIN32 !MPE !__VMS */  
+	} /*for*/
+#if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
+      break; /*case 0*/
+      
+    default: 
+      exit (0);
+      
+    }
+#endif /* !WIN32 !MPE !__VMS */  
+}
+
+#ifdef WIN32
+
+  /* With Win2003, WinNT's POSIX subsystem is gone and hence so is */
+  /* fork. */
+
+  /* But hopefully the kernel support will continue to exist for some */
+  /* time. */
+
+  /* We are not counting on the child address space copy_on_write */
+  /* support, since it isn't exposed except through the NT native APIs */
+  /* (which is not public). */
+
+  /* We will try to use the InheritHandles flag in CreateProcess.  It */
+  /* is in the public API, though it is documented as "must be FALSE". */
+
+  /* So where we would have forked, we will now create a new process. */
+  /* I have added a set of command line switches to specify a list of */
+  /* handles that the child should close since they shouldn't have */
+  /* been inherited ("-i#"), and a single switch to specify the handle */
+  /* for the server_sock ("I#"). */
+
+  /* A better alternative would be to re-write NetPerf to be */
+  /* multi-threaded; i.e., move all of the various NetPerf global */
+  /* variables in to thread specific structures.  But this is a bigger */
+  /* effort than I want to tackle at this time.  (And I doubt that the */
+  /* HP-UX author sees value in this effort). */
+
+#endif
+
+int _cdecl
+main(int argc, char *argv[])
+{
+
+  int	c;
+  int   not_inetd = 0;
+#ifdef WIN32
+  BOOL  child = FALSE;
+#endif
+  char arg1[BUFSIZ], arg2[BUFSIZ];
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+  char FileName[PATH_MAX];   /* for opening the debug log file */
+
+  struct sockaddr name;
+  netperf_socklen_t namelen = sizeof(name);
+  
+
+#ifdef WIN32
+	WSADATA	wsa_data ;
+
+	/* Initialize the winsock lib ( version 2.2 ) */
+	if ( WSAStartup(MAKEWORD(2,2), &wsa_data) == SOCKET_ERROR ){
+		printf("WSAStartup() failed : %d\n", GetLastError()) ;
+		return 1 ;
+	}
+#endif /* WIN32 */
+
+	/* Save away the program name */
+	program = (char *)malloc(strlen(argv[0]) + 1);
+	if (program == NULL) {
+		printf("malloc(%d) failed!\n", strlen(argv[0]) + 1);
+		return 1 ;
+	}
+	strcpy(program, argv[0]);
+
+  netlib_init();
+  
+  /* Scan the command line to see if we are supposed to set-up our own */
+  /* listen socket instead of relying on inetd. */
+
+  /* first set a copy of initial values */
+  strncpy(local_host_name,"0.0.0.0",sizeof(local_host_name));
+  local_address_family = AF_UNSPEC;
+  strncpy(listen_port,TEST_PORT,sizeof(listen_port));
+
+  while ((c = getopt(argc, argv, SERVER_ARGS)) != EOF) {
+    switch (c) {
+    case '?':
+    case 'h':
+      print_netserver_usage();
+      exit(1);
+    case 'd':
+      /* we want to set the debug file name sometime */
+      debug++;
+      break;
+    case 'L':
+      not_inetd = 1;
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	strncpy(local_host_name,arg1,sizeof(local_host_name));
+      }
+      if (arg2[0]) {
+	local_address_family = parse_address_family(arg2);
+	/* if only the address family was set, we may need to set the
+	   local_host_name accordingly. since our defaults are IPv4
+	   this should only be necessary if we have IPv6 support raj
+	   2005-02-07 */  
+#if defined (AF_INET6)
+	if (!arg1[0]) {
+	  strncpy(local_host_name,"::0",sizeof(local_host_name));
+	}
+#endif
+      }
+      break;
+    case 'n':
+      shell_num_cpus = atoi(optarg);
+      if (shell_num_cpus > MAXCPUS) {
+	fprintf(stderr,
+		"netserver: This version can only support %d CPUs. Please",
+		MAXCPUS);
+	fprintf(stderr,
+		"           increase MAXCPUS in netlib.h and recompile.\n");
+	fflush(stderr);
+	exit(1);
+      }
+      break;
+    case 'p':
+      /* we want to open a listen socket at a */
+      /* specified port number */
+      strncpy(listen_port,optarg,sizeof(listen_port));
+      not_inetd = 1;
+      break;
+    case '4':
+      local_address_family = AF_INET;
+      break;
+    case '6':
+#if defined(AF_INET6)
+      local_address_family = AF_INET6;
+      strncpy(local_host_name,"::0",sizeof(local_host_name));
+#else
+      local_address_family = AF_UNSPEC;
+#endif
+      break;
+    case 'v':
+      /* say how much to say */
+      verbosity = atoi(optarg);
+      break;
+    case 'V':
+      printf("Netperf version %s\n",NETPERF_VERSION);
+      exit(0);
+      break;
+#ifdef WIN32
+/*+*+SAF */
+	case 'I':
+		child = TRUE;
+		/* This is the handle we expect to inherit. */
+		/*+*+SAF server_sock = (HANDLE)atoi(optarg); */
+		break;
+	case 'i':
+		/* This is a handle we should NOT inherit. */
+		/*+*+SAF CloseHandle((HANDLE)atoi(optarg)); */
+		break;
+#endif
+
+    }
+  }
+
+  /* +*+SAF I need a better way to find inherited handles I should close! */
+  /* +*+SAF Use DuplicateHandle to force inheritable attribute (or reset it)? */
+
+/*  unlink(DEBUG_LOG_FILE); */
+
+  strcpy(FileName, DEBUG_LOG_FILE);
+    
+#ifndef WIN32
+  snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%d", getpid());
+  if ((where = fopen(FileName, "w")) == NULL) {
+    perror("netserver: debug file");
+    exit(1);
+  }
+#else
+  {
+    
+    if (child) {
+      snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%x", getpid());
+    }
+    
+    /* Hopefully, by closing stdout & stderr, the subsequent
+       fopen calls will get mapped to the correct std handles. */
+    fclose(stdout);
+    
+    if ((where = fopen(FileName, "w")) == NULL) {
+      perror("netserver: fopen of debug file as new stdout failed!");
+      exit(1);
+    }
+    
+    fclose(stderr);
+    
+    if ((where = fopen(FileName, "w")) == NULL) {
+      fprintf(stdout, "fopen of debug file as new stderr failed!\n");
+      exit(1);
+    }
+  }
+#endif
+ 
+#ifndef WIN32 
+  chmod(DEBUG_LOG_FILE,0644);
+#endif
+  
+#if WIN32
+  if (child) {
+	  server_sock = (SOCKET)GetStdHandle(STD_INPUT_HANDLE);
+  }
+#endif
+
+  /* if we are not a child of an inetd or the like, then we should
+   open a socket and hang listens off of it. otherwise, we should go
+   straight into processing requests. the do_listen() routine will sit
+   in an infinite loop accepting connections and forking child
+   processes. the child processes will call process_requests */
+  
+  /* If fd 0 is not a socket then assume we're not being called */
+  /* from inetd and start server socket on the default port. */
+  /* this enhancement comes from vwelch@ncsa.uiuc.edu (Von Welch) */
+  if (not_inetd) {
+    /* the user specified a port number on the command line */
+    set_up_server(local_host_name,listen_port,local_address_family);
+  }
+#ifdef WIN32
+  /* OK, with Win2003 WinNT's POSIX subsystem is gone, and hence so is */
+  /* fork.  But hopefully the kernel support will continue to exist */
+  /* for some time.  We are not counting on the address space */
+  /* copy_on_write support, since it isn't exposed except through the */
+  /* NT native APIs (which are not public).  We will try to use the */
+  /* InheritHandles flag in CreateProcess though since this is public */
+  /* and is used for more than just POSIX so hopefully it won't go */
+  /* away. */
+  else if (TRUE) {
+    if (child) {
+      process_requests();
+    } else {
+      strncpy(listen_port,TEST_PORT,sizeof(listen_port));
+      set_up_server(local_host_name,listen_port,local_address_family);
+    }
+  }
+#endif
+#if !defined(__VMS)
+  else if (getsockname(0, &name, &namelen) == SOCKET_ERROR) {
+    /* we may not be a child of inetd */
+    if (errno == ENOTSOCK) {
+      strncpy(listen_port,TEST_PORT,sizeof(listen_port));
+      set_up_server(local_host_name,listen_port,local_address_family);
+    }
+  }
+#endif /* !defined(__VMS) */
+  else {
+    /* we are probably a child of inetd, or are being invoked via the
+       VMS auxilliarly server mechanism */
+#if !defined(__VMS)
+    server_sock = 0;
+#else
+    if ( (server_sock = socket(TCPIP$C_AUXS, SOCK_STREAM, 0)) == INVALID_SOCKET ) 
+    { 
+      perror("Failed to grab aux server socket" ); 
+      exit(1); 
+    } 
+  
+#endif /* !defined(__VMS) */
+    process_requests();
+  }
+#ifdef WIN32
+	/* Cleanup the winsock lib */
+	WSACleanup();
+#endif
+
+  return(0);
+}
diff --git a/netsh.c b/netsh.c
new file mode 100644
index 0000000..7659679
--- /dev/null
+++ b/netsh.c
@@ -0,0 +1,1002 @@
+#include "netperf_version.h"
+
+char	netsh_id[]="\
+@(#)netsh.c (c) Copyright 1993-2007 Hewlett-Packard Company. Version 2.4.3pre";
+
+
+/****************************************************************/
+/*								*/
+/*	Global include files					*/
+/*								*/
+/****************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+#ifndef WIN32
+#include <unistd.h>
+#ifndef __VMS
+#include <sys/ipc.h>
+#endif /* __VMS */
+#endif /* WIN32 */
+#include <fcntl.h>
+#ifndef WIN32
+#include <errno.h>
+#include <signal.h>
+#endif  /* !WIN32 */
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+ /* the following four includes should not be needed ?*/
+#ifndef WIN32
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#else
+#include <time.h>
+#include <winsock2.h>
+#define netperf_socklen_t socklen_t
+#endif
+
+#ifndef STRINGS
+#include <string.h>
+#else /* STRINGS */
+#include <strings.h>
+#endif /* STRINGS */
+
+#ifdef WIN32
+extern	int	getopt(int , char **, char *) ;
+#else
+double atof(const char *);
+#endif /* WIN32 */
+
+/**********************************************************************/
+/*                                                                    */
+/*          Local Include Files                                       */
+/*                                                                    */
+/**********************************************************************/
+
+#define  NETSH
+#include "netsh.h"
+#include "netlib.h"
+#include "nettest_bsd.h"
+
+#ifdef WANT_UNIX
+#include "nettest_unix.h"
+#ifndef WIN32
+#include "sys/socket.h"
+#endif  /* !WIN32 */
+#endif /* WANT_UNIX */
+
+#ifdef WANT_XTI
+#include "nettest_xti.h"
+#endif /* WANT_XTI */
+
+#ifdef WANT_DLPI
+#include "nettest_dlpi.h"
+#endif /* WANT_DLPI */
+
+#ifdef WANT_SCTP
+#include "nettest_sctp.h"
+#endif
+
+
+/************************************************************************/
+/*									*/
+/*	Global constants  and macros					*/
+/*									*/
+/************************************************************************/
+
+ /* Some of the args take optional parameters. Since we are using */
+ /* getopt to parse the command line, we will tell getopt that they do */
+ /* not take parms, and then look for them ourselves */
+#define GLOBAL_CMD_LINE_ARGS "A:a:b:B:CcdDf:F:H:hi:I:k:K:l:L:n:NO:o:P:p:rt:T:v:VW:w:46"
+
+/************************************************************************/
+/*									*/
+/*	Extern variables 						*/
+/*									*/
+/************************************************************************/
+
+/*
+extern int errno;
+extern char *sys_errlist[ ];
+extern int sys_nerr;
+*/
+
+/************************************************************************/
+/*									*/
+/*	Global variables 						*/
+/*									*/
+/************************************************************************/
+
+/* some names and such                                                  */
+char	*program;		/* program invocation name		*/
+char	username[BUFSIZ];	/* login name of user			*/
+char	cmd_file[BUFSIZ];	/* name of the commands file		*/
+
+/* stuff to say where this test is going                                */
+char	host_name[HOSTNAMESIZE];	/* remote host name or ip addr  */
+char    local_host_name[HOSTNAMESIZE];  /* local hostname or ip */
+char    test_name[BUFSIZ];		/* which test to run 		*/
+char	test_port[PORTBUFSIZE];		/* where is the test waiting    */
+char    local_test_port[PORTBUFSIZE];   /* from whence we should start */
+int     address_family;                 /* which address family remote */
+int     local_address_family;           /* which address family local */
+
+/* the source of data for filling the buffers */
+char    fill_file[BUFSIZ];
+
+/* output controlling variables                                         */
+int
+  debug,			/* debugging level */
+  print_headers,		/* do/don't display headers */
+  verbosity;		/* verbosity level */
+
+/* When specified with -B, this will be displayed at the end of the line
+   for output that does not include the test header.  mostly this is
+   to help identify a specific netperf result when concurrent netperfs
+   are run. raj 2006-02-01 */
+char *result_brand = NULL;
+
+/* cpu variables */
+int
+  local_cpu_usage,	/* you guessed it			*/
+  remote_cpu_usage;	/* still right !			*/
+
+float			       
+  local_cpu_rate,
+  remote_cpu_rate;
+
+int
+  shell_num_cpus=1;
+
+/* the end-test conditions for the tests - either transactions, bytes,  */
+/* or time. different vars used for clarity - space is cheap ;-)        */
+int	
+  test_time,		/* test ends by time			*/
+  test_len_ticks,       /* how many times will the timer go off before */
+			/* the test is over? */
+  test_bytes,		/* test ends on byte count		*/
+  test_trans;		/* test ends on tran count		*/
+
+/* the alignment conditions for the tests				*/
+int
+  local_recv_align,	/* alignment for local receives		*/
+  local_send_align,	/* alignment for local sends		*/
+  local_send_offset = 0,
+  local_recv_offset = 0,
+  remote_recv_align,	/* alignment for remote receives	*/
+  remote_send_align,	/* alignment for remote sends		*/
+  remote_send_offset = 0,
+  remote_recv_offset = 0;
+
+#if defined(WANT_INTERVALS) || defined(WANT_DEMO)
+int
+  interval_usecs,
+  interval_wate,
+  interval_burst;
+
+int demo_mode;                    /* are we actually in demo mode? */
+double demo_interval = 1000000.0; /* what is the desired interval to
+				     display interval results. default
+				     is one second in units of
+				     microseconds */
+double demo_units = 0.0;          /* what is our current best guess as
+				     to how many work units must be
+				     done to be near the desired
+				     reporting interval? */ 
+
+double units_this_tick;
+#endif
+
+#ifdef DIRTY
+int	loc_dirty_count;
+int	loc_clean_count;
+int	rem_dirty_count;
+int	rem_clean_count;
+#endif /* DIRTY */
+
+ /* some of the vairables for confidence intervals... */
+
+int  confidence_level;
+int  iteration_min;
+int  iteration_max;
+int  result_confidence_only = 0;
+
+double interval;
+
+ /* stuff to control the "width" of the buffer rings for sending and */
+ /* receiving data */
+int	send_width;
+int     recv_width;
+
+/* address family */
+int	af = AF_INET;
+
+/* did someone request processor affinity? */
+int cpu_binding_requested = 0;
+
+/* are we not establishing a control connection? */
+int no_control = 0;
+
+char netserver_usage[] = "\n\
+Usage: netserver [options] \n\
+\n\
+Options:\n\
+    -h                Display this text\n\
+    -d                Increase debugging output\n\
+    -L name,family    Use name to pick listen address and family for family\n\
+    -p portnum        Listen for connect requests on portnum.\n\
+    -4                Do IPv4\n\
+    -6                Do IPv6\n\
+    -v verbosity      Specify the verbosity level\n\
+    -V                Display version information and exit\n\
+\n";
+
+/* netperf_usage done as two concatenated strings to make the MS
+   compiler happy when compiling for x86_32.  fix from Spencer
+   Frink.  */
+
+char netperf_usage1[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+Global options:\n\
+    -a send,recv      Set the local send,recv buffer alignment\n\
+    -A send,recv      Set the remote send,recv buffer alignment\n\
+    -B brandstr       Specify a string to be emitted with brief output\n\
+    -c [cpu_rate]     Report local CPU usage\n\
+    -C [cpu_rate]     Report remote CPU usage\n\
+    -d                Increase debugging output\n\
+    -D [secs,units] * Display interim results at least every secs seconds\n\
+                      using units as the initial guess for units per second\n\
+    -f G|M|K|g|m|k    Set the output units\n\
+    -F fill_file      Pre-fill buffers with data from fill_file\n\
+    -h                Display this text\n\
+    -H name|ip,fam *  Specify the target machine and/or local ip and family\n\
+    -i max,min        Specify the max and min number of iterations (15,1)\n\
+    -I lvl[,intvl]    Specify confidence level (95 or 99) (99) \n\
+                      and confidence interval in percentage (10)\n\
+    -l testlen        Specify test duration (>0 secs) (<0 bytes|trans)\n\
+    -L name|ip,fam *  Specify the local ip|name and address family\n\
+    -o send,recv      Set the local send,recv buffer offsets\n\
+    -O send,recv      Set the remote send,recv buffer offset\n\
+    -n numcpu         Set the number of processors for CPU util\n\
+    -N                Establish no control connection, do 'send' side only\n\
+    -p port,lport*    Specify netserver port number and/or local port\n\
+    -P 0|1            Don't/Do display test headers\n\
+    -r                Allow confidence to be hit on result only\n\
+    -t testname       Specify test to perform\n\
+    -T lcpu,rcpu      Request netperf/netserver be bound to local/remote cpu\n\
+    -v verbosity      Specify the verbosity level\n\
+    -W send,recv      Set the number of send,recv buffers\n\
+    -v level          Set the verbosity level (default 1, min 0)\n\
+    -V                Display the netperf version and exit\n";
+
+char netperf_usage2[] = "\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\
+\n"
+"* For these options taking two parms, specifying one value with no comma\n\
+will only set the first parms and will leave the second at the default\n\
+value. To set the second value it must be preceded with a comma or be a\n\
+comma-separated pair. This is to retain previous netperf behaviour.\n"; 
+
+
+/* This routine will return the two arguments to the calling routine. */
+/* If the second argument is not specified, and there is no comma, */
+/* then the value of the second argument will be the same as the */
+/* value of the first. If there is a comma, then the value of the */
+/* second argument will be the value of the second argument ;-) */
+void
+break_args(char *s, char *arg1, char *arg2)
+
+{
+  char *ns;
+  ns = strchr(s,',');
+  if (ns) {
+    /* there was a comma arg2 should be the second arg*/
+    *ns++ = '\0';
+    while ((*arg2++ = *ns++) != '\0');
+  }
+  else {
+    /* there was not a comma, we can use ns as a temp s */
+    /* and arg2 should be the same value as arg1 */
+    ns = s;
+    while ((*arg2++ = *ns++) != '\0');
+  };
+  while ((*arg1++ = *s++) != '\0');
+}
+
+/* break_args_explicit
+
+   this routine is somewhat like break_args in that it will separate a
+   pair of comma-separated values.  however, if there is no comma,
+   this version will not ass-u-me that arg2 should be the same as
+   arg1. raj 2005-02-04 */
+void
+break_args_explicit(char *s, char *arg1, char *arg2)
+
+{
+  char *ns;
+  ns = strchr(s,',');
+  if (ns) {
+    /* there was a comma arg2 should be the second arg*/
+    *ns++ = '\0';
+    while ((*arg2++ = *ns++) != '\0');
+  }
+  else {
+    /* there was not a comma, so we should make sure that arg2 is \0
+       lest something become confused. raj 2005-02-04 */
+    *arg2 = '\0';
+  };
+  while ((*arg1++ = *s++) != '\0');
+
+}
+
+/* given a string with possible values for setting an address family,
+   convert that into one of the AF_mumble values - AF_INET, AF_INET6,
+   AF_UNSPEC as apropriate. the family_string is compared in a
+   case-insensitive manner */
+
+int
+parse_address_family(char family_string[])
+{
+
+  char temp[10];  /* gotta love magic constants :) */
+
+  strncpy(temp,family_string,10);
+
+  if (debug) {
+    fprintf(where,
+	    "Attempting to parse address family from %s derived from %s\n",
+	    temp,
+	    family_string);
+  }
+#if defined(AF_INET6)
+  if (strstr(temp,"6")) {
+    return(AF_INET6);
+  }
+#endif
+  if (strstr(temp,"inet") ||
+      strstr(temp,"4")) {
+    return(AF_INET);
+  }
+  if (strstr(temp,"unspec") ||
+      strstr(temp,"0")) {
+    return(AF_UNSPEC);
+  }
+  fprintf(where,
+	  "WARNING! %s not recognized as an address family, using AF_UNPSEC\n",
+	  family_string);
+  fprintf(where,
+	  "Are you sure netperf was configured for that address family?\n");
+  fflush(where);
+  return(AF_UNSPEC);
+}
+
+
+void
+set_defaults()
+{
+  
+  /* stuff to say where this test is going                              */
+  strcpy(host_name,"");	      /* remote host name or ip addr  */
+  strcpy(local_host_name,""); /* we want it to be INADDR_ANY */
+  strcpy(test_name,"TCP_STREAM");	/* which test to run 		*/
+  strncpy(test_port,"12865",PORTBUFSIZE); /* where is the test waiting    */
+  strncpy(local_test_port,"0",PORTBUFSIZE);/* INPORT_ANY as it were */
+  address_family = AF_UNSPEC;
+  local_address_family = AF_UNSPEC;
+
+  /* output controlling variables                               */
+  debug			= 0;/* debugging level			*/
+  print_headers		= 1;/* do print test headers		*/
+  verbosity		= 1;/* verbosity level			*/
+  /* cpu variables */
+  local_cpu_usage	= 0;/* measure local cpu		*/
+  remote_cpu_usage	= 0;/* what do you think ;-)		*/
+  
+  local_cpu_rate	= (float)0.0;
+  remote_cpu_rate	= (float)0.0;
+  
+  /* the end-test conditions for the tests - either transactions, bytes,  */
+  /* or time. different vars used for clarity - space is cheap ;-)        */
+  test_time	= 10;	/* test ends by time			*/
+  test_bytes	= 0;	/* test ends on byte count		*/
+  test_trans	= 0;	/* test ends on tran count		*/
+  
+  /* the alignment conditions for the tests				*/
+  local_recv_align	= 8;	/* alignment for local receives	*/
+  local_send_align	= 8;	/* alignment for local sends	*/
+  remote_recv_align	= 8;	/* alignment for remote receives*/
+  remote_send_align	= 8;	/* alignment for remote sends	*/
+  
+#ifdef WANT_INTERVALS
+  /* rate controlling stuff */
+  interval_usecs  = 0;
+  interval_wate   = 1;
+  interval_burst  = 0;
+#endif /* WANT_INTERVALS */
+  
+#ifdef DIRTY
+  /* dirty and clean cache stuff */
+  loc_dirty_count = 0;
+  loc_clean_count = 0;
+  rem_dirty_count = 0;
+  rem_clean_count = 0;
+#endif /* DIRTY */
+
+ /* some of the vairables for confidence intervals... */
+
+  confidence_level = 99;
+  iteration_min = 1;
+  iteration_max = 1;
+  interval = 0.05; /* five percent? */
+
+  no_control = 0;
+  strcpy(fill_file,"");
+}
+     
+
+void
+print_netserver_usage()
+{
+  fwrite(netserver_usage, sizeof(char), strlen(netserver_usage), stderr);
+}
+
+
+void
+print_netperf_usage()
+{
+  fwrite(netperf_usage1, sizeof(char), strlen(netperf_usage1),  stderr);
+  fwrite(netperf_usage2, sizeof(char), strlen(netperf_usage2),  stderr);
+}
+
+void
+scan_cmd_line(int argc, char *argv[])
+{
+  extern int	optind;           /* index of first unused arg 	*/
+  extern char	*optarg;	  /* pointer to option string	*/
+  
+  int		c;
+  
+  char	arg1[BUFSIZ],  /* argument holders		*/
+    arg2[BUFSIZ];
+  
+  program = (char *)malloc(strlen(argv[0]) + 1);
+  if (program == NULL) {
+    printf("malloc(%d) failed!\n", strlen(argv[0]) + 1);
+    exit(1);
+  }
+  strcpy(program, argv[0]);
+  
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form first, (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, GLOBAL_CMD_LINE_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case 'h':
+      print_netperf_usage();
+      exit(1);
+    case 'a':
+      /* set local alignments */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	local_send_align = convert(arg1);
+      }
+      if (arg2[0])
+	local_recv_align = convert(arg2);
+      break;
+    case 'A':
+      /* set remote alignments */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	remote_send_align = convert(arg1);
+      }
+      if (arg2[0])
+	remote_recv_align = convert(arg2);
+      break;
+    case 'c':
+      /* measure local cpu usage please. the user */
+      /* may have specified the cpu rate as an */
+      /* optional parm */
+      if (argv[optind] && isdigit((unsigned char)argv[optind][0])){
+	/* there was an optional parm */
+	local_cpu_rate = (float)atof(argv[optind]);
+	optind++;
+      }
+      local_cpu_usage++;
+      break;
+    case 'C':
+      /* measure remote cpu usage please */
+      if (argv[optind] && isdigit((unsigned char)argv[optind][0])){
+	/* there was an optional parm */
+	remote_cpu_rate = (float)atof(argv[optind]);
+	optind++;
+      }
+      remote_cpu_usage++;
+      break;
+    case 'd':
+      debug++;
+      break;
+    case 'D':
+#if (defined WANT_DEMO)
+      demo_mode++;
+      if (argv[optind] && isdigit((unsigned char)argv[optind][0])){
+	/* there was an optional parm */
+	break_args_explicit(argv[optind],arg1,arg2);
+	optind++;
+	if (arg1[0]) {
+	  demo_interval = atof(arg1) * 1000000.0;
+	}
+	if (arg2[0]) {
+	  demo_units = convert(arg2);
+	}
+      }
+#else 
+      printf("Sorry, Demo Mode not configured into this netperf.\n");
+      printf("please consider reconfiguring netperf with\n");
+      printf("--enable-demo=yes and recompiling\n");
+#endif 
+      break;
+    case 'f':
+      /* set the thruput formatting */
+      libfmt = *optarg;
+      break;
+    case 'F':
+      /* set the fill_file variable for pre-filling buffers */
+      strcpy(fill_file,optarg);
+      break;
+    case 'i':
+      /* set the iterations min and max for confidence intervals */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	iteration_max = convert(arg1);
+      }
+      if (arg2[0] ) {
+	iteration_min = convert(arg2);
+      }
+      /* if the iteration_max is < iteration_min make iteration_max
+	 equal iteration_min */
+      if (iteration_max < iteration_min) iteration_max = iteration_min;
+      /* limit minimum to 3 iterations */
+      if (iteration_max < 3) iteration_max = 3;
+      if (iteration_min < 3) iteration_min = 3;
+      /* limit maximum to 30 iterations */
+      if (iteration_max > 30) iteration_max = 30;
+      if (iteration_min > 30) iteration_min = 30;
+      break;
+    case 'I':
+      /* set the confidence level (95 or 99) and width */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	confidence_level = convert(arg1);
+      }
+      if((confidence_level != 95) && (confidence_level != 99)){
+	printf("Only 95%% and 99%% confidence level is supported\n");
+	exit(1);
+      }
+      if (arg2[0] ) {
+	interval = (double) convert(arg2)/100;
+      }
+      /* make sure that iteration_min and iteration_max are at least
+	 at a reasonable default value.  if a -i option has previously
+	 been parsed, these will no longer be 1, so we can check
+	 against 1 */ 
+      if (iteration_min == 1) iteration_min = 3;
+      if (iteration_max == 1) iteration_max = 10;
+
+      break;
+    case 'k':
+      /* local dirty and clean counts */
+#ifdef DIRTY
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	loc_dirty_count = convert(arg1);
+      }
+      if (arg2[0] ) {
+	loc_clean_count = convert(arg2);
+      }
+#else
+      printf("I don't know how to get dirty.\n");
+#endif /* DIRTY */
+      break;
+    case 'K':
+      /* remote dirty and clean counts */
+#ifdef DIRTY
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	rem_dirty_count = convert(arg1);
+      }
+      if (arg2[0] ) {
+	rem_clean_count = convert(arg2);
+      }
+#else
+      printf("I don't know how to get dirty.\n");
+#endif /* DIRTY */
+      break;
+    case 'n':
+      shell_num_cpus = atoi(optarg);
+      break;
+    case 'N':
+      no_control = 1;
+      break;
+    case 'o':
+      /* set the local offsets */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	local_send_offset = convert(arg1);
+      if (arg2[0])
+	local_recv_offset = convert(arg2);
+      break;
+    case 'O':
+      /* set the remote offsets */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) 
+	remote_send_offset = convert(arg1);
+      if (arg2[0])
+	remote_recv_offset = convert(arg2);
+      break;
+    case 'P':
+      /* to print or not to print, that is */
+      /* the header question */
+      print_headers = convert(optarg);
+      break;
+    case 'r':
+      /* the user wishes that we declare confidence when hit on the
+	 result even if not yet reached on CPU utilization.  only
+	 meaningful if cpu util is enabled */
+      result_confidence_only = 1;
+      break;
+    case 't':
+      /* set the test name */
+      strcpy(test_name,optarg);
+      break;
+    case 'T':
+      /* We want to set the processor on which netserver or netperf */
+      /* will run */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) {
+	local_proc_affinity = convert(arg1);
+	bind_to_specific_processor(local_proc_affinity,0);
+      }
+      if (arg2[0]) {
+	remote_proc_affinity = convert(arg2);
+      }
+      cpu_binding_requested = 1;
+      break;
+    case 'W':
+      /* set the "width" of the user space data buffer ring. This will */
+      /* be the number of send_size buffers malloc'd in the tests */  
+      break_args(optarg,arg1,arg2);
+      if (arg1[0]) 
+	send_width = convert(arg1);
+      if (arg2[0])
+	recv_width = convert(arg2);
+      break;
+    case 'l':
+      /* determine test end conditions */
+      /* assume a timed test */
+      test_time = convert(optarg);
+      test_bytes = test_trans = 0;
+      if (test_time < 0) {
+	test_bytes = -1 * test_time;
+	test_trans = test_bytes;
+	test_time = 0;
+      }
+      break;
+    case 'v':
+      /* say how much to say */
+      verbosity = convert(optarg);
+      break;
+    case 'p':
+      /* specify an alternate port number we use break_args_explicit
+	 here to maintain backwards compatibility with previous
+	 generations of netperf where having a single value did not
+	 set both remote _and_ local port number. raj 2005-02-04 */
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(test_port,arg1,PORTBUFSIZE);
+      if (arg2[0])
+	strncpy(local_test_port,arg2,PORTBUFSIZE);
+      break;
+    case 'H':
+      /* save-off the host identifying information, use
+	 break_args_explicit since passing just one value should not
+	 set both */ 
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(host_name,arg1,sizeof(host_name));
+      if (arg2[0])
+	address_family = parse_address_family(arg2);
+      break;
+    case 'L':
+      /* save-off the local control socket addressing information. use
+	 break_args_explicit since passing just one value should not
+	 set both */
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(local_host_name,arg1,sizeof(local_host_name));
+      if (arg2[0])
+	local_address_family = parse_address_family(arg2);
+      break;
+    case 'w':
+      /* We want to send requests at a certain wate. */
+      /* Remember that there are 1000000 usecs in a */
+      /* second, and that the packet rate is */
+      /* expressed in packets per millisecond. */
+#ifdef WANT_INTERVALS
+      interval_usecs = convert_timespec(optarg);
+      interval_wate  = interval_usecs / 1000;
+#else
+      fprintf(where,
+	      "Packet rate control is not compiled in.\n");
+#endif
+      break;
+    case 'b':
+      /* we want to have a burst so many packets per */
+      /* interval. */
+#ifdef WANT_INTERVALS
+      interval_burst = convert(optarg);
+#else
+      fprintf(where,
+	      "Packet burst size is not compiled in. \n");
+#endif /* WANT_INTERVALS */
+      break;
+    case 'B':
+      result_brand = malloc(strlen(optarg)+1);
+      if (NULL != result_brand) {
+	strcpy(result_brand,optarg);
+      }
+      else {
+	fprintf(where,
+		"Unable to malloc space for result brand\n");
+      }
+      break;
+    case '4':
+      address_family = AF_INET;
+      local_address_family = AF_INET;
+      break;
+    case '6':
+#if defined(AF_INET6)
+      address_family = AF_INET6;
+      local_address_family = AF_INET6;
+#else
+      printf("This netperf was not compiled on an IPv6 capable system!\n");
+      exit(-1);
+#endif
+      break;
+    case 'V':
+      printf("Netperf version %s\n",NETPERF_VERSION);
+      exit(0);
+      break;
+    };
+  }
+  /* ok, what should our default hostname and local binding info be?
+   */
+  if ('\0' == host_name[0]) {
+    /* host_name was not set */
+    switch (address_family) {
+    case AF_INET:
+      strcpy(host_name,"localhost");
+      break;
+    case AF_UNSPEC:
+      /* what to do here? case it off the local_address_family I
+	 suppose */
+      switch (local_address_family) {
+      case AF_INET:
+      case AF_UNSPEC:
+	strcpy(host_name,"localhost");
+	break;
+#if defined(AF_INET6)
+      case AF_INET6:
+	strcpy(host_name,"::1");
+	break;
+#endif
+      default:
+	printf("Netperf does not understand %d as an address family\n",
+	       address_family);
+	exit(-1);
+      }
+      break; 
+#if defined(AF_INET6)
+    case AF_INET6:
+      strcpy(host_name,"::1");
+      break;
+#endif
+    default:
+      printf("Netperf does not understand %d as an address family\n",
+	     address_family);
+      exit(-1);
+    }
+  }
+  
+  /* now, having established the name to which the control will
+     connect, from what should it come? */
+  if ('\0' == local_host_name[0]) {
+    switch (local_address_family) {
+    case AF_INET:
+      strcpy(local_host_name,"0.0.0.0");
+      break;
+    case AF_UNSPEC:
+      switch (address_family) {
+      case AF_INET:
+      case AF_UNSPEC:
+	strcpy(local_host_name,"0.0.0.0");
+	break;
+#if defined(AF_INET6)
+      case AF_INET6:
+	strcpy(local_host_name,"::0");
+	break;
+#endif
+      default:
+	printf("Netperf does not understand %d as an address family\n",
+	       address_family);
+	exit(-1);
+      }
+      break;
+#if defined(AF_INET6)
+    case AF_INET6:
+      strcpy(local_host_name,"::0");
+      break;
+#endif
+    default:
+      printf("Netperf does not understand %d as an address family\n",
+	     address_family);
+      exit(-1);
+    }
+  }
+
+  /* so, if we aren't even going to establish a control connection we
+     should set certain "remote" settings to reflect this, regardless
+     of what else may have been set on the command line */
+  if (no_control) {
+    remote_recv_align = -1;
+    remote_send_align = -1;
+    remote_send_offset = -1;
+    remote_recv_offset = -1;
+    remote_cpu_rate = (float)-1.0;
+    remote_cpu_usage = 0;
+  }
+
+  /* parsing test-specific options used to be conditional on there
+    being a "--" in the option stream.  however, some of the tests
+    have other initialization happening in their "scan" routines so we
+    want to call them regardless. raj 2005-02-08 */
+    if ((strcasecmp(test_name,"TCP_STREAM") == 0) ||
+#ifdef HAVE_ICSC_EXS
+    (strcasecmp(test_name,"EXS_TCP_STREAM") == 0) ||
+#endif /* HAVE_ICSC_EXS */ 
+#ifdef HAVE_SENDFILE
+	(strcasecmp(test_name,"TCP_SENDFILE") == 0) ||
+#endif /* HAVE_SENDFILE */
+	(strcasecmp(test_name,"TCP_MAERTS") == 0) ||
+	(strcasecmp(test_name,"TCP_RR") == 0) ||
+	(strcasecmp(test_name,"TCP_CRR") == 0) ||
+	(strcasecmp(test_name,"TCP_CC") == 0) ||
+#ifdef DO_1644
+	(strcasecmp(test_name,"TCP_TRR") == 0) ||
+#endif /* DO_1644 */
+#ifdef DO_NBRR
+	(strcasecmp(test_name,"TCP_TRR") == 0) ||
+#endif /* DO_NBRR */
+	(strcasecmp(test_name,"UDP_STREAM") == 0) ||
+	(strcasecmp(test_name,"UDP_RR") == 0))
+      {
+	scan_sockets_args(argc, argv);
+      }
+
+#ifdef WANT_DLPI
+    else if ((strcasecmp(test_name,"DLCO_RR") == 0) ||
+	     (strcasecmp(test_name,"DLCL_RR") == 0) ||
+	     (strcasecmp(test_name,"DLCO_STREAM") == 0) ||
+	     (strcasecmp(test_name,"DLCL_STREAM") == 0))
+      {
+	scan_dlpi_args(argc, argv);
+      }
+#endif /* WANT_DLPI */
+
+#ifdef WANT_UNIX
+    else if ((strcasecmp(test_name,"STREAM_RR") == 0) ||
+	     (strcasecmp(test_name,"DG_RR") == 0) ||
+	     (strcasecmp(test_name,"STREAM_STREAM") == 0) ||
+	     (strcasecmp(test_name,"DG_STREAM") == 0))
+      {
+	scan_unix_args(argc, argv);
+      }
+#endif /* WANT_UNIX */
+
+#ifdef WANT_XTI
+    else if ((strcasecmp(test_name,"XTI_TCP_RR") == 0) ||
+	     (strcasecmp(test_name,"XTI_TCP_STREAM") == 0) ||
+	     (strcasecmp(test_name,"XTI_UDP_RR") == 0) ||
+	     (strcasecmp(test_name,"XTI_UDP_STREAM") == 0))
+      {
+	scan_xti_args(argc, argv);
+      }
+#endif /* WANT_XTI */
+
+#ifdef WANT_SCTP
+    else if ((strcasecmp(test_name,"SCTP_STREAM") == 0) ||
+	     (strcasecmp(test_name,"SCTP_RR") == 0) ||
+	     (strcasecmp(test_name,"SCTP_STREAM_MANY") == 0) ||
+	     (strcasecmp(test_name,"SCTP_RR_MANY") == 0))
+    {
+      scan_sctp_args(argc, argv);
+    }
+#endif
+
+#ifdef WANT_SDP
+    else if((strcasecmp(test_name,"SDP_STREAM") == 0) ||
+	    (strcasecmp(test_name,"SDP_MAERTS") == 0) ||
+	    (strcasecmp(test_name,"SDP_RR") == 0))
+      {
+	scan_sdp_args(argc, argv);
+      }
+#endif
+    
+    /* what is our default value for the output units?  if the test
+       name contains "RR" or "rr" or "Rr" or "rR" then the default is
+       'x' for transactions. otherwise it is 'm' for megabits
+       (10^6) */
+
+    if ('?' == libfmt) {
+      /* we use a series of strstr's here because not everyone has
+	 strcasestr and I don't feel like up or downshifting text */
+      if ((strstr(test_name,"RR")) ||
+	  (strstr(test_name,"rr")) ||
+	  (strstr(test_name,"Rr")) ||
+	  (strstr(test_name,"rR"))) {
+	libfmt = 'x';
+      }
+      else {
+	libfmt = 'm';
+      }
+    }
+    else if ('x' == libfmt) {
+      /* now, a format of 'x' makes no sense for anything other than
+	 an RR test. if someone has been silly enough to try to set
+	 that, we will reset it silently to default - namely 'm' */
+      if ((strstr(test_name,"RR") == NULL) &&
+	  (strstr(test_name,"rr") == NULL) &&
+	  (strstr(test_name,"Rr") == NULL) &&
+	  (strstr(test_name,"rR") == NULL)) {
+	libfmt = 'm';
+      }
+    }
+}
+
+
+void
+dump_globals()
+{
+  printf("Program name: %s\n", program);
+  printf("Local send alignment: %d\n",local_send_align);
+  printf("Local recv alignment: %d\n",local_recv_align);
+  printf("Remote send alignment: %d\n",remote_send_align);
+  printf("Remote recv alignment: %d\n",remote_recv_align);
+  printf("Report local CPU %d\n",local_cpu_usage);
+  printf("Report remote CPU %d\n",remote_cpu_usage);
+  printf("Verbosity: %d\n",verbosity);
+  printf("Debug: %d\n",debug);
+  printf("Port: %s\n",test_port);
+  printf("Test name: %s\n",test_name);
+  printf("Test bytes: %d Test time: %d Test trans: %d\n",
+	 test_bytes,
+	 test_time,
+	 test_trans);
+  printf("Host name: %s\n",host_name);
+  printf("\n");
+}
diff --git a/netsh.h b/netsh.h
new file mode 100644
index 0000000..e99883b
--- /dev/null
+++ b/netsh.h
@@ -0,0 +1,149 @@
+/*
+        Copyright (C) 1993,1995 Hewlett-Packard Company
+*/
+
+/* libraried performance include file 				*/
+/* the define NOPERFEXTERN tels us not to re-define all the 	*/
+
+/* defines and defaults */
+#define		HOSTNAMESIZE 	255
+#define         PORTBUFSIZE     10
+#define		DEFAULT_SIZE	32768
+#define		HOST_NAME	"127.0.0.1"
+#define		TEST_PORT	"12865"
+
+/* output controlling variables                                         */
+#define 	DEBUG 0		/* debugging level			*/
+#define 	VERBOSITY 0	/* verbosity level			*/
+
+/* the end-test conditions for the tests - either transactions, bytes,  */
+/* or time. different vars used for clarity - space is cheap ;-)        */
+#define 	TEST_TIME 10	/* test ends by time			*/
+#define 	TEST_BYTES 0	/* test ends on byte count		*/
+#define 	TEST_TRANS 0	/* test ends on tran count		*/
+
+/* the alignment conditions for the tests				*/
+#define 	LOC_RECV_ALIGN	4	/* alignment for local receives	*/
+#define 	LOC_SEND_ALIGN	4	/* alignment for local sends	*/
+#define 	REM_RECV_ALIGN	4	/* alignment for remote receive	*/
+#define 	REM_SEND_ALIGN	4	/* alignment for remote sends	*/
+
+/* misc defines for the hell of it					*/
+#ifndef MAXLONG
+#define 	MAXLONG  	4294967295UL
+#endif /* MAXLONG */
+
+#ifndef NETSH
+extern char		*program;		/* program invocation name		*/
+
+/* stuff to say where this test is going                                */
+extern char	host_name[HOSTNAMESIZE];/* remote host name or ip addr  */
+extern char     local_host_name[HOSTNAMESIZE];
+extern char	test_port[PORTBUFSIZE]; /* where is the test waiting    */
+extern char     local_test_port[PORTBUFSIZE];
+extern int      address_family;
+extern int      local_address_family;
+extern int      parse_address_family(char family_string[]);
+extern void     set_defaults();
+extern void     scan_cmd_line(int argc, char *argv[]);
+extern void     dump_globals();
+extern void     break_args(char *s, char *arg1, char *arg2);
+extern void     break_args_explicit(char *s, char *arg1, char *arg2);
+extern void     print_netserver_usage();
+
+/* output controlling variables                                         */
+extern int
+  debug,		/* debugging level			*/
+  print_headers,	/* do/don't print test headers		*/
+  verbosity;		/* verbosity level			*/
+
+/* the end-test conditions for the tests - either transactions, bytes,  */
+/* or time. different vars used for clarity - space is cheap ;-)        */
+extern int	
+  test_time,		/* test ends by time			*/
+  test_len_ticks,
+  test_bytes,		/* test ends on byte count		*/
+  test_trans;		/* test ends on tran count		*/
+
+/* the alignment conditions for the tests				*/
+extern int
+  local_recv_align,	/* alignment for local receives		*/
+  local_send_align,	/* alignment for local sends		*/
+  remote_recv_align,	/* alignment for remote receives	*/
+  remote_send_align,	/* alignment for remote sends		*/
+  local_send_offset,
+  local_recv_offset,
+  remote_send_offset,
+  remote_recv_offset;
+
+#if defined(WANT_INTERVALS) || defined(WANT_DEMO)
+extern	int          interval_usecs;
+extern  int          interval_wate;
+extern	int	     interval_burst;
+
+extern int    demo_mode;
+extern double demo_interval;
+extern double demo_units;
+extern double units_this_tick;
+#endif 
+
+#ifdef DIRTY
+extern int	rem_dirty_count;
+extern int	rem_clean_count;
+extern int	loc_dirty_count;
+extern int	loc_clean_count;
+#endif /* DIRTY */
+
+/* stuff for confidence intervals */
+
+extern int  confidence_level;
+extern int  iteration_min;
+extern int  iteration_max;
+extern int  result_confidence_only;
+extern double interval;
+
+extern int cpu_binding_requested;
+
+/* stuff to controll the bufferspace "width" */
+extern int	send_width;
+extern int      recv_width;
+
+/* address family */
+extern int	af;
+
+/* different options for other things					*/
+extern int
+  local_cpu_usage,
+  remote_cpu_usage;
+
+extern float
+  local_cpu_rate,
+  remote_cpu_rate;
+
+extern int
+  shell_num_cpus;
+
+extern	char	
+  test_name[BUFSIZ];
+
+extern char
+  fill_file[BUFSIZ];
+
+extern char *
+  result_brand;
+
+extern int
+  no_control;
+
+#ifdef WANT_DLPI
+
+extern int
+  loc_ppa,
+  rem_ppa;
+
+extern int
+  dlpi_sap;
+
+#endif /* WANT_DLPI */
+
+#endif
diff --git a/nettest_bsd.c b/nettest_bsd.c
new file mode 100644
index 0000000..27092f3
--- /dev/null
+++ b/nettest_bsd.c
@@ -0,0 +1,12333 @@
+#ifndef lint
+char	nettest_id[]="\
+@(#)nettest_bsd.c (c) Copyright 1993-2004 Hewlett-Packard Co. Version 2.4.3";
+#endif /* lint */
+
+
+/****************************************************************/
+/*								*/
+/*	nettest_bsd.c						*/
+/*								*/
+/*      the BSD sockets parsing routine...                      */
+/*       ...with the addition of Windows NT, this is now also   */
+/*          a Winsock test... sigh :)                           */
+/*                                                              */
+/*      scan_sockets_args()                                     */
+/*                                                              */
+/*	the actual test routines...				*/
+/*								*/
+/*	send_tcp_stream()	perform a tcp stream test	*/
+/*	recv_tcp_stream()					*/
+/*      send_tcp_maerts()       perform a tcp stream test       */
+/*      recv_tcp_maerts()       in the other direction          */
+/*	send_tcp_rr()		perform a tcp request/response	*/
+/*	recv_tcp_rr()						*/
+/*      send_tcp_conn_rr()      an RR test including connect    */
+/*      recv_tcp_conn_rr()                                      */
+/*      send_tcp_cc()           a connect/disconnect test with  */
+/*      recv_tcp_cc()           no RR                           */
+/*	send_udp_stream()	perform a udp stream test	*/
+/*	recv_udp_stream()					*/
+/*	send_udp_rr()		perform a udp request/response	*/
+/*	recv_udp_rr()						*/
+/*	loc_cpu_rate()		determine the local cpu maxrate */
+/*	rem_cpu_rate()		find the remote cpu maxrate	*/
+/*								*/
+/****************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#if HAVE_STRING_H
+# if !STDC_HEADERS && HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include <fcntl.h>
+#ifndef WIN32
+#include <errno.h>
+#include <signal.h>
+#endif
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+#ifdef NOSTDLIBH
+#include <malloc.h>
+#endif /* NOSTDLIBH */
+
+#ifndef WIN32
+#if !defined(__VMS)
+#include <sys/ipc.h>
+#endif /* !defined(__VMS) */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#else /* WIN32 */
+#include <process.h>
+#define netperf_socklen_t socklen_t
+#include <winsock2.h>
+
+/* while it is unlikely that anyone running Windows 2000 or NT 4 is
+   going to be trying to compile this, if they are they will want to
+   define DONT_IPV6 in the sources file */
+#ifndef DONT_IPV6
+#include <ws2tcpip.h>
+#endif
+#include <windows.h>
+
+#define sleep(x) Sleep((x)*1000)
+
+#define __func__ __FUNCTION__
+#endif /* WIN32 */
+
+/* We don't want to use bare constants in the shutdown() call.  In the
+   extremely unlikely event that SHUT_WR isn't defined, we will define
+   it to the value we used to be passing to shutdown() anyway.  raj
+   2007-02-08 */
+#if !defined(SHUT_WR)
+#define SHUT_WR 1
+#endif
+
+#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO)
+# include "missing/getaddrinfo.h"
+#endif
+
+#include "netlib.h"
+#include "netsh.h"
+#include "nettest_bsd.h"
+
+#if defined(WANT_HISTOGRAM) || defined(WANT_DEMO) 
+#include "hist.h"
+#endif /* WANT_HISTOGRAM */
+
+/* make first_burst_size unconditional so we can use it easily enough
+   when calculating transaction latency for the TCP_RR test. raj
+   2007-06-08 */
+int first_burst_size=0;
+
+#if defined(HAVE_SENDFILE) && (defined(__linux) || defined(__sun__))
+#include <sys/sendfile.h>
+#endif /* HAVE_SENDFILE && (__linux || __sun__) */
+
+
+
+/* these variables are specific to the BSD sockets tests, but can
+ * be used elsewhere if needed.  They are externed through nettest_bsd.h
+ */
+
+int	
+  rss_size_req = -1,	/* requested remote socket send buffer size */
+  rsr_size_req = -1,	/* requested remote socket recv buffer size */
+  rss_size,		/* remote socket send buffer size	*/
+  rsr_size,		/* remote socket recv buffer size	*/
+  lss_size_req = -1,	/* requested local socket send buffer size */
+  lsr_size_req = -1,	/* requested local socket recv buffer size */
+  lss_size,		/* local  socket send buffer size 	*/
+  lsr_size,		/* local  socket recv buffer size 	*/
+  req_size = 1,		/* request size                   	*/
+  rsp_size = 1,		/* response size			*/
+  send_size,		/* how big are individual sends		*/
+  recv_size;		/* how big are individual receives	*/
+
+static  int confidence_iteration;
+static  char  local_cpu_method;
+static  char  remote_cpu_method;
+
+/* these will control the width of port numbers we try to use in the */
+/* TCP_CRR and/or TCP_TRR tests. raj 3/95 */
+static int client_port_min = 5000;
+static int client_port_max = 65535;
+
+ /* different options for the sockets				*/
+
+int
+  loc_nodelay,		/* don't/do use NODELAY	locally		*/
+  rem_nodelay,		/* don't/do use NODELAY remotely	*/
+#ifdef TCP_CORK
+  loc_tcpcork=0,        /* don't/do use TCP_CORK locally        */
+  rem_tcpcork=0,        /* don't/do use TCP_CORK remotely       */
+#endif /* TCP_CORK */
+  loc_sndavoid,		/* avoid send copies locally		*/
+  loc_rcvavoid,		/* avoid recv copies locally		*/
+  rem_sndavoid,		/* avoid send copies remotely		*/
+  rem_rcvavoid, 	/* avoid recv_copies remotely		*/
+  local_connected = 0,  /* local socket type, connected/non-connected */
+  remote_connected = 0; /* remote socket type, connected/non-connected */
+
+#ifdef WANT_HISTOGRAM
+#ifdef HAVE_GETHRTIME
+static hrtime_t time_one;
+static hrtime_t time_two;
+#elif HAVE_GET_HRT
+#include "hrt.h"
+static hrt_t time_one;
+static hrt_t time_two;
+#elif defined(WIN32)
+static LARGE_INTEGER time_one;
+static LARGE_INTEGER time_two;
+#else
+static struct timeval time_one;
+static struct timeval time_two;
+#endif /* HAVE_GETHRTIME */
+static HIST time_hist;
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_INTERVALS
+int interval_count;
+#ifndef WANT_SPIN
+sigset_t signal_set;
+#define INTERVALS_INIT() \
+    if (interval_burst) { \
+      /* zero means that we never pause, so we never should need the \
+         interval timer. we used to use it for demo mode, but we deal \
+	 with that with a variant on watching the clock rather than \
+	 waiting for a timer. raj 2006-02-06 */ \
+      start_itimer(interval_wate); \
+    } \
+    interval_count = interval_burst; \
+    /* get the signal set for the call to sigsuspend */ \
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) { \
+      fprintf(where, \
+	      "%s: unable to get sigmask errno %d\n", \
+	      __func__, \
+	      errno); \
+      fflush(where); \
+      exit(1); \
+    }
+
+#define INTERVALS_WAIT() \
+      /* 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 sigsuspend and wait for the interval timer to get us \
+	   out */ \
+	if (debug > 1) { \
+	  fprintf(where,"about to suspend\n"); \
+	  fflush(where); \
+	} \
+	if (sigsuspend(&signal_set) == EFAULT) { \
+	  fprintf(where, \
+		  "%s: fault with sigsuspend.\n", \
+                  __func__); \
+	  fflush(where); \
+	  exit(1); \
+	} \
+	interval_count = interval_burst; \
+      }
+#else
+/* first out timestamp */
+#ifdef HAVE_GETHRTIME
+static hrtime_t intvl_one;
+static hrtime_t intvl_two;
+static hrtime_t *intvl_one_ptr = &intvl_one;
+static hrtime_t *intvl_two_ptr = &intvl_two;
+static hrtime_t *temp_intvl_ptr = &intvl_one;
+#elif defined(WIN32)
+static LARGE_INTEGER intvl_one;
+static LARGE_INTEGER intvl_two;
+static LARGE_INTEGER *intvl_one_ptr = &intvl_one;
+static LARGE_INTEGER *intvl_two_ptr = &intvl_two;
+static LARGE_INTEGER *temp_intvl_ptr = &intvl_one;
+#else
+static struct timeval intvl_one;
+static struct timeval intvl_two;
+static struct timeval *intvl_one_ptr = &intvl_one;
+static struct timeval *intvl_two_ptr = &intvl_two;
+static struct timeval *temp_intvl_ptr = &intvl_one;
+#endif
+
+#define INTERVALS_INIT() \
+      if (interval_burst) { \
+	HIST_timestamp(intvl_one_ptr); \
+      } \
+      interval_count = interval_burst; \
+
+#define INTERVALS_WAIT() \
+      /* 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 sigsuspend and wait for the interval timer to get us \
+	   out */ \
+	if (debug > 1) { \
+	  fprintf(where,"about to spin suspend\n"); \
+	  fflush(where); \
+	} \
+        HIST_timestamp(intvl_two_ptr); \
+        while(delta_micro(intvl_one_ptr,intvl_two_ptr) < interval_usecs) { \
+	  HIST_timestamp(intvl_two_ptr); \
+	} \
+	temp_intvl_ptr = intvl_one_ptr; \
+	intvl_one_ptr = intvl_two_ptr; \
+	intvl_two_ptr = temp_intvl_ptr; \
+	interval_count = interval_burst; \
+      }
+#endif
+#endif
+
+#ifdef WANT_DEMO
+#ifdef HAVE_GETHRTIME
+static hrtime_t demo_one;
+static hrtime_t demo_two;
+static hrtime_t *demo_one_ptr = &demo_one;
+static hrtime_t *demo_two_ptr = &demo_two;
+static hrtime_t *temp_demo_ptr = &demo_one;
+#elif defined(WIN32)
+static LARGE_INTEGER demo_one;
+static LARGE_INTEGER demo_two;
+static LARGE_INTEGER *demo_one_ptr = &demo_one;
+static LARGE_INTEGER *demo_two_ptr = &demo_two;
+static LARGE_INTEGER *temp_demo_ptr = &demo_one;
+#else
+static struct timeval demo_one;
+static struct timeval demo_two;
+static struct timeval *demo_one_ptr = &demo_one;
+static struct timeval *demo_two_ptr = &demo_two;
+static struct timeval *temp_demo_ptr = &demo_one;
+#endif 
+
+/* for a _STREAM test, "a" should be lss_size and "b" should be
+   rsr_size. for a _MAERTS test, "a" should be lsr_size and "b" should
+   be rss_size. raj 2005-04-06 */
+#define DEMO_STREAM_SETUP(a,b) \
+    if ((demo_mode) && (demo_units == 0)) { \
+      /* take our default value of demo_units to be the larger of \
+	 twice the remote's SO_RCVBUF or twice our SO_SNDBUF */ \
+      if (a > b) { \
+	demo_units = 2*a; \
+      } \
+      else { \
+	demo_units = 2*b; \
+      } \
+    }
+
+#define DEMO_STREAM_INTERVAL(units) \
+      if (demo_mode) { \
+	double actual_interval; \
+	units_this_tick += units; \
+	if (units_this_tick >= demo_units) { \
+	  /* time to possibly update demo_units and maybe output an \
+	     interim result */ \
+	  HIST_timestamp(demo_two_ptr); \
+	  actual_interval = delta_micro(demo_one_ptr,demo_two_ptr); \
+	  /* we always want to fine-tune demo_units here whether we \
+	     emit an interim result or not.  if we are short, this \
+	     will lengthen demo_units.  if we are long, this will \
+	     shorten it */ \
+	  demo_units = demo_units * (demo_interval / actual_interval); \
+	  if (actual_interval >= demo_interval) { \
+	    /* time to emit an interim result */ \
+	    fprintf(where, \
+		    "Interim result: %7.2f %s/s over %.2f seconds\n", \
+		    calc_thruput_interval(units_this_tick, \
+					  actual_interval/1000000.0), \
+		    format_units(), \
+		    actual_interval/1000000.0); \
+            fflush(where); \
+	    units_this_tick = 0.0; \
+	    /* now get a new starting timestamp.  we could be clever \
+	       and swap pointers - the math we do probably does not \
+	       take all that long, but for now this will suffice */ \
+	    temp_demo_ptr = demo_one_ptr; \
+	    demo_one_ptr = demo_two_ptr; \
+	    demo_two_ptr = temp_demo_ptr; \
+	  } \
+	} \
+      }
+
+#define DEMO_RR_SETUP(a) \
+    if ((demo_mode) && (demo_units == 0)) { \
+      /* take whatever we are given */ \
+	demo_units = a; \
+    }
+
+#define DEMO_RR_INTERVAL(units) \
+      if (demo_mode) { \
+	double actual_interval; \
+	units_this_tick += units; \
+	if (units_this_tick >= demo_units) { \
+	  /* time to possibly update demo_units and maybe output an \
+	     interim result */ \
+	  HIST_timestamp(demo_two_ptr); \
+	  actual_interval = delta_micro(demo_one_ptr,demo_two_ptr); \
+	  /* we always want to fine-tune demo_units here whether we \
+	     emit an interim result or not.  if we are short, this \
+	     will lengthen demo_units.  if we are long, this will \
+	     shorten it */ \
+	  demo_units = demo_units * (demo_interval / actual_interval); \
+	  if (actual_interval >= demo_interval) { \
+	    /* time to emit an interim result */ \
+	    fprintf(where, \
+		    "Interim result: %.2f %s/s over %.2f seconds\n", \
+                    units_this_tick / (actual_interval/1000000.0), \
+		    "Trans", \
+		    actual_interval/1000000.0); \
+	    units_this_tick = 0.0; \
+	    /* now get a new starting timestamp.  we could be clever \
+	       and swap pointers - the math we do probably does not \
+	       take all that long, but for now this will suffice */ \
+	    temp_demo_ptr = demo_one_ptr; \
+	    demo_one_ptr = demo_two_ptr; \
+	    demo_two_ptr = temp_demo_ptr; \
+	  } \
+	} \
+      }
+#endif 
+
+char sockets_usage[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+TCP/UDP BSD Sockets Test Options:\n\
+    -b number         Send number requests at start of _RR tests\n\
+    -C                Set TCP_CORK when available\n\
+    -D [L][,R]        Set TCP_NODELAY locally and/or remotely (TCP_*)\n\
+    -h                Display this text\n\
+    -H name,fam       Use name (or IP) and family as target of data connection\n\
+    -L name,fam       Use name (or IP) and family as source of data connection\n\
+    -m bytes          Set the send size (TCP_STREAM, UDP_STREAM)\n\
+    -M bytes          Set the recv size (TCP_STREAM, UDP_STREAM)\n\
+    -n                Use the connected socket for UDP locally\n\
+    -N                Use the connected socket for UDP remotely\n\
+    -p min[,max]      Set the min/max port numbers for TCP_CRR, TCP_TRR\n\
+    -P local[,remote] Set the local/remote port for the data socket\n\
+    -r req,[rsp]      Set request/response sizes (TCP_RR, UDP_RR)\n\
+    -s send[,recv]    Set local socket send/recv buffer sizes\n\
+    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
+    -4                Use AF_INET (eg IPv4) on both ends of the data conn\n\
+    -6                Use AF_INET6 (eg IPv6) on both ends of the data conn\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"; 
+
+
+
+/* these routines convert between the AF address space and the NF
+   address space since the numeric values of AF_mumble are not the
+   same across the platforms. raj 2005-02-08 */
+
+int
+nf_to_af(int nf) {
+  switch(nf) {
+  case NF_INET:
+    return AF_INET;
+    break;
+  case NF_UNSPEC:
+    return AF_UNSPEC;
+    break;
+  case NF_INET6:
+#if defined(AF_INET6)
+    return AF_INET6;
+#else
+    return AF_UNSPEC;
+#endif
+    break;
+  default:
+    return AF_UNSPEC;
+    break;
+  }
+}
+
+int
+af_to_nf(int af) {
+
+  switch(af) {
+  case AF_INET:
+    return NF_INET;
+    break;
+  case AF_UNSPEC:
+    return NF_UNSPEC;
+    break;
+#if defined(AF_INET6)
+  case AF_INET6:
+    return NF_INET6;
+    break;
+#endif
+  default:
+    return NF_UNSPEC;
+    break;
+  }
+}     
+
+
+ /* This routine is intended to retrieve interesting aspects of tcp */
+ /* for the data connection. at first, it attempts to retrieve the */
+ /* maximum segment size. later, it might be modified to retrieve */
+ /* other information, but it must be information that can be */
+ /* retrieved quickly as it is called during the timing of the test. */
+ /* for that reason, a second routine may be created that can be */
+ /* called outside of the timing loop */
+static
+void
+get_tcp_info(SOCKET socket, int *mss)
+{
+
+#ifdef TCP_MAXSEG
+  netperf_socklen_t sock_opt_len;
+
+  sock_opt_len = sizeof(netperf_socklen_t);
+  if (getsockopt(socket,
+		 getprotobyname("tcp")->p_proto,	
+		 TCP_MAXSEG,
+		 (char *)mss,
+		 &sock_opt_len) == SOCKET_ERROR) {
+    fprintf(where,
+	    "netperf: get_tcp_info: getsockopt TCP_MAXSEG: errno %d\n",
+	    errno);
+    fflush(where);
+    *mss = -1;
+  }
+#else
+  *mss = -1;
+#endif /* TCP_MAXSEG */
+}
+
+
+/* return a pointer to a completed addrinfo chain - prefer
+   data_address to controlhost and utilize the specified address
+   family */
+
+struct addrinfo *
+complete_addrinfo(char *controlhost, char *data_address, char *port, int family, int type, int protocol, int flags) 
+{
+  struct addrinfo hints;
+  struct addrinfo *res;
+  struct addrinfo *temp_res;
+
+#define CHANGED_SOCK_TYPE  0x1
+#define CHANGED_PROTOCOL   0x2
+#define CHANGED_SCTP       0x4
+  int    change_info = 0;
+  static int change_warning_displayed = 0;
+
+  int count = 0;
+  int error = 0;
+
+  char *hostname;
+
+  /* take data-address over controlhost */
+  if (data_address)
+    hostname = data_address;
+  else
+    hostname = controlhost;
+
+  if (debug) {
+    fprintf(where,
+	    "complete_addrinfo using hostname %s port %s family %s type %s prot %s flags 0x%x\n",
+	    hostname,
+	    port,
+	    inet_ftos(family),
+	    inet_ttos(type),
+	    inet_ptos(protocol),
+	    flags);
+    fflush(where);
+  }
+
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = family;
+  hints.ai_socktype = type;
+  hints.ai_protocol = protocol;
+  hints.ai_flags = flags|AI_CANONNAME;
+
+  count = 0;
+  do {
+    error = getaddrinfo((char *)hostname,
+                        (char *)port,
+                        &hints,
+                        &res);
+    count += 1;
+    if (error == EAI_AGAIN) {
+      if (debug) {
+        fprintf(where,"Sleeping on getaddrinfo EAI_AGAIN\n");
+        fflush(where);
+      }
+      sleep(1);
+    }
+    /* while you see this kludge first, it is actually the second, the
+       first being the one for Solaris below. The need for this kludge
+       came after implementing the Solaris broken getaddrinfo kludge -
+       now we see a kludge in Linux getaddrinfo where if it is given
+       SOCK_STREAM and IPPROTO_SCTP it barfs with a -7
+       EAI_SOCKTYPE. so, we check if the error was EAI_SOCKTYPE and if
+       we were asking for IPPROTO_SCTP and if so, kludge, again... raj
+       2008-10-13 */
+#ifdef WANT_SCTP
+    if (EAI_SOCKTYPE == error
+#ifdef EAI_BADHINTS
+        || EAI_BADHINTS == error
+#endif
+        ) {
+      /* we ass-u-me this is the Linux getaddrinfo bug, clear the
+	 hints.ai_protocol field, and set some state "remembering"
+	 that we did this so the code for the Solaris kludge can do
+	 the fix-up for us.  also flip error over to EAI_AGAIN and
+	 make sure we don't "count" this time around the loop. */
+      hints.ai_protocol = 0;
+      error = EAI_AGAIN;
+      count -= 1;
+      change_info |= CHANGED_SCTP;
+    }
+#endif
+  } while ((error == EAI_AGAIN) && (count <= 5));
+
+  if (error) {
+    fprintf(where,
+	    "complete_addrinfo: could not resolve '%s' port '%s' af %d",
+	    hostname,
+	    port,
+	    family);
+    fprintf(where,
+	    "\n\tgetaddrinfo returned %d %s\n",
+	    error,
+	    gai_strerror(error));
+    fflush(where);
+    exit(-1);
+  }
+
+  /* there exists at least one platform - Solaris 10 - that does not
+     seem to completely honor the ai_protocol and/or ai_socktype one
+     sets in the hints parm to the getaddrinfo call.  so, we need to
+     walk the list of entries returned and if either of those do not
+     match what we asked for, we need to go ahead and set them
+     "correctly" this is based in part on some earlier SCTP-only code
+     from previous revisions.  raj 2006-10-09 */
+
+  temp_res = res;
+
+  while (temp_res) {
+
+    if ((type)  &&
+	(temp_res->ai_socktype != type)) {
+      change_info |= CHANGED_SOCK_TYPE;
+      if (debug) {
+	fprintf(where,
+		"WARNING! Changed bogus getaddrinfo socket type %d to %d\n",
+		temp_res->ai_socktype,
+		type);
+	fflush(where);
+      }
+      temp_res->ai_socktype = type;
+    }
+
+    if ((protocol) &&
+	(temp_res->ai_protocol != protocol)) {
+      change_info |= CHANGED_PROTOCOL;
+      if (debug) {
+	fprintf(where,
+		"WARNING! Changed bogus getaddrinfo protocol %d to %d\n",
+		temp_res->ai_protocol,
+		protocol);
+	fflush(where);
+      }
+      temp_res->ai_protocol = protocol;
+    }
+    temp_res = temp_res->ai_next;
+  }
+	
+  if ((change_info & CHANGED_SOCK_TYPE) &&
+      !(change_warning_displayed & CHANGED_SOCK_TYPE)) {
+    change_warning_displayed |= CHANGED_SOCK_TYPE;
+    fprintf(where,
+	    "WARNING! getaddrinfo returned a socket type which did not\n");
+    fprintf(where,
+	    "match the requested type.  Please contact your vendor for\n");
+    fprintf(where,
+	    "a fix to this bug in getaddrinfo()\n");
+    fflush(where);
+  }
+
+  /* if we dropped the protocol hint, it would be for a protocol that
+     getaddrinfo() wasn't supporting yet, not for the bug that it took
+     our hint and still returned zero. raj 2006-10-16 */
+  if ((change_info & CHANGED_PROTOCOL) &&
+      !(change_warning_displayed & CHANGED_PROTOCOL) &&
+      (hints.ai_protocol != 0)) {
+    change_warning_displayed |= CHANGED_PROTOCOL;
+    fprintf(where,
+	    "WARNING! getaddrinfo returned a protocol other than the\n");
+    fprintf(where,
+	    "requested protocol.  Please contact your vendor for\n");
+    fprintf(where,
+	    "a fix to this bug in getaddrinfo()\n");
+    fflush(where);
+  }
+
+  if ((change_info & CHANGED_SCTP) &&
+      !(change_warning_displayed & CHANGED_SCTP)) {
+    change_warning_displayed |= CHANGED_SCTP;
+    fprintf(where,
+	    "WARNING! getaddrinfo on this platform does not accept IPPROTO_SCTP!\n");
+    fprintf(where,
+	    "Please contact your vendor for a fix to this bug in getaddrinfo().\n");
+    fflush(where);
+  }
+
+
+  if (debug) {
+    dump_addrinfo(where, res, hostname, port, family);
+  }
+
+  return(res);
+}
+
+void
+complete_addrinfos(struct addrinfo **remote,struct addrinfo **local, char remote_host[], int type, int protocol, int flags) {
+
+  *remote = complete_addrinfo(remote_host,
+			      remote_data_address,
+			      remote_data_port,
+			      remote_data_family,
+			      type,
+			      protocol,
+			      flags);
+
+  /* OK, if the user has not specified a local data endpoint address
+     (test-specific -L), pick the local data endpoint address based on
+     the remote data family info (test-specific -H or -4 or -6
+     option).  if the user has not specified remote data addressing
+     info (test-specific -H, -4 -6) pick something based on the local
+     control connection address (ie the global -L option). */
+
+  if (NULL == local_data_address) {
+    local_data_address = malloc(HOSTNAMESIZE);
+    if (NULL == remote_data_address) {
+      if (debug) {
+	fprintf(where,
+		"local_data_address not set, using local_host_name of '%s'\n",
+		local_host_name);
+	fflush(where);
+      }
+      strcpy(local_data_address,local_host_name);
+    }
+    else {
+      if (debug) {
+	fprintf(where,
+		"local_data_address not set, using address family info\n");
+	fflush(where);
+      }
+      /* by default, use 0.0.0.0 - assume IPv4 */
+      strcpy(local_data_address,"0.0.0.0");
+#if defined(AF_INET6)
+      if ((AF_INET6 == local_data_family) ||
+	  ((AF_UNSPEC == local_data_family) &&
+	   (AF_INET6 == remote_data_family)) ||
+	  ((AF_UNSPEC == local_data_family) && 
+	   (AF_INET6 == (*remote)->ai_family))) {
+	strcpy(local_data_address,"::0");
+      }
+#endif
+    }
+  }
+
+  *local = complete_addrinfo("what to put here?",
+			     local_data_address,
+			     local_data_port,
+			     local_data_family,
+			     type,
+			     protocol,
+			     flags|AI_PASSIVE);
+
+}
+
+void
+set_hostname_and_port(char *hostname, char *portstr, int family, int port)
+{
+  strcpy(hostname,"0.0.0.0");
+#if defined AF_INET6
+  if (AF_INET6 == family) {
+    strcpy(hostname,"::0");
+  }
+#endif
+    
+  sprintf(portstr, "%u", port);
+
+}
+
+static unsigned short
+get_port_number(struct addrinfo *res) 
+{
+ switch(res->ai_family) {
+  case AF_INET: {
+    struct sockaddr_in *foo = (struct sockaddr_in *)res->ai_addr;
+    return(ntohs(foo->sin_port));
+    break;
+  }
+#if defined(AF_INET6)
+  case AF_INET6: {
+    struct sockaddr_in6 *foo = (struct sockaddr_in6 *)res->ai_addr;
+    return(ntohs(foo->sin6_port));
+    break;
+  }
+#endif
+  default:
+    fprintf(where,
+	    "Unexpected Address Family of %u\n",res->ai_family);
+    fflush(where);
+    exit(-1);
+  }
+}
+
+/* this routine will set the port number of the sockaddr in the
+   addrinfo to the specified value, based on the address family */
+void
+set_port_number(struct addrinfo *res, unsigned short port)
+{
+  switch(res->ai_family) {
+  case AF_INET: {
+    struct sockaddr_in *foo = (struct sockaddr_in *)res->ai_addr;
+    foo->sin_port = htons(port);
+    break;
+  }
+#if defined(AF_INET6)
+  case AF_INET6: {
+    struct sockaddr_in6 *foo = (struct sockaddr_in6 *)res->ai_addr;
+    foo->sin6_port = htons(port);
+    break;
+  }
+#endif
+  default:
+    fprintf(where,
+	    "Unexpected Address Family of %u\n",res->ai_family);
+    fflush(where);
+    exit(-1);
+  }
+}
+
+
+
+ /* This routine will create a data (listen) socket with the
+  apropriate options set and return it to the caller. this replaces
+  all the duplicate code in each of the test routines and should help
+  make things a little easier to understand. since this routine can be
+  called by either the netperf or netserver programs, all output
+  should be directed towards "where." family is generally AF_INET and
+  type will be either SOCK_STREAM or SOCK_DGRAM.  This routine will
+  also be used by the "SCTP" tests, hence the slightly strange-looking
+  SCTP stuff in the classic bsd sockets test file... vlad/raj
+  2005-03-15 */
+
+SOCKET
+create_data_socket(struct addrinfo *res)
+{
+
+  SOCKET temp_socket;
+  int one;
+  int    on  = 1;
+  
+
+  /*set up the data socket                        */
+  temp_socket = socket(res->ai_family,
+		       res->ai_socktype,
+		       res->ai_protocol);
+  
+  if (temp_socket == INVALID_SOCKET){
+    fprintf(where,
+	    "netperf: create_data_socket: socket: errno %d fam %s type %s prot %s errmsg %s\n",
+	    errno,
+	    inet_ftos(res->ai_family),
+	    inet_ttos(res->ai_socktype),
+	    inet_ptos(res->ai_protocol),
+	    strerror(errno));
+    fflush(where);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"create_data_socket: socket %d obtained...\n",temp_socket);
+    fflush(where);
+  }
+  
+  /* Modify the local socket size. The reason we alter the send buffer
+   size here rather than when the connection is made is to take care
+   of decreases in buffer size. Decreasing the window size after
+   connection establishment is a 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 (well, should
+   never be) 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.  */
+  
+  /* all the oogy nitty gritty stuff moved from here into the routine
+     being called below, per patches from davidm to workaround the bug
+     in Linux getsockopt().  raj 2004-06-15 */
+  set_sock_buffer (temp_socket, SEND_BUFFER, lss_size_req, &lss_size);
+  set_sock_buffer (temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size);
+
+  /* now, we may wish to enable the copy avoidance features on the */
+  /* local system. of course, this may not be possible... */
+  
+#ifdef SO_RCV_COPYAVOID
+  if (loc_rcvavoid) {
+    if (setsockopt(temp_socket,
+		   SOL_SOCKET,
+		   SO_RCV_COPYAVOID,
+		   (const char *)&loc_rcvavoid,
+		   sizeof(int)) == SOCKET_ERROR) {
+      fprintf(where,
+	      "netperf: create_data_socket: Could not enable receive copy avoidance");
+      fflush(where);
+      loc_rcvavoid = 0;
+    }
+  }
+#else
+  /* it wasn't compiled in... */
+  loc_rcvavoid = 0;
+#endif /* SO_RCV_COPYAVOID */
+
+#ifdef SO_SND_COPYAVOID
+  if (loc_sndavoid) {
+    if (setsockopt(temp_socket,
+		   SOL_SOCKET,
+		   SO_SND_COPYAVOID,
+		   (const char *)&loc_sndavoid,
+		   sizeof(int)) == SOCKET_ERROR) {
+      fprintf(where,
+	      "netperf: create_data_socket: Could not enable send copy avoidance");
+      fflush(where);
+      loc_sndavoid = 0;
+    }
+  }
+#else
+  /* it was not compiled in... */
+  loc_sndavoid = 0;
+#endif
+  
+  /* Now, we will see about setting the TCP_NODELAY flag on the local */
+  /* socket. We will only do this for those systems that actually */
+  /* support the option. If it fails, note the fact, but keep going. */
+  /* If the user tries to enable TCP_NODELAY on a UDP socket, this */
+  /* will cause an error to be displayed */
+
+  /* well..... long ago and far away that would have happened, in
+     particular because we would always use IPPROTO_TCP here.
+     however, now we are using res->ai_protocol, which will be
+     IPPROT_UDP, and while HP-UX, and I suspect no-one else on the
+     planet has a UDP_mumble option that overlaps with TCP_NODELAY,
+     sure as knuth made little green programs, linux has a UDP_CORK
+     option that is defined as a value of 1, which is the same a
+     TCP_NODELAY under Linux.  So, when asking for -D and
+     "TCP_NODELAY" under Linux, we are actually setting UDP_CORK
+     instead of getting an error like every other OS on the
+     planet. joy and rupture. this stops a UDP_RR test cold sooo we
+     have to make sure that res->ai_protocol actually makes sense for
+     a _NODELAY setsockopt() or a UDP_RR test on Linux where someone
+     mistakenly sets -D will hang.  raj 2005-04-21 */
+  
+#if defined(TCP_NODELAY) || defined(SCTP_NODELAY)
+  if ((loc_nodelay) && (res->ai_protocol != IPPROTO_UDP)) {
+
+    /* strictly speaking, since the if defined above is an OR, we
+       should probably check against TCP_NODELAY being defined here.
+       however, the likelihood of SCTP_NODELAY being defined and
+       TCP_NODELAY _NOT_ being defined is, probably :), epsilon.  raj
+       2005-03-15 */
+
+    int option = TCP_NODELAY;
+
+    /* I suspect that WANT_SCTP would suffice here since that is the
+       only time we would have called getaddrinfo with a hints asking
+       for SCTP, but just in case there is an SCTP implementation out
+       there _without_ SCTP_NODELAY... raj 2005-03-15 */ 
+
+#if defined(WANT_SCTP) && defined(SCTP_NODELAY)
+    if (IPPROTO_SCTP == res->ai_protocol) {
+      option = SCTP_NODELAY;
+    }
+#endif
+
+    one = 1;
+    if(setsockopt(temp_socket,
+		  res->ai_protocol,
+		  option,
+		  (char *)&one,
+		  sizeof(one)) == SOCKET_ERROR) {
+      fprintf(where,
+	      "netperf: create_data_socket: nodelay: errno %d\n",
+	      errno);
+      fflush(where);
+    }
+    
+    if (debug > 1) {
+      fprintf(where,
+	      "netperf: create_data_socket: [TCP|SCTP]_NODELAY requested...\n");
+      fflush(where);
+    }
+  }
+#else /* TCP_NODELAY */
+  
+  loc_nodelay = 0;
+  
+#endif /* TCP_NODELAY */
+
+#if defined(TCP_CORK)
+    
+    if (loc_tcpcork != 0) {
+      /* the user wishes for us to set TCP_CORK on the socket */
+      int one = 1;
+      if (setsockopt(temp_socket,
+		     getprotobyname("tcp")->p_proto,
+		     TCP_CORK,
+		     (char *)&one,
+		     sizeof(one)) == SOCKET_ERROR) {
+	perror("netperf: sendfile_tcp_stream: tcp_cork");
+	exit(1);
+      }
+      if (debug) {
+	fprintf(where,"sendfile_tcp_stream: tcp_cork...\n");
+      }
+    }
+    
+#endif /* TCP_CORK */    
+
+  /* since some of the UDP tests do not do anything to cause an
+     implicit bind() call, we need to be rather explicit about our
+     bind() call here. even if the address and/or the port are zero
+     (INADDR_ANY etc). raj 2004-07-20 */
+
+  if (setsockopt(temp_socket,
+		 SOL_SOCKET,
+		 SO_REUSEADDR,
+		 (const char *)&on,
+		 sizeof(on)) < 0) {
+    fprintf(where,
+	    "netperf: create_data_socket: SO_REUSEADDR failed %d\n",
+	    errno);
+    fflush(where);
+  }
+  
+  if (bind(temp_socket,
+	   res->ai_addr,
+	   res->ai_addrlen) < 0) {
+    if (debug) {
+      fprintf(where,
+	      "netperf: create_data_socket: data socket bind failed errno %d\n",
+	      errno);
+      fprintf(where," port: %d\n",get_port_number(res));
+      fflush(where);
+    }
+  }
+  
+
+  return(temp_socket);
+
+}
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+
+
+ /* This routine is for those BROKEN systems which do not correctly */
+ /* pass socket attributes through calls such as accept(). It should */
+ /* only be called for those broken systems. I *really* don't want to */
+ /* have this, but even broken systems must be measured. raj 11/95 */
+void
+kludge_socket_options(int temp_socket)
+{
+
+  set_sock_buffer(temp_socket, SEND_BUFFER, lss_size_req, &lss_size);
+  set_sock_buffer(temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size);
+
+  /* now, we may wish to enable the copy avoidance features on the */
+  /* local system. of course, this may not be possible... */
+  /* those calls were only valid for HP-UX, and I know that HP-UX is */
+  /* written correctly, and so we do not need to include those calls */
+  /* in this kludgy routine. raj 11/95 */
+
+  
+  /* Now, we will see about setting the TCP_NODELAY flag on the local */
+  /* socket. We will only do this for those systems that actually */
+  /* support the option. If it fails, note the fact, but keep going. */
+  /* If the user tries to enable TCP_NODELAY on a UDP socket, this */
+  /* will cause an error to be displayed */
+  
+#ifdef TCP_NODELAY
+  if (loc_nodelay) {
+    one = 1;
+    if(setsockopt(temp_socket,
+		  getprotobyname("tcp")->p_proto,
+		  TCP_NODELAY,
+		  (char *)&one,
+		  sizeof(one)) == SOCKET_ERROR) {
+      fprintf(where,"netperf: kludge_socket_options: nodelay: errno %d\n",
+	      errno);
+      fflush(where);
+    }
+    
+    if (debug > 1) {
+      fprintf(where,
+	      "netperf: kludge_socket_options: TCP_NODELAY requested...\n");
+      fflush(where);
+    }
+  }
+#else /* TCP_NODELAY */
+  
+  loc_nodelay = 0;
+  
+#endif /* TCP_NODELAY */
+
+  }
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+
+
+static void *
+get_address_address(struct addrinfo *info) 
+{
+  struct sockaddr_in *sin;
+#if defined(AF_INET6)
+  struct sockaddr_in6 *sin6;
+#endif
+
+  switch(info->ai_family) {
+  case AF_INET:
+    sin = (struct sockaddr_in *)info->ai_addr;
+    return(&(sin->sin_addr));
+    break;
+#if defined(AF_INET6)
+  case AF_INET6:
+    sin6 = (struct sockaddr_in6 *)info->ai_addr;
+    return(&(sin6->sin6_addr));
+    break;
+#endif
+  default:
+    fprintf(stderr,"we never expected to get here in get_address_address\n");
+    fflush(stderr);
+    exit(-1);
+  }
+}
+
+#if defined(WIN32) 
+/* +*+ Why isn't this in the winsock headers yet? */
+const char *
+inet_ntop(int af, const void *src, char *dst, size_t size);
+#endif
+
+/* This routine is a generic test header printer for the topmost header */
+void
+print_top_test_header(char test_name[], struct addrinfo *source, struct addrinfo *destination)
+{
+
+#if defined(AF_INET6)
+  char address_buf[INET6_ADDRSTRLEN];
+#else
+  char address_buf[16]; /* magic constant */
+#endif
+
+  /* we want to have some additional, interesting information in */
+  /* the headers. we know some of it here, but not all, so we will */
+  /* only print the test title here and will print the results */
+  /* titles after the test is finished */
+  fprintf(where,test_name);
+  address_buf[0] = '\0';
+  inet_ntop(source->ai_family,get_address_address(source),address_buf,sizeof(address_buf));
+  fprintf(where,
+	  " from %s (%s) port %u %s",
+	  source->ai_canonname,
+	  address_buf,
+	  get_port_number(source),
+	  inet_ftos(source->ai_family));
+  address_buf[0] = '\0';
+  inet_ntop(destination->ai_family,get_address_address(destination),address_buf,sizeof(address_buf));
+  fprintf(where,
+	  " to %s (%s) port %u %s",
+	  destination->ai_canonname,
+	  address_buf,
+	  get_port_number(destination),
+	  inet_ftos(destination->ai_family));
+
+  if (iteration_max > 1) {
+    fprintf(where,
+	    " : +/-%3.1f%% @ %2d%% conf. %s",
+	    interval/0.02,
+	    confidence_level,
+	    result_confidence_only ? " on result only" : "");
+  }
+  if ((loc_nodelay > 0) || (rem_nodelay > 0)) {
+    fprintf(where," : nodelay");
+  }
+  if ((loc_sndavoid > 0) || 
+      (loc_rcvavoid > 0) ||
+      (rem_sndavoid > 0) ||
+      (rem_rcvavoid > 0)) {
+    fprintf(where," : copy avoidance");
+  }
+
+  if (no_control) {
+    fprintf(where," : no control");
+  }
+
+#ifdef WANT_HISTOGRAM
+  fprintf(where," : histogram");
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_INTERVALS
+#ifndef WANT_SPIN
+  fprintf(where," : interval");
+#else
+  fprintf(where," : spin interval");
+#endif
+#endif /* WANT_INTERVALS */
+
+#ifdef DIRTY 
+  fprintf(where," : dirty data");
+#endif /* DIRTY */
+#ifdef WANT_DEMO
+  fprintf(where," : demo");
+#endif
+#ifdef WANT_FIRST_BURST
+  /* a little hokey perhaps, but we really only want this to be
+     emitted for tests where it actually is used, which means a
+     "REQUEST/RESPONSE" test. raj 2005-11-10 */
+  if (strstr(test_name,"REQUEST/RESPONSE")) {
+    fprintf(where," : first burst %d",first_burst_size);
+  }
+#endif
+  if (cpu_binding_requested) {
+    fprintf(where," : cpu bind");
+  }
+  fprintf(where,"\n");
+  
+}
+
+
+/* This routine implements the TCP 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_tcp_stream(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   %s\n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %6d    %-6.2f     %7.2f   %-6.2f   %-6.2f   %-6.3f  %-6.3f %s\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";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+  /* 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;
+  
+  int len;
+  unsigned int nummessages = 0;
+  SOCKET send_socket;
+  int bytes_remaining;
+  int tcp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+
+  unsigned long long local_bytes_sent = 0;
+  double	bytes_sent = 0.0;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+  
+  struct	tcp_stream_request_struct	*tcp_stream_request;
+  struct	tcp_stream_response_struct	*tcp_stream_response;
+  struct	tcp_stream_results_struct	*tcp_stream_result;
+  
+  tcp_stream_request  = 
+    (struct tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+  tcp_stream_response =
+    (struct tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+  tcp_stream_result   = 
+    (struct tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+  /* 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. */
+  
+  /* complete_addrinfos will either succede or exit the process */
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+  
+  if ( print_headers ) {
+    print_top_test_header("TCP STREAM TEST",local_res,remote_res);
+  }
+
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+    
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_tcp_stream: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_tcp_stream: send_socket obtained...\n");
+    }
+    
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one send-size greater than our socket */
+    /* buffer size. We want to be sure that there are at least two */
+    /* buffers allocated - this can be a bit of a problem when the */
+    /* send_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our send */
+    /* buffers, we should respect that wish... */
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) {
+      /* only allocate the send ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* Tell the remote end to do a listen. The server alters the
+	 socket paramters on the other side at this point, hence the
+	 reason for all the values being passed in the setup
+	 message. If the user did not specify any of the parameters,
+	 they will be passed as 0, which will indicate to the remote
+	 that no changes beyond the system's default should be
+	 used. Alignment is the exception, it will default to 1, which
+	 will be no alignment alterations. */
+    
+      netperf_request.content.request_type =	DO_TCP_STREAM;
+      tcp_stream_request->send_buf_size	=	rss_size_req;
+      tcp_stream_request->recv_buf_size	=	rsr_size_req;
+      tcp_stream_request->receive_size	=	recv_size;
+      tcp_stream_request->no_delay	=	rem_nodelay;
+      tcp_stream_request->recv_alignment	=	remote_recv_align;
+      tcp_stream_request->recv_offset	=	remote_recv_offset;
+      tcp_stream_request->measure_cpu	=	remote_cpu_usage;
+      tcp_stream_request->cpu_rate	=	remote_cpu_rate;
+      if (test_time) {
+	tcp_stream_request->test_length	=	test_time;
+      }
+      else {
+	tcp_stream_request->test_length	=	test_bytes;
+      }
+      tcp_stream_request->so_rcvavoid	=	rem_rcvavoid;
+      tcp_stream_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+      tcp_stream_request->dirty_count     =       rem_dirty_count;
+      tcp_stream_request->clean_count     =       rem_clean_count;
+#endif /* DIRTY */
+      tcp_stream_request->port            =    atoi(remote_data_port);
+      tcp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
+      if (debug > 1) {
+	fprintf(where,
+		"netperf: send_tcp_stream: 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");
+	rsr_size	      =	tcp_stream_response->recv_buf_size;
+	rss_size	      =	tcp_stream_response->send_buf_size;
+	rem_nodelay     =	tcp_stream_response->no_delay;
+	remote_cpu_usage=	tcp_stream_response->measure_cpu;
+	remote_cpu_rate = tcp_stream_response->cpu_rate;
+	
+	/* we have to make sure that the server port number is in
+	   network order */
+	set_port_number(remote_res,
+			(short)tcp_stream_response->data_port_number);
+	
+	rem_rcvavoid	= tcp_stream_response->so_rcvavoid;
+	rem_sndavoid	= tcp_stream_response->so_sndavoid;
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lss_size,rsr_size)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: send_tcp_stream: data socket connect failed");
+      exit(1);
+    }
+
+    /* Data Socket set-up is finished. If there were problems, either */
+    /* the connect would have failed, or the previous response would */
+    /* have indicated a problem. I failed to see the value of the */
+    /* extra  message after the accept on the remote. If it failed, */
+    /* we'll see it here. If it didn't, we might as well start pumping */
+    /* data. */ 
+    
+    /* Set-up the test end conditions. For a 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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      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 only start the interval timer if we are using the
+       timer-timed intervals rather than the sit and spin ones. raj
+       2006-02-06 */    
+#if defined(WANT_INTERVALS)
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+    /* before we start, initialize a few variables */
+
+#ifdef WANT_DEMO
+      if (demo_mode) {
+	HIST_timestamp(demo_one_ptr);
+      }
+#endif
+      
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+#ifdef DIRTY
+      access_buffer(send_ring->buffer_ptr,
+		    send_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before we go into send and then again just
+	 after we come out raj 8/94 */
+	/* but lets only do this if there is going to be a histogram
+	   displayed */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+
+      if((len=send(send_socket,
+		   send_ring->buffer_ptr,
+		   send_size,
+		   0)) != send_size) {
+      if ((len >=0) || SOCKET_EINTR(len)) {
+	    /* the test was interrupted, must be the end of test */
+	    break;
+	  }
+	perror("netperf: data send error");
+	printf("len was %d\n",len);
+	exit(1);
+      }
+
+      local_bytes_sent += send_size;
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp the exit from the send call and update the histogram */
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(send_size)
+#endif 
+
+#if defined(WANT_INTERVALS)
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      send_ring = send_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a */
+    /* graceful release to insure that all data has been taken by the */
+    /* remote. */ 
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the TCP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      tcp_mss = -1;
+      get_tcp_info(send_socket,&tcp_mss);
+    }
+    
+    if (shutdown(send_socket,SHUT_WR) == SOCKET_ERROR) {
+      perror("netperf: cannot shutdown tcp stream socket");
+      exit(1);
+    }
+    
+    /* hang a recv() off the socket to block until the remote has */
+    /* brought all the data up into the application. it will do a */
+    /* shutdown to cause a FIN to be sent our way. We will assume that */
+    /* any exit from the recv() call is good... raj 4/93 */
+    
+    recv(send_socket, send_ring->buffer_ptr, send_size, 0);
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+
+    close(send_socket);
+
+    if (!no_control) {
+      /* 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);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	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	= ntohd(tcp_stream_result->bytes_received);
+    }
+    else {
+      bytes_sent = (double)local_bytes_sent;
+    }
+
+    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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= tcp_stream_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      tcp_stream_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(tcp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+		fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand,	/* remote service demand */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+		fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput,                  /* how fast did it go */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      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... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)tcp_stream_result->recv_calls,
+	    tcp_stream_result->recv_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    tcp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+
+/* This routine implements the netperf-side TCP unidirectional data
+   transfer test (a.k.a. stream) for the sockets interface where the
+   data flow is from the netserver to the netperf.  It receives its
+   parameters via global variables from the shell and writes its
+   output to the standard output. */
+
+
+void 
+send_tcp_maerts(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f    %s \n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %6d    %-6.2f     %7.2f   %-6.2f   %-6.2f   %-6.3f  %-6.3f %s\n";
+  
+  char *ksink_fmt = "\n\
+Alignment      Offset         %-8.8s %-8.8s    Recvs   %-8.8s Sends\n\
+Local  Remote  Local  Remote  Xfered   Per                 Per\n\
+Recv   Send    Recv   Send             Recv (avg)          Send (avg)\n\
+%5d   %5d  %5d   %5d %6.4g  %6.2f    %6d   %6.2f %6d\n";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* recv-size greater than our recv 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 *recv_ring;
+  
+  int len;
+  unsigned int nummessages = 0;
+  SOCKET recv_socket;
+  int bytes_remaining;
+  int tcp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can recv > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+  double	bytes_sent = 0.0;
+  unsigned long long local_bytes_recvd = 0;
+
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+  
+  struct	tcp_maerts_request_struct	*tcp_maerts_request;
+  struct	tcp_maerts_response_struct	*tcp_maerts_response;
+  struct	tcp_maerts_results_struct	*tcp_maerts_result;
+  
+  tcp_maerts_request  = 
+    (struct tcp_maerts_request_struct *)netperf_request.content.test_specific_data;
+  tcp_maerts_response =
+    (struct tcp_maerts_response_struct *)netperf_response.content.test_specific_data;
+  tcp_maerts_result   = 
+    (struct tcp_maerts_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+  /* 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. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+  
+  if ( print_headers ) {
+    print_top_test_header("TCP MAERTS TEST",local_res,remote_res);
+  }
+
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /*set up the data socket                        */
+    recv_socket = create_data_socket(local_res);
+    
+    if (recv_socket == INVALID_SOCKET){
+      perror("netperf: send_tcp_maerts: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_tcp_maerts: recv_socket obtained...\n");
+    }
+
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the recv */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the recv size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (recv_size == 0) {
+      if (lsr_size > 0) {
+	recv_size = lsr_size;
+      }
+      else {
+	recv_size = 4096;
+      }
+    }
+
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one recv-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 */
+    /* recv_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our recv */
+    /* buffers, we should respect that wish... */
+    if (recv_width == 0) {
+      recv_width = (lsr_size/recv_size) + 1;
+      if (recv_width == 1) recv_width++;
+    }
+    
+    if (recv_ring == NULL) {
+      /* only allocate the recv ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      recv_ring = allocate_buffer_ring(recv_width,
+				       recv_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* Tell the remote end to do a listen. The server alters the
+	 socket paramters on the other side at this point, hence the
+	 reason for all the values being passed in the setup
+	 message. If the user did not specify any of the parameters,
+	 they will be passed as 0, which will indicate to the remote
+	 that no changes beyond the system's default should be
+	 used. Alignment is the exception, it will default to 1, which
+	 will be no alignment alterations. */
+
+      netperf_request.content.request_type	=	DO_TCP_MAERTS;
+      tcp_maerts_request->send_buf_size	=	rss_size_req;
+      tcp_maerts_request->recv_buf_size	=	rsr_size_req;
+      tcp_maerts_request->send_size	=	send_size;
+      tcp_maerts_request->no_delay	=	rem_nodelay;
+      tcp_maerts_request->send_alignment	=	remote_send_align;
+      tcp_maerts_request->send_offset	=	remote_send_offset;
+      tcp_maerts_request->measure_cpu	=	remote_cpu_usage;
+      tcp_maerts_request->cpu_rate	=	remote_cpu_rate;
+      if (test_time) {
+	tcp_maerts_request->test_length	=	test_time;
+      }
+      else {
+	tcp_maerts_request->test_length	=	test_bytes;
+      }
+      tcp_maerts_request->so_rcvavoid	=	rem_rcvavoid;
+      tcp_maerts_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+      tcp_maerts_request->dirty_count       =       rem_dirty_count;
+      tcp_maerts_request->clean_count       =       rem_clean_count;
+#endif /* DIRTY */
+      tcp_maerts_request->port            = atoi(remote_data_port);
+      tcp_maerts_request->ipfamily        = af_to_nf(remote_res->ai_family);
+      if (debug > 1) {
+	fprintf(where,
+		"netperf: send_tcp_maerts: requesting TCP maerts 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");
+	rsr_size	=	tcp_maerts_response->recv_buf_size;
+	rss_size	=	tcp_maerts_response->send_buf_size;
+	rem_nodelay     =	tcp_maerts_response->no_delay;
+	remote_cpu_usage=	tcp_maerts_response->measure_cpu;
+	remote_cpu_rate = tcp_maerts_response->cpu_rate;
+	send_size       = tcp_maerts_response->send_size;
+	
+	/* we have to make sure that the server port number is in
+	 network order */
+      set_port_number(remote_res,
+		      (short)tcp_maerts_response->data_port_number);
+      rem_rcvavoid	= tcp_maerts_response->so_rcvavoid;
+      rem_sndavoid	= tcp_maerts_response->so_sndavoid;
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lsr_size,rss_size)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(recv_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: send_tcp_maerts: data socket connect failed");
+      exit(1);
+    }
+
+    /* Data Socket set-up is finished. If there were problems, either */
+    /* the connect would have failed, or the previous response would */
+    /* have indicated a problem. I failed to see the value of the */
+    /* extra  message after the accept on the remote. If it failed, */
+    /* we'll see it here. If it didn't, we might as well start pumping */
+    /* data. */ 
+    
+    /* Set-up the test end conditions. For a maerts 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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      if (!no_control) {
+	/* this is a netperf to netserver test, netserver will close
+	   to tell us the test is over, so use PAD_TIME to avoid
+	   causing the netserver fits. */
+	start_timer(test_time + PAD_TIME);
+      }
+      else {
+	/* this is a netperf to data source test, no PAD_TIME */
+	start_timer(test_time);
+      }
+    }
+    else {
+      /* The tester wanted to recv a number of bytes. we don't do that 
+	 in a TCP_MAERTS test. sorry. raj 2002-06-21 */
+      printf("netperf: send_tcp_maerts: test must be timed\n");
+      exit(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);
+    
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+    /* before we start, initialize a few variables */
+
+#ifdef WANT_DEMO
+    if (demo_mode) {
+      HIST_timestamp(demo_one_ptr);
+    }
+#endif
+
+    /* the test will continue until we either get a zero-byte recv()
+       on the socket or our failsafe timer expires. most of the time
+       we trust that we get a zero-byte recieve from the socket. raj
+       2002-06-21 */
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      /* timestamp just before we go into recv and then again just
+	 after we come out raj 8/94 */
+      /* but only if we are actually going to display a histogram. raj
+	 2006-02-07 */
+      HIST_timestamp(&time_one);
+    }
+#endif /* WANT_HISTOGRAM */
+    
+    while ((!times_up) && (len=recv(recv_socket,
+				    recv_ring->buffer_ptr,
+				    recv_size,
+				    0)) > 0 ) {
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp the exit from the recv call and update the histogram */
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef DIRTY
+      access_buffer(recv_ring->buffer_ptr,
+		    recv_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(len);
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the recv width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      recv_ring = recv_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= len;
+      }
+
+      local_bytes_recvd += len;
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* make sure we timestamp just before we go into recv  */
+	/* raj 2004-06-15 */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+    
+    }
+
+    /* an EINTR is to be expected when this is a no_control test */
+    if (((len < 0) || SOCKET_EINTR(len)) && (!no_control)) {
+      perror("send_tcp_maerts: data recv error");
+      printf("len was %d\n",len);
+      exit(1);
+    }
+    
+    /* if we get here, it must mean we had a recv return of 0 before
+       the watchdog timer expired, or the watchdog timer expired and
+       this was a no_control test */
+
+    /* The test is over. Flush the buffers to the remote end. We do a
+       graceful release to tell the  remote we have all the data. */  
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the TCP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      tcp_mss = -1;
+      get_tcp_info(recv_socket,&tcp_mss);
+    }
+    
+    if (shutdown(recv_socket,SHUT_WR) == SOCKET_ERROR) {
+      perror("netperf: cannot shutdown tcp maerts socket");
+      exit(1);
+    }
+
+    stop_timer();
+    
+    /* this call will always give us the local elapsed time for the
+       test, and will also store-away the necessaries for cpu
+       utilization */ 
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+
+    close(recv_socket);
+
+    if (!no_control) {
+      /* 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);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	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 maerts 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 recv_size, so we
+	 really didn't recv what he asked for ;-) */
+    
+      bytes_sent	= ntohd(tcp_maerts_result->bytes_sent);
+    }
+    else {
+      bytes_sent = (double)local_bytes_recvd;
+    }
+
+
+    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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= tcp_maerts_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      tcp_maerts_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(tcp_maerts_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the recvs */
+	      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 */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      lsr_size, 		/* local recvbuf size */
+	      rss_size, 		/* remot sendbuf size */
+	      send_size,		/* how large were the recvs */
+	      elapsed_time, 		/* how long did it take */
+	      thruput,                  /* how fast did it go */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      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... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    fprintf(where,
+	    ksink_fmt,
+	    "Bytes",
+	    "Bytes",
+	    "Bytes",
+	    local_recv_align,
+	    remote_recv_align,
+	    local_recv_offset,
+	    remote_recv_offset,
+	    bytes_sent,
+	    bytes_sent / (double)nummessages,
+	    nummessages,
+	    bytes_sent / (double)tcp_maerts_result->send_calls,
+	    tcp_maerts_result->send_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    tcp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in recv() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+
+#ifdef HAVE_ICSC_EXS
+
+#include <sys/exs.h>
+
+
+/* This routine implements the TCP 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_exs_tcp_stream(char remote_host[])
+{
+
+    char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+
+    char *tput_fmt_0 =
+        "%7.2f\n";
+
+    char *tput_fmt_1 =
+        "%6d %6d %6d    %-6.2f   %7.2f   \n";
+
+    char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+
+    char *cpu_fmt_0 =
+        "%6.3f %c\n";
+
+    char *cpu_fmt_1 =
+        "%6d %6d %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";
+
+    char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+
+
+    float         elapsed_time;
+
+    /* 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;
+
+    int len;
+    unsigned int nummessages = 0;
+    SOCKET send_socket;
+    int bytes_remaining;
+    int tcp_mss = -1;  /* possibly uninitialized on printf far below */
+
+    exs_mhandle_t exs_mhandle;
+    exs_qhandle_t exs_qhandle;
+#define NETPERF_EXS_PENDING  16
+    int exs_aio_pending;
+    int exs_aio_eagain;
+    int exs_aio_dequeued;
+    int exs_aio_dequeuecnt;
+    int exs_evtcnt;
+#define NETPERF_EXS_QSIZE    128
+    exs_event_t exs_evtvec[NETPERF_EXS_QSIZE];
+
+    /* with links like fddi, one can send > 32 bits worth of bytes */
+    /* during a test... ;-) at some point, this should probably become a */
+    /* 64bit integral type, but those are not entirely common yet */
+
+    double   bytes_sent = 0.0;
+
+    float   local_cpu_utilization;
+    float   local_service_demand;
+    float   remote_cpu_utilization;
+    float   remote_service_demand;
+
+    double   thruput;
+
+    struct addrinfo *remote_res;
+    struct addrinfo *local_res;
+
+    struct   tcp_stream_request_struct   *tcp_stream_request;
+    struct   tcp_stream_response_struct   *tcp_stream_response;
+    struct   tcp_stream_results_struct   *tcp_stream_result;
+
+    tcp_stream_request  =
+        (struct tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+    tcp_stream_response =
+        (struct tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+    tcp_stream_result   =
+        (struct tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+
+#if 0 /* def WANT_HISTOGRAM */
+    time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+    /* 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. */
+
+    /* complete_addrinfos will either succede or exit the process */
+    complete_addrinfos(&remote_res,
+                       &local_res,
+                       remote_host,
+                       SOCK_STREAM,
+                       IPPROTO_TCP,
+                       0);
+
+    if ( print_headers ) {
+        print_top_test_header("EXS TCP STREAM TEST",local_res,remote_res);
+    }
+
+    send_ring = NULL;
+    confidence_iteration = 1;
+    init_stat();
+
+    /* initialize EXS API and create event queue */
+    if (exs_init (EXS_VERSION) == -1) {
+        perror ("netperf: send_exs_tcp_stream: exs_init failed");
+        exit (1);
+    }
+
+    if ((exs_qhandle = exs_qcreate (NETPERF_EXS_QSIZE)) == EXS_QHANDLE_INVALID) {
+        perror ("netperf: send_exs_tcp_stream: exs_qcreate failed");
+        exit (1);
+    }
+    if (debug) {
+        fprintf (where, "send_exs_tcp_stream: qhandle=%d\n", exs_qhandle);
+    }
+
+    /* we have a great-big while loop which controls the number of times */
+    /* we run a particular test. this is for the calculation of a */
+    /* confidence interval (I really should have stayed awake during */
+    /* probstats :). If the user did not request confidence measurement */
+    /* (no confidence is the default) then we will only go though the */
+    /* loop once. the confidence stuff originates from the folks at IBM */
+
+    while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+           (confidence_iteration <= iteration_min)) {
+
+        /* initialize a few counters. we have to remember that we might be */
+        /* going through the loop more than once. */
+
+        nummessages    =   0;
+        bytes_sent     =   0.0;
+        times_up       =    0;
+
+        /*set up the data socket                        */
+        send_socket = create_data_socket(local_res);
+
+        if (send_socket == INVALID_SOCKET){
+            perror("netperf: send_tcp_stream: tcp stream data socket");
+            exit(1);
+        }
+
+        if (debug) {
+            fprintf(where,"send_tcp_stream: send_socket obtained...\n");
+        }
+
+        /* at this point, we have either retrieved the socket buffer sizes, */
+        /* or have tried to set them, so now, we may want to set the send */
+        /* size based on that (because the user either did not use a -m */
+        /* option, or used one with an argument of 0). If the socket buffer */
+        /* size is not available, we will set the send size to 4KB - no */
+        /* particular reason, just arbitrary... */
+        if (send_size == 0) {
+            if (lss_size > 0) {
+                send_size = lss_size;
+            }
+            else {
+                send_size = 4096;
+            }
+        }
+
+        /* set-up the data buffer ring with the requested alignment and offset. */
+        /* note also that we have allocated a quantity */
+        /* of memory that is at least one send-size greater than our socket */
+        /* buffer size. We want to be sure that there are at least two */
+        /* buffers allocated - this can be a bit of a problem when the */
+        /* send_size is bigger than the socket size, so we must check... the */
+        /* user may have wanted to explicitly set the "width" of our send */
+        /* buffers, we should respect that wish... */
+        if (send_width == 0) {
+            send_width = (lss_size/send_size) + 1;
+            if (send_width == 1) send_width++;
+        }
+
+        if (send_ring == NULL) {
+            /* only allocate the send ring once. this is a networking test, */
+            /* not a memory allocation test. this way, we do not need a */
+            /* deallocate_buffer_ring() routine, and I don't feel like */
+            /* writing one anyway :) raj 11/94 */
+            send_ring = allocate_exs_buffer_ring(send_width,
+                                                 send_size,
+                                                 local_send_align,
+                                                 local_send_offset,
+                                                 &exs_mhandle);
+        }
+
+        /* If the user has requested cpu utilization measurements, we must */
+        /* calibrate the cpu(s). We will perform this task within the tests */
+        /* themselves. If the user has specified the cpu rate, then */
+        /* calibrate_local_cpu will return rather quickly as it will have */
+        /* nothing to do. If local_cpu_rate is zero, then we will go through */
+        /* all the "normal" calibration stuff and return the rate back. */
+
+        if (local_cpu_usage) {
+            local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+        }
+
+        /* Tell the remote end to do a listen. The server alters the socket */
+        /* paramters on the other side at this point, hence the reason for */
+        /* all the values being passed in the setup message. If the user did */
+        /* not specify any of the parameters, they will be passed as 0, which */
+        /* will indicate to the remote that no changes beyond the system's */
+        /* default should be used. Alignment is the exception, it will */
+        /* default to 1, which will be no alignment alterations. */
+
+        netperf_request.content.request_type =   DO_TCP_STREAM;
+        tcp_stream_request->send_buf_size   =   rss_size_req;
+        tcp_stream_request->recv_buf_size   =   rsr_size_req;
+        tcp_stream_request->receive_size   =   recv_size;
+        tcp_stream_request->no_delay   =   rem_nodelay;
+        tcp_stream_request->recv_alignment   =   remote_recv_align;
+        tcp_stream_request->recv_offset   =   remote_recv_offset;
+        tcp_stream_request->measure_cpu   =   remote_cpu_usage;
+        tcp_stream_request->cpu_rate   =   remote_cpu_rate;
+        if (test_time) {
+            tcp_stream_request->test_length   =   test_time;
+        }
+        else {
+            tcp_stream_request->test_length   =   test_bytes;
+        }
+        tcp_stream_request->so_rcvavoid   =   rem_rcvavoid;
+        tcp_stream_request->so_sndavoid   =   rem_sndavoid;
+#ifdef DIRTY
+        tcp_stream_request->dirty_count     =       rem_dirty_count;
+        tcp_stream_request->clean_count     =       rem_clean_count;
+#endif /* DIRTY */
+        tcp_stream_request->port            =    atoi(remote_data_port);
+        tcp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
+        if (debug > 1) {
+            fprintf(where,
+                    "netperf: send_tcp_stream: 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");
+            rsr_size         =   tcp_stream_response->recv_buf_size;
+            rss_size         =   tcp_stream_response->send_buf_size;
+            rem_nodelay     =   tcp_stream_response->no_delay;
+            remote_cpu_usage=   tcp_stream_response->measure_cpu;
+            remote_cpu_rate = tcp_stream_response->cpu_rate;
+
+            /* we have to make sure that the server port number is in */
+            /* network order */
+            set_port_number(remote_res,(short)tcp_stream_response->data_port_number);
+
+            rem_rcvavoid   = tcp_stream_response->so_rcvavoid;
+            rem_sndavoid   = tcp_stream_response->so_sndavoid;
+        }
+        else {
+            Set_errno(netperf_response.content.serv_errno);
+            fprintf(where,
+                    "netperf: remote error %d",
+                    netperf_response.content.serv_errno);
+            perror("");
+            fflush(where);
+
+            exit(1);
+        }
+
+#if 0 /* def WANT_DEMO */
+        DEMO_STREAM_SETUP(lss_size,rsr_size)
+#endif
+
+            /*Connect up to the remote port on the data socket  */
+            if (connect(send_socket,
+                        remote_res->ai_addr,
+                        remote_res->ai_addrlen) == INVALID_SOCKET){
+                perror("netperf: send_tcp_stream: data socket connect failed");
+                exit(1);
+            }
+
+        /* Data Socket set-up is finished. If there were problems, either */
+        /* the connect would have failed, or the previous response would */
+        /* have indicated a problem. I failed to see the value of the */
+        /* extra  message after the accept on the remote. If it failed, */
+        /* we'll see it here. If it didn't, we might as well start pumping */
+        /* data. */
+
+        /* Set-up the test end conditions. For a 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;
+            /* in previous revisions, we had the same code repeated throught */
+            /* all the test suites. this was unnecessary, and meant more */
+            /* work for me when I wanted to switch to POSIX signals, so I */
+            /* have abstracted this out into a routine in netlib.c. if you */
+            /* are experiencing signal problems, you might want to look */
+            /* there. raj 11/94 */
+            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);
+
+#if 0 /* def WANT_INTERVALS */
+	INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+        /* before we start, initialize a few variables */
+
+#if 0 /* def WANT_DEMO */
+        if (demo_mode) {
+            HIST_timestamp(demo_one_ptr);
+        }
+#endif
+
+
+        /* 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. */
+
+        exs_aio_pending = 0;
+        exs_aio_eagain = 0;
+        exs_aio_dequeuecnt = 0;
+
+        while ((!times_up) || (bytes_remaining > 0)) {
+
+#ifdef DIRTY
+	  access_buffer(send_ring->buffer_ptr,
+			send_size,
+			loc_dirty_count,
+			loc_clean_count);
+#endif /* DIRTY */
+
+#if 0 /* def WANT_HISTOGRAM */
+            /* timestamp just before we go into send and then again just after */
+            /* we come out raj 8/94 */
+            HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+
+
+            /* post up to NETPERF_EXS_PENDING I/Os  */
+            while ((exs_aio_pending < NETPERF_EXS_PENDING) &&
+                   (exs_send (send_socket, send_ring->buffer_ptr, send_size,
+                              0, exs_qhandle, (exs_ahandle_t)-1, exs_mhandle) == 0)) {
+                exs_aio_pending++;
+
+                /* now we want to move our pointer to the next
+		   position in the data buffer...we may also want to
+		   wrap back to the "beginning" of the bufferspace, so
+		   we will mod the number of messages sent by the send
+		   width, and use that to calculate the offset to add
+		   to the base pointer. */
+
+                nummessages++;
+                send_ring = send_ring->next;
+                if (bytes_remaining) {
+                    bytes_remaining -= send_size;
+                }
+            }
+
+            /* check exs_send result */
+            if (exs_aio_pending < NETPERF_EXS_PENDING) {
+               /* standard flow control case */
+                if (errno == EAGAIN)
+                    exs_aio_eagain++;
+                /* case of times_up */
+                else if (errno == EINTR)
+                    break;
+                /* strange, let's stop */
+                else {
+                    perror ("netperf: exs_send error");
+                    exit (1);
+                }
+            }
+
+            /* dequeue events with "threshold" on 1/2 posted */
+            exs_aio_dequeued =
+                exs_qdequeue (exs_qhandle, exs_evtvec,
+                              -(exs_aio_pending>>1), NULL);
+            exs_aio_dequeuecnt++;
+
+            /* check exs_dequeue result */
+            if (exs_aio_dequeued < 0) {
+                /* case of times_up */
+                if (errno == EINTR)
+                    break;
+                /* strange, let's stop */
+                else {
+                    perror ("netperf: exs_send error");
+                    exit (1);
+                }
+            }
+            /* update number of pending I/Os */
+            else {
+                exs_aio_pending -= exs_aio_dequeued;
+            }
+
+
+#if 0 /* def WANT_HISTOGRAM */
+            /* timestamp the exit from the send call and update the histogram */
+            HIST_timestamp(&time_two);
+            HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */
+
+#if 0 /* def WANT_DEMO */
+            DEMO_STREAM_INTERVAL(send_size);
+#endif
+
+#if 0 /* def WANT_INTERVALS */
+	    INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+
+        }
+
+        /* Collect the last completion events */
+        exs_aio_dequeued =
+            exs_qdequeue (exs_qhandle, exs_evtvec, -exs_aio_pending, NULL);
+        exs_aio_dequeuecnt++;
+        /* check exs_dequeue result and update number of pending I/Os */
+        if (exs_aio_dequeued < 0) {
+            perror ("netperf: exs_send error");
+            exit (1);
+        }
+        exs_aio_pending -= exs_aio_dequeued;
+
+        /* Display some async I/O debug info */
+        if (debug) {
+            fprintf (where, "send_exs_tcp_stream: "
+                     "aio sent=%d eagain=%d dequeue=%d pending=%d\n",
+                     nummessages, exs_aio_eagain, exs_aio_dequeuecnt, exs_aio_pending);
+        }
+
+        /* 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. */
+
+        /* but first, if the verbosity is greater than 1, find-out what */
+        /* the TCP maximum segment_size was (if possible) */
+        if (verbosity > 1) {
+            tcp_mss = -1;
+            get_tcp_info(send_socket,&tcp_mss);
+        }
+
+        if (shutdown(send_socket,SHUT_WR) == SOCKET_ERROR) {
+            perror("netperf: cannot shutdown tcp stream socket");
+            exit(1);
+        }
+
+        /* hang a recv() off the socket to block until the remote has */
+        /* brought all the data up into the application. it will do a */
+        /* shutdown to cause a FIN to be sent our way. We will assume that */
+        /* any exit from the recv() call is good... raj 4/93 */
+
+        recv(send_socket, send_ring->buffer_ptr, send_size, 0);
+
+        /* this call will always give us the elapsed time for the test, and */
+        /* will also store-away the necessaries for cpu utilization */
+
+        cpu_stop(local_cpu_usage,&elapsed_time);   /* was cpu being */
+        /* measured and how */
+        /* long did we really */
+        /* run? */
+
+        /* we are finished with the socket, so close it to prevent hitting */
+        /* the limit on maximum open files. */
+
+        close(send_socket);
+
+        /* 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);
+            fprintf(where,
+                    "netperf: remote error %d",
+                    netperf_response.content.serv_errno);
+            perror("");
+            fflush(where);
+
+            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   = ntohd(tcp_stream_result->bytes_received);
+
+        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) {
+
+                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   = (float) -1.0;
+                local_service_demand   = (float) -1.0;
+            }
+
+            if (remote_cpu_usage) {
+
+                remote_cpu_utilization   = tcp_stream_result->cpu_util;
+                remote_service_demand   = calc_service_demand(bytes_sent,
+                                                              0.0,
+                                                              remote_cpu_utilization,
+                                                              tcp_stream_result->num_cpus);
+            }
+            else {
+                remote_cpu_utilization = (float) -1.0;
+                remote_service_demand  = (float) -1.0;
+            }
+        }
+        else {
+            /* we were not measuring cpu, for the confidence stuff, we */
+            /* should make it -1.0 */
+            local_cpu_utilization   = (float) -1.0;
+            local_service_demand   = (float) -1.0;
+            remote_cpu_utilization = (float) -1.0;
+            remote_service_demand  = (float) -1.0;
+        }
+
+        /* at this point, we want to calculate the confidence information. */
+        /* if debugging is on, calculate_confidence will print-out the */
+        /* parameters we pass it */
+
+        calculate_confidence(confidence_iteration,
+                             elapsed_time,
+                             thruput,
+                             local_cpu_utilization,
+                             remote_cpu_utilization,
+                             local_service_demand,
+                             remote_service_demand);
+
+
+        confidence_iteration++;
+    }
+
+    /* at this point, we have finished making all the runs that we */
+    /* will be making. so, we should extract what the calcuated values */
+    /* are for all the confidence stuff. we could make the values */
+    /* global, but that seemed a little messy, and it did not seem worth */
+    /* all the mucking with header files. so, we create a routine much */
+    /* like calcualte_confidence, which just returns the mean values. */
+    /* raj 11/94 */
+
+    retrieve_confident_values(&elapsed_time,
+                              &thruput,
+                              &local_cpu_utilization,
+                              &remote_cpu_utilization,
+                              &local_service_demand,
+                              &remote_service_demand);
+
+    /* 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...  */
+
+    if (confidence < 0) {
+        /* we did not hit confidence, but were we asked to look for it? */
+        if (iteration_max > 1) {
+            display_confidence();
+        }
+    }
+
+    if (local_cpu_usage || remote_cpu_usage) {
+        local_cpu_method = format_cpu_method(cpu_method);
+        remote_cpu_method = format_cpu_method(tcp_stream_result->cpu_method);
+
+        switch (verbosity) {
+            case 0:
+                if (local_cpu_usage) {
+                    fprintf(where,
+                            cpu_fmt_0,
+                            local_service_demand,
+                            local_cpu_method);
+                }
+                else {
+                    fprintf(where,
+                            cpu_fmt_0,
+                            remote_service_demand,
+                            remote_cpu_method);
+                }
+                break;
+            case 1:
+            case 2:
+                if (print_headers) {
+                    fprintf(where,
+                            cpu_title,
+                            format_units(),
+                            local_cpu_method,
+                            remote_cpu_method);
+                }
+
+                fprintf(where,
+                        cpu_fmt_1,      /* the format string */
+                        rsr_size,              /* remote recvbuf size */
+                        lss_size,              /* local sendbuf size */
+                        send_size,      /* how large were the sends */
+                        elapsed_time,      /* how long was the test */
+                        thruput,               /* what was the xfer rate */
+                        local_cpu_utilization,   /* local cpu */
+                        remote_cpu_utilization,   /* remote cpu */
+                        local_service_demand,   /* local service demand */
+                        remote_service_demand);   /* remote service demand */
+                break;
+        }
+    }
+    else {
+        /* The tester did not wish to measure service demand. */
+
+        switch (verbosity) {
+            case 0:
+                fprintf(where,
+                        tput_fmt_0,
+                        thruput);
+                break;
+            case 1:
+            case 2:
+                if (print_headers) {
+                    fprintf(where,tput_title,format_units());
+                }
+                fprintf(where,
+                        tput_fmt_1,      /* the format string */
+                        rsr_size,       /* remote recvbuf size */
+                        lss_size,       /* local sendbuf size */
+                        send_size,      /* how large were the sends */
+                        elapsed_time,       /* how long did it take */
+                        thruput);/* how fast did it go */
+                break;
+        }
+    }
+
+    /* it would be a good thing to include information about some of the */
+    /* other parameters that may have been set for this test, but at the */
+    /* moment, I do not wish to figure-out all the  formatting, so I will */
+    /* just put this comment here to help remind me that it is something */
+    /* that should be done at a later time. */
+
+    if (verbosity > 1) {
+        /* The user wanted to know it all, so we will give it to him. */
+        /* This information will include as much as we can find about */
+        /* TCP statistics, the alignments of the sends and receives */
+        /* and all that sort of rot... */
+
+        /* this stuff needs to be worked-out in the presence of confidence */
+        /* intervals and multiple iterations of the test... raj 11/94 */
+
+        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)tcp_stream_result->recv_calls,
+                tcp_stream_result->recv_calls);
+        fprintf(where,
+                ksink_fmt2,
+                tcp_mss);
+        fflush(where);
+#if 0 /* def WANT_HISTOGRAM */
+        fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+        fflush(where);
+        HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+    }
+
+}
+
+#endif /* HAVE_ICSC_EXS */
+
+
+
+#if defined(HAVE_SENDFILE) 
+
+#if defined(QUICK_SENDPATH)
+
+/*
+ * a temporary stub for the sendpath() system call
+ * which is defined & implemented in the kernel
+ * but which has no libc stub.
+ */
+#include <sys/types.h>
+#include <sys/scall_define.h>
+#include <sys/uio.h>
+
+ssize_t
+sendpath(int s, char *path, off_t offset, size_t nbytes,
+	 const struct iovec *hdtrl, int flags)
+  {
+    return syscall(SYS_sendpath, s, path, offset, nbytes, hdtrl, flags);
+  }
+#endif /* QUICK_SENDPATH */
+
+/* This routine implements the TCP unidirectional data transfer test
+   (a.k.a. stream) for the sockets interface using the sendfile()
+   system call - TCP_SENDFILE.  It receives its  parameters via global
+   variables from the shell and writes its  output to the standard
+   output. Basically,  this is the same test as the send_tcp_stream()
+   logic and we even tell the remote to do a TCP_STREAM test since for 
+   all it knows, nothig is different. */
+
+void 
+sendfile_tcp_stream(remote_host)
+     char	remote_host[];
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   \n";
+
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  char *cpu_fmt_1 =
+    "%6d %6d %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";
+
+char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+
+  float			elapsed_time;
+  
+  /* 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 sendfile_ring_elt *send_ring;
+  
+  int len;
+  unsigned int nummessages = 0;
+  SOCKET send_socket;
+  int bytes_remaining;
+  int tcp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+  double	bytes_sent = 0.0;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct  addrinfo *remote_res;
+  struct  addrinfo *local_res;
+  struct	sockaddr_in	server;
+
+#if defined(__linux) || defined(__sun__)
+  off_t     scratch_offset;   /* the linux sendfile() call will update
+				 the offset variable, which is
+				 something we do _not_ want to happen
+				 to the value in the send_ring! so, we
+				 have to use a scratch variable. */
+#endif /* __linux  || defined(__sun__) */
+#if defined (USE_OSX)
+   off_t    scratch_len;  /* Darwin 9.x need a value-result parameter  */
+#endif
+#if defined (__sun__)
+   size_t  scratch_len;	/* the sun sendfilev() needs a place to 
+			   tell us how many bytes were written,
+			   even though it also returns the value */
+   sendfilevec_t sv;
+#endif /* __sun__ */
+  
+  struct	tcp_stream_request_struct	*tcp_stream_request;
+  struct	tcp_stream_response_struct	*tcp_stream_response;
+  struct	tcp_stream_results_struct	*tcp_stream_result;
+
+  tcp_stream_request  = 
+    (struct tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+  tcp_stream_response =
+    (struct tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+  tcp_stream_result   = 
+    (struct tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    /* we want to have some additional, interesting information in */
+    /* the headers. we know some of it here, but not all, so we will */
+    /* only print the test title here and will print the results */
+    /* titles after the test is finished */
+#ifdef QUICK_SENDPATH
+    print_top_test_header("TCP SENDPATH TEST",local_res,remote_res);
+#else
+    print_top_test_header("TCP SENDFILE TEST",local_res,remote_res);
+#endif /* QUICK_SENDPATH */
+  }
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+  
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+    
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /* set up the data socket */
+    send_socket = create_data_socket(local_res);
+
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: sendfile_tcp_stream: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"sendfile_tcp_stream: send_socket obtained...\n");
+    }
+    
+#if defined(TCP_CORK)
+    /* should this even be here?!? */
+    if (loc_tcpcork != 0) {
+      /* the user wishes for us to set TCP_CORK on the socket */
+      int one = 1;
+      if (setsockopt(send_socket,
+		     getprotobyname("tcp")->p_proto,
+		     TCP_CORK,
+		     (char *)&one,
+		     sizeof(one)) == SOCKET_ERROR) {
+	perror("netperf: sendfile_tcp_stream: tcp_cork");
+	exit(1);
+      }
+      if (debug) {
+	fprintf(where,"sendfile_tcp_stream: tcp_cork...\n");
+      }
+    }
+    
+#endif /* TCP_CORK */    
+
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+
+    /*check for file size/ min file size here?  create file here/ back out???*/
+    
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+   
+    /* set-up the data buffer ring with the requested alignment and
+       offset. note also that we have allocated a quantity  of memory
+       that is at least one send-size greater than our socket  buffer
+       size. We want to be sure that there are at least two  buffers
+       allocated - this can be a bit of a problem when the  send_size
+       is bigger than the socket size, so we must check... the  user
+       may have wanted to explicitly set the "width" of our send
+       buffers, we should respect that wish... */ 
+
+    /*sendring -> an offset index that will shift the starting point of the*/
+    /*section of the file sent throughout the file*/
+    
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) { 
+
+      /* only allocate the send ring once. this is a networking test,
+	 not a memory allocation test. this way, we do not need a
+	 deallocate_buffer_ring() routine, and I don't feel like
+	 writing one anyway :) raj 11/94 */ 
+      
+      send_ring = alloc_sendfile_buf_ring(send_width,
+					  send_size,
+					  local_send_align,
+					  local_send_offset);
+    }
+	
+    /* If the user has requested cpu utilization measurements, we must
+       calibrate the cpu(s). We will perform this task within the
+       tests  themselves. If the user has specified the cpu rate, then
+       calibrate_local_cpu will return rather quickly as it will have
+       nothing to do. If local_cpu_rate is zero, then we will go
+       through  all the "normal" calibration stuff and return the rate
+       back. */ 
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+
+    /* Tell the remote end to do a listen. The server alters the
+       socket  paramters on the other side at this point, hence the
+       reason for  all the values being passed in the setup
+       message. If the user did  not specify any of the parameters,
+       they will be passed as 0, which  will indicate to the remote
+       that no changes beyond the system's  default should be
+       used. Alignment is the exception, it will  default to 1, which
+       will be no alignment alterations. */ 
+
+    netperf_request.content.request_type =	DO_TCP_STREAM;
+    tcp_stream_request->send_buf_size	=	rss_size_req;
+    tcp_stream_request->recv_buf_size	=	rsr_size_req;
+    tcp_stream_request->receive_size	=	recv_size;
+    tcp_stream_request->no_delay	=	rem_nodelay;
+    tcp_stream_request->recv_alignment	=	remote_recv_align;
+    tcp_stream_request->recv_offset	=	remote_recv_offset;
+    tcp_stream_request->measure_cpu	=	remote_cpu_usage;
+    tcp_stream_request->cpu_rate	=	remote_cpu_rate;
+
+    if (test_time) {
+      tcp_stream_request->test_length	=	test_time;
+    }
+    else {
+      tcp_stream_request->test_length	=	test_bytes;
+    }
+
+    tcp_stream_request->so_rcvavoid	=	rem_rcvavoid;
+    tcp_stream_request->so_sndavoid	=	rem_sndavoid;
+
+#ifdef DIRTY
+    tcp_stream_request->dirty_count       =       rem_dirty_count;
+    tcp_stream_request->clean_count       =       rem_clean_count;
+#endif /* DIRTY */
+    tcp_stream_request->port     = atoi(remote_data_port);
+    tcp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
+
+    if (debug > 1) {
+      fprintf(where,
+	      "netperf: send_tcp_stream: 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");
+      rsr_size	      =	tcp_stream_response->recv_buf_size;
+      rss_size	      =	tcp_stream_response->send_buf_size;
+      rem_nodelay     =	tcp_stream_response->no_delay;
+      remote_cpu_usage=	tcp_stream_response->measure_cpu;
+      remote_cpu_rate = tcp_stream_response->cpu_rate;
+
+      /* we have to make sure that the server port number is in */
+      /* network order */
+      set_port_number(remote_res,(short)tcp_stream_response->data_port_number);
+      rem_rcvavoid	= tcp_stream_response->so_rcvavoid;
+      rem_sndavoid	= tcp_stream_response->so_sndavoid;
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lss_size,rsr_size)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: send_tcp_stream: data socket connect failed");
+      printf(" port: %d\n",ntohs(server.sin_port));
+      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;
+
+      /* in previous revisions, we had the same code repeated throught
+         all the test suites. this was unnecessary, and meant more
+         work for me when I wanted to switch to POSIX signals, so I
+         have abstracted this out into a routine in netlib.c. if you
+         are experiencing signal problems, you might want to look
+         there. raj 11/94 */
+
+      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);
+    
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+   
+    /* before we start, initialize a few variables */
+
+#ifdef WANT_DEMO
+    if (demo_mode) {
+      HIST_timestamp(demo_one_ptr);
+    }
+#endif
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+      /* the sendfile_tcp_stream test does not support making the buffers
+	 dirty. 08/2000 */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before we go into sendfile() and then again
+         just after we come out raj 08/2000 */
+	/* but only if we are actually going to display a histogram */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+      
+      /* you can look at netlib.h for a description of the fields we
+	 are passing to sendfile(). 08/2000 */
+#ifdef QUICK_SENDPATH
+      if ((len=sendpath(send_socket, 
+			fill_file,
+			send_ring->offset,
+			send_ring->length,
+			send_ring->hdtrl,
+			send_ring->flags)) != send_size)
+#elif defined(__linux)
+	scratch_offset = send_ring->offset;
+      if ((len=sendfile(send_socket, 
+			send_ring->fildes, 
+			&scratch_offset,   /* modified after the call! */
+			send_ring->length)) != send_size)
+#elif defined (__sun__)
+      /* We must call with SFV_NOWAIT and a large file size (>= 16MB) to
+	 get zero-copy, as well as compiling with  -D_LARGEFILE_SOURCE
+	  -D_FILE_OFFSET_BITS=64 */
+      sv.sfv_fd = send_ring->fildes;
+      sv.sfv_flag = SFV_NOWAIT;
+      sv.sfv_off = send_ring->offset;
+      sv.sfv_len =  send_ring->length;
+      if ((len = sendfilev(send_socket, &sv, 1, &scratch_len)) != send_size)
+#elif defined(__FreeBSD__)
+	/* so close to HP-UX and yet so far away... :) */
+	if ((sendfile(send_ring->fildes, 
+		      send_socket, 
+		      send_ring->offset,
+		      send_ring->length,
+		      NULL,
+		      (off_t *)&len,
+		      send_ring->flags) != 0) ||
+	    (len != send_size))
+#elif defined(USE_OSX)
+    scratch_len = send_ring->length;
+    if ((sendfile(send_ring->fildes,
+              send_socket,
+              send_ring->offset,
+              (off_t *)&scratch_len,
+              NULL,
+              send_ring->flags) != 0) ||
+        (scratch_len != send_size))
+#else /* original sendile HP-UX */
+	  if ((len=sendfile(send_socket, 
+			    send_ring->fildes, 
+			    send_ring->offset,
+			    send_ring->length,
+			    send_ring->hdtrl,
+			    send_ring->flags)) != send_size)
+#endif /* QUICK_SENDPATH */
+	    {
+	      /* the test was interrupted, must be the end of test. the
+		 send_tcp_stream code has some WIN32 ifdefs that we do not
+		 need here. */
+	      if ((len >=0) || SOCKET_EINTR(len)) {
+		break;
+	      }
+	      perror("netperf: data send error: sendfile");
+	      fprintf(stderr,
+		      "len was %d send_size was %d\n",
+		      len,
+		      send_size);
+	      fflush(stderr);
+	      exit(1);
+	    }
+      
+      /*	offset += len;*/
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp the exit from the send call and update the
+	   histogram */
+      
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */      
+    
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(send_size);
+#endif 
+  
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+
+      nummessages++;          
+      send_ring = send_ring->next; 
+      if (bytes_remaining) {
+	bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a
+       graceful release to insure that all data has been taken by the
+       remote. */
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the TCP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      tcp_mss = -1;
+      get_tcp_info(send_socket,&tcp_mss);
+    }
+    
+    if (shutdown(send_socket,SHUT_WR) == SOCKET_ERROR) {
+      perror("netperf: cannot shutdown tcp stream socket");
+      exit(1);
+    }
+    
+    /* hang a recv() off the socket to block until the remote has */
+    /* brought all the data up into the application. it will do a */
+    /* shutdown to cause a FIN to be sent our way. We will assume that */
+    /* any exit from the recv() call is good... raj 4/93 */
+
+    /* since we are using sendfile() instead of send, we have no
+       scratch buffer from the send_ring to use for the
+       receive. however, since we "know" that the recv should be
+       returning zero bytes (not that we are making the checks we
+       should) we can pass the address of the flags field. raj 08/2000 
+    */
+
+    recv(send_socket,
+	 &(send_ring->flags), 
+	 sizeof(send_ring->flags),
+	 0);
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+
+    close(send_socket);
+
+    /* 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);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      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	= ntohd(tcp_stream_result->bytes_received);
+    
+    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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= tcp_stream_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      tcp_stream_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(tcp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+
+    if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+
+      break;
+
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+
+  }
+
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+ 
+    case 0:
+
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+
+    case 1:
+    case 2:
+
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);/* how fast did it go */
+      break;
+    }
+  }
+
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+    if (verbosity > 1) {
+
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)tcp_stream_result->recv_calls,
+	    tcp_stream_result->recv_calls);
+
+    fprintf(where,
+	    ksink_fmt2,
+	    tcp_mss);
+
+    fflush(where);
+
+#ifdef WANT_HISTOGRAM
+
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+}
+
+#endif /* HAVE_SENDFILE */
+
+/* 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. */
+
+void
+recv_tcp_stream()
+{
+  
+  struct sockaddr_storage myaddr_in, peeraddr_in;
+  SOCKET s_listen,s_data;
+  netperf_socklen_t addrlen;
+  int	len;
+  unsigned int	receive_calls;
+  float	elapsed_time;
+  double   bytes_received;
+  
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+#ifdef DO_SELECT
+  fd_set readfds;
+  struct timeval timeout;
+#endif /* DO_SELECT */
+
+  struct	tcp_stream_request_struct	*tcp_stream_request;
+  struct	tcp_stream_response_struct	*tcp_stream_response;
+  struct	tcp_stream_results_struct	*tcp_stream_results;
+  
+#ifdef DO_SELECT
+  FD_ZERO(&readfds);
+  timeout.tv_sec = 1;
+  timeout.tv_usec = 0;
+#endif /* DO_SELECT */
+
+  tcp_stream_request	= 
+    (struct tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+  tcp_stream_response	= 
+    (struct tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+  tcp_stream_results	= 
+    (struct tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_STREAM_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_stream: requested alignment of %d\n",
+	    tcp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_stream_request->send_buf_size;
+  lsr_size_req = tcp_stream_request->recv_buf_size;
+  loc_nodelay  = tcp_stream_request->no_delay;
+  loc_rcvavoid = tcp_stream_request->so_rcvavoid;
+  loc_sndavoid = tcp_stream_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_stream_request->ipfamily),
+			tcp_stream_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_stream_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+  
+  /* what sort of sizes did we end-up with? */
+  if (tcp_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = tcp_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   tcp_stream_request->recv_alignment,
+				   tcp_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_tcp_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_stream_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  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. */
+  
+  tcp_stream_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (tcp_stream_request->measure_cpu) {
+    tcp_stream_response->measure_cpu = 1;
+    tcp_stream_response->cpu_rate = 
+      calibrate_local_cpu(tcp_stream_request->cpu_rate);
+  }
+  else {
+    tcp_stream_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_stream_response->send_buf_size = lss_size;
+  tcp_stream_response->recv_buf_size = lsr_size;
+  tcp_stream_response->no_delay = loc_nodelay;
+  tcp_stream_response->so_rcvavoid = loc_rcvavoid;
+  tcp_stream_response->so_sndavoid = loc_sndavoid;
+  tcp_stream_response->receive_size = recv_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  if ((s_data=accept(s_listen,
+		     (struct sockaddr *)&peeraddr_in,
+		     &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_stream_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  /* there used to be an #ifdef DIRTY call to access_buffer() here,
+     but we have switched from accessing the buffer before the recv()
+     call to accessing the buffer after the recv() call.  The
+     accessing before was, IIRC, related to having dirty data when
+     doing page-flipping copy avoidance. */
+
+  bytes_received = 0;
+  receive_calls  = 0;
+
+  while ((len = recv(s_data, recv_ring->buffer_ptr, recv_size, 0)) != 0) {
+    if (len == SOCKET_ERROR )
+	{
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    bytes_received += len;
+    receive_calls++;
+
+#ifdef DIRTY
+    /* we access the buffer after the recv() call now, rather than before */
+    access_buffer(recv_ring->buffer_ptr,
+		  recv_size,
+		  tcp_stream_request->dirty_count,
+		  tcp_stream_request->clean_count);
+#endif /* DIRTY */
+
+
+    /* move to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+
+#ifdef PAUSE
+    sleep(1);
+#endif /* PAUSE */
+
+#ifdef DO_SELECT
+	FD_SET(s_data,&readfds);
+	select(s_data+1,&readfds,NULL,NULL,&timeout);
+#endif /* DO_SELECT */
+
+  }
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (shutdown(s_data,SHUT_WR) == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+  
+  cpu_stop(tcp_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_stream: got %g bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_tcp_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  tcp_stream_results->bytes_received	= htond(bytes_received);
+  tcp_stream_results->elapsed_time	= elapsed_time;
+  tcp_stream_results->recv_calls	= receive_calls;
+  
+  tcp_stream_results->cpu_method = cpu_method;
+  tcp_stream_results->num_cpus   = lib_num_loc_cpus;
+  
+  if (tcp_stream_request->measure_cpu) {
+    tcp_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_stream: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_received %g receive_calls %d\n",
+	    bytes_received,
+	    receive_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+
+  send_response();
+
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  }
+
+/* This is the server-side routine for the tcp maerts test. It is
+   implemented as one routine. I could break things-out somewhat, but
+   didn't feel it was necessary. */ 
+
+void
+recv_tcp_maerts()
+{
+  
+  struct sockaddr_storage myaddr_in, peeraddr_in;
+  struct addrinfo *local_res;
+  char  local_name[BUFSIZ];
+  char  port_buffer[PORTBUFSIZE];
+
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  int	len;
+  unsigned int	send_calls;
+  float	elapsed_time;
+  double   bytes_sent = 0.0 ;
+  
+  struct ring_elt *send_ring;
+
+  struct	tcp_maerts_request_struct	*tcp_maerts_request;
+  struct	tcp_maerts_response_struct	*tcp_maerts_response;
+  struct	tcp_maerts_results_struct	*tcp_maerts_results;
+  
+  tcp_maerts_request	= 
+    (struct tcp_maerts_request_struct *)netperf_request.content.test_specific_data;
+  tcp_maerts_response	= 
+    (struct tcp_maerts_response_struct *)netperf_response.content.test_specific_data;
+  tcp_maerts_results	= 
+    (struct tcp_maerts_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_maerts: 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_tcp_maerts: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_MAERTS_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_maerts: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_maerts: requested alignment of %d\n",
+	    tcp_maerts_request->send_alignment);
+    fflush(where);
+  }
+
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_maerts: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_maerts_request->send_buf_size;
+  lsr_size_req = tcp_maerts_request->recv_buf_size;
+  loc_nodelay = tcp_maerts_request->no_delay;
+  loc_rcvavoid = tcp_maerts_request->so_rcvavoid;
+  loc_sndavoid = tcp_maerts_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_maerts_request->ipfamily),
+			tcp_maerts_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_maerts_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+  
+  /* what sort of sizes did we end-up with? */
+  if (tcp_maerts_request->send_size == 0) {
+    if (lss_size > 0) {
+      send_size = lss_size;
+    }
+    else {
+      send_size = 4096;
+    }
+  }
+  else {
+    send_size = tcp_maerts_request->send_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the recving side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (send_width == 0) {
+    send_width = (lsr_size/send_size) + 1;
+    if (send_width == 1) send_width++;
+  }
+
+  send_ring = allocate_buffer_ring(send_width,
+				   send_size,
+				   tcp_maerts_request->send_alignment,
+				   tcp_maerts_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_tcp_maerts: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_maerts_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  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. */
+  
+  tcp_maerts_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (tcp_maerts_request->measure_cpu) {
+    tcp_maerts_response->measure_cpu = 1;
+    tcp_maerts_response->cpu_rate = 
+      calibrate_local_cpu(tcp_maerts_request->cpu_rate);
+  }
+  else {
+    tcp_maerts_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_maerts_response->send_buf_size = lss_size;
+  tcp_maerts_response->recv_buf_size = lsr_size;
+  tcp_maerts_response->no_delay = loc_nodelay;
+  tcp_maerts_response->so_rcvavoid = loc_rcvavoid;
+  tcp_maerts_response->so_sndavoid = loc_sndavoid;
+  tcp_maerts_response->send_size = send_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+
+  /* we will start the timer before the accept() to be somewhat
+     analagous to the starting of the timer before the connect() call
+     in the TCP_STREAM test. raj 2002-06-21 */
+
+  start_timer(tcp_maerts_request->test_length);
+
+  /* Now it's time to start receiving data on the connection. We will
+     first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_maerts_request->measure_cpu);
+  
+
+  if ((s_data=accept(s_listen,
+		     (struct sockaddr *)&peeraddr_in,
+		     &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  
+  /* this is for those systems which *INCORRECTLY* fail to pass
+     attributes across an accept() call. Including this goes against
+     my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  bytes_sent = 0.0;
+  send_calls  = 0;
+
+  len = 0;   /* nt-lint; len is not initialized (printf far below) if
+		times_up initially true.*/
+  times_up = 0; /* must remember to initialize this little beauty */
+  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. */
+
+  access_buffer(send_ring->buffer_ptr,
+		send_size,
+		tcp_maerts_request->dirty_count,
+		tcp_maerts_request->clean_count);
+
+#endif /* DIRTY */
+
+    if((len=send(s_data,
+		 send_ring->buffer_ptr,
+		 send_size,
+		 0)) != send_size) {
+		if ((len >=0) || SOCKET_EINTR(len)) {
+	      /* the test was interrupted, must be the end of test */
+	      break;
+		}
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+
+    bytes_sent += len;
+    send_calls++;
+
+    /* more to the next buffer in the send_ring */
+    send_ring = send_ring->next;
+
+  }
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (shutdown(s_data,SHUT_WR) == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+
+  /* hang a recv() off the socket to block until the remote has
+     brought all the data up into the application. it will do a
+     shutdown to cause a FIN to be sent our way. We will assume that
+     any exit from the recv() call is good... raj 4/93 */
+    
+  recv(s_data, send_ring->buffer_ptr, send_size, 0);
+    
+  
+  cpu_stop(tcp_maerts_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_maerts: got %g bytes\n",
+	    bytes_sent);
+    fprintf(where,
+	    "recv_tcp_maerts: got %d sends\n",
+	    send_calls);
+    fflush(where);
+  }
+  
+  tcp_maerts_results->bytes_sent	= htond(bytes_sent);
+  tcp_maerts_results->elapsed_time	= elapsed_time;
+  tcp_maerts_results->send_calls	= send_calls;
+  
+  if (tcp_maerts_request->measure_cpu) {
+    tcp_maerts_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_maerts: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_sent %g send_calls %d\n",
+	    bytes_sent,
+	    send_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+  
+  tcp_maerts_results->cpu_method = cpu_method;
+  tcp_maerts_results->num_cpus   = lib_num_loc_cpus;
+  send_response();
+
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  }
+
+
+ /* this routine implements the sending (netperf) side of the TCP_RR */
+ /* test. */
+
+void
+send_tcp_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+
+  char *tput_title_band = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  \n\
+Send   Recv   Size     Size    Time     Throughput \n\
+bytes  Bytes  bytes    bytes   secs.    %s/sec   \n\n";
+
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   %s\n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+
+  char *cpu_title_tput = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Tput     CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    %-8.8s local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f %s\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset         RoundTrip  Trans    Throughput\n\
+Local  Remote  Local  Remote  Latency    Rate     %-8.8s/s\n\
+Send   Recv    Send   Recv    usec/Tran  per sec  Outbound   Inbound\n\
+%5d  %5d   %5d  %5d   %-6.3f   %-6.3f %-6.3f    %-6.3f\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+
+  struct	tcp_rr_request_struct	*tcp_rr_request;
+  struct	tcp_rr_response_struct	*tcp_rr_response;
+  struct	tcp_rr_results_struct	*tcp_rr_result;
+
+#ifdef WANT_FIRST_BURST
+#define REQUEST_CWND_INITIAL 2
+  /* "in the beginning..." the WANT_FIRST_BURST stuff was like both
+     Unix and the state of New Jersey - both were simple an unspoiled.
+     then it was realized that some stacks are quite picky about
+     initial congestion windows and a non-trivial initial burst of
+     requests would not be individual segments even with TCP_NODELAY
+     set. so, we have to start tracking a poor-man's congestion window
+     up here in window space because we want to try to make something
+     happen that frankly, we cannot guarantee with the specification
+     of TCP.  ain't that grand?-)  raj 2006-01-30 */
+  int requests_outstanding = 0;
+  int request_cwnd = REQUEST_CWND_INITIAL;  /* we ass-u-me that having
+					       three requests
+					       outstanding at the
+					       beginning of the test
+					       is ok with TCP stacks
+					       of interest. the first
+					       two will come from our
+					       first_burst loop, and
+					       the third from our
+					       regularly scheduled
+					       send */
+#endif
+
+  tcp_rr_request = 
+    (struct tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_rr_response=
+    (struct tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_rr_result	=
+    (struct tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("TCP REQUEST/RESPONSE TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+#ifdef WANT_FIRST_BURST
+    /* we have to remember to reset the number of transactions
+       outstanding and the "congestion window for each new
+       iteration. raj 2006-01-31 */
+    requests_outstanding = 0;
+    request_cwnd = REQUEST_CWND_INITIAL;
+#endif
+
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_tcp_rr: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_tcp_rr: send_socket obtained...\n");
+    }
+  
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back.*/
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* 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_TCP_RR;
+      tcp_rr_request->recv_buf_size	=	rsr_size_req;
+      tcp_rr_request->send_buf_size	=	rss_size_req;
+      tcp_rr_request->recv_alignment    =	remote_recv_align;
+      tcp_rr_request->recv_offset	=	remote_recv_offset;
+      tcp_rr_request->send_alignment    =	remote_send_align;
+      tcp_rr_request->send_offset	=	remote_send_offset;
+      tcp_rr_request->request_size	=	req_size;
+      tcp_rr_request->response_size	=	rsp_size;
+      tcp_rr_request->no_delay	        =	rem_nodelay;
+      tcp_rr_request->measure_cpu	=	remote_cpu_usage;
+      tcp_rr_request->cpu_rate	        =	remote_cpu_rate;
+      tcp_rr_request->so_rcvavoid	=	rem_rcvavoid;
+      tcp_rr_request->so_sndavoid	=	rem_sndavoid;
+      if (test_time) {
+	tcp_rr_request->test_length	=	test_time;
+      }
+      else {
+	tcp_rr_request->test_length	=	test_trans * -1;
+      }
+      tcp_rr_request->port              =      atoi(remote_data_port);
+      tcp_rr_request->ipfamily = af_to_nf(remote_res->ai_family);
+      
+      if (debug > 1) {
+	fprintf(where,"netperf: send_tcp_rr: requesting TCP rr test\n");
+      }
+      
+      send_request();
+      
+      /* The response from the remote will contain all of the relevant
+	 socket parameters for this test type. We will put them back
+	 into the variables here so they can be displayed if desired.
+	 The remote will have calibrated CPU if necessary, and will
+	 have done all the needed set-up we will have calibrated the
+	 cpu locally before sending the request, and will grab the
+	 counter value right after the connect returns. The remote
+	 will grab the counter right after the accept call. This saves
+	 the hassle of extra messages being sent for the TCP
+	 tests.  */
+  
+      recv_response();
+  
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"remote listen done.\n");
+	rsr_size          = tcp_rr_response->recv_buf_size;
+	rss_size          = tcp_rr_response->send_buf_size;
+	rem_nodelay       = tcp_rr_response->no_delay;
+	remote_cpu_usage  = tcp_rr_response->measure_cpu;
+	remote_cpu_rate   = tcp_rr_response->cpu_rate;
+	/* make sure that port numbers are in network order */
+	set_port_number(remote_res,(short)tcp_rr_response->data_port_number);
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_RR_SETUP(1000)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: data socket connect failed");
+      
+      exit(1);
+    }
+    
+    /* Data Socket set-up is finished. If there were problems, either the */
+    /* connect would have failed, or the previous response would have */
+    /* indicated a problem. I failed to see the value of the extra */
+    /* message after the accept on the remote. If it failed, we'll see it */
+    /* here. If it didn't, we might as well start pumping data. */
+    
+    /* Set-up the test end conditions. For a request/response test, they */
+    /* can be either time or transaction based. */
+    
+    if (test_time) {
+      /* The user wanted to end the test after a period of time. */
+      times_up = 0;
+      trans_remaining = 0;
+      start_timer(test_time);
+    }
+    else {
+      /* The tester wanted to send a number of bytes. */
+      trans_remaining = test_bytes;
+      times_up = 1;
+    }
+    
+    /* The cpu_start routine will grab the current time and possibly */
+    /* value of the idle counter for later use in measuring cpu */
+    /* utilization and/or service demand and thruput. */
+    
+    cpu_start(local_cpu_usage);
+
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+    
+    /* 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. */
+
+#ifdef WANT_DEMO
+      if (demo_mode) {
+	HIST_timestamp(demo_one_ptr);
+      }
+#endif
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+
+#ifdef WANT_FIRST_BURST
+      /* we can inject no more than request_cwnd, which will grow with
+	 time, and no more than first_burst_size.  we don't use <= to
+	 account for the "regularly scheduled" send call.  of course
+	 that makes it more a "max_outstanding_ than a
+	 "first_burst_size" but for now we won't fix the names. also,
+	 I suspect the extra check against < first_burst_size is
+	 redundant since later I expect to make sure that request_cwnd
+	 can never get larger than first_burst_size, but just at the
+	 moment I'm feeling like a belt and suspenders kind of
+	 programmer. raj 2006-01-30 */
+      while ((first_burst_size > 0) &&
+	     (requests_outstanding < request_cwnd) &&
+	     (requests_outstanding < first_burst_size)) {
+	if (debug) {
+	  fprintf(where,
+		  "injecting, req_outstndng %d req_cwnd %d burst %d\n",
+		  requests_outstanding,
+		  request_cwnd,
+		  first_burst_size);
+	}
+	if ((len = send(send_socket,
+			send_ring->buffer_ptr,
+			req_size,
+			0)) != req_size) {
+	  /* we should never hit the end of the test in the first burst */
+	  perror("send_tcp_rr: initial burst data send error");
+	  exit(-1);
+	}
+	requests_outstanding += 1;
+      }
+
+#endif /* WANT_FIRST_BURST */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before our call to send, and then again just
+	   after the receive raj 8/94 */
+	/* but only if we are actually going to display one. raj
+	   2007-02-07 */
+
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+      
+      if ((len = send(send_socket,
+		      send_ring->buffer_ptr,
+		      req_size,
+		      0)) != req_size) {
+	if (SOCKET_EINTR(len) || (errno == 0)) {
+	  /* we hit the end of a */
+	  /* timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_tcp_rr: data send error");
+	exit(1);
+      }
+      send_ring = send_ring->next;
+
+#ifdef WANT_FIRST_BURST
+      requests_outstanding += 1;
+#endif
+
+      /* receive the response */
+      rsp_bytes_left = rsp_size;
+      temp_message_ptr  = recv_ring->buffer_ptr;
+      while(rsp_bytes_left > 0) {
+	if((rsp_bytes_recvd=recv(send_socket,
+				 temp_message_ptr,
+				 rsp_bytes_left,
+				 0)) == SOCKET_ERROR) {
+		if ( SOCKET_EINTR(rsp_bytes_recvd) ) {
+		    /* We hit the end of a timed test. */
+			timed_out = 1;
+			break;
+		}
+	  perror("send_tcp_rr: data recv error");
+	  exit(1);
+	}
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr  += rsp_bytes_recvd;
+      }	
+      recv_ring = recv_ring->next;
+      
+#ifdef WANT_FIRST_BURST
+      /* so, since we've gotten a response back, update the
+	 bookkeeping accordingly.  there is one less request
+	 outstanding and we can put one more out there than before. */
+      requests_outstanding -= 1;
+      if (request_cwnd < first_burst_size) {
+	request_cwnd += 1;
+	if (debug) {
+	  fprintf(where,
+		  "incr req_cwnd to %d first_burst %d reqs_outstndng %d\n",
+		  request_cwnd,
+		  first_burst_size,
+		  requests_outstanding);
+	}
+      }
+#endif
+      if (timed_out) {
+	/* we may have been in a nested while loop - we need */
+	/* another call to break. */
+	break;
+      }
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_DEMO
+      DEMO_RR_INTERVAL(1);
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  fprintf(where,
+		  "Transaction %d completed\n",
+		  nummessages);
+	  fflush(where);
+	}
+      }
+    }
+
+    /* At this point we used to call shutdown on the data socket to be
+       sure all the data was delivered, but this was not germane in a
+       request/response test, and it was causing the tests to "hang"
+       when they were being controlled by time. So, I have replaced
+       this shutdown call with a call to close that can be found later
+       in the procedure. */
+    
+    /* this call will always give us the elapsed time for the test,
+       and will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured? how long */
+						/* did we really run? */
+    
+    if (!no_control) {
+      /* Get the statistics from the remote end. The remote will have
+	 calculated CPU utilization. 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);
+	fprintf(where,"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	exit(1);
+      }
+    }
+    
+    /* We now calculate what our "throughput" was for the test. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = tcp_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,
+						    tcp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information.
+       if debugging is on, calculate_confidence will print-out the
+       parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    close(send_socket);
+
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(tcp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	if ('x' == libfmt) {
+	  fprintf(where,
+		  cpu_title,
+		  local_cpu_method,
+		  remote_cpu_method);
+	}
+	else {
+	  fprintf(where,
+		  cpu_title_tput,
+		  format_units(),
+		  local_cpu_method,
+		  remote_cpu_method);
+	}	  
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      ('x' == libfmt) ? thruput : 
+	      calc_thruput_interval_omni(thruput * (req_size+rsp_size),
+					 1.0),
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand,	/* remote service demand */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      ('x' == libfmt) ? thruput :
+	      calc_thruput_interval_omni(thruput * (req_size+rsp_size),
+					 1.0),
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		('x' == libfmt) ? tput_title : tput_title_band,
+		format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      /* are we trans or do we need to convert to bytes then
+		 bits? at this point, thruput is in our "confident"
+		 transactions per second. we can convert to a
+		 bidirectional bitrate by multiplying that by the sum
+		 of the req_size and rsp_size.  we pass that to
+		 calc_thruput_interval_omni with an elapsed time of
+		 1.0 s to get it converted to [kmg]bits/s or
+		 [KMG]Bytes/s */
+	      ('x' == libfmt) ?  thruput : 
+	      calc_thruput_interval_omni(thruput * (req_size+rsp_size),
+					 1.0),
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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... */
+
+    /* normally, you might think that if we were messing about with
+       the value of libfmt we would need to put it back again, but
+       since this is basically the last thing we are going to do with
+       it, it does not matter.  so there :) raj 2007-06-08 */
+    /* if the user was asking for transactions, then we report
+       megabits per sedcond for the unidirectional throughput,
+       otherwise we use the desired units. */
+    if ('x' == libfmt) {
+      libfmt = 'm';
+    }
+
+    fprintf(where,
+	    ksink_fmt,
+	    format_units(),
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset,
+	    /* if the user has enable burst mode, we have to remember
+	       to account for that in the number of transactions
+	       outstanding at any one time. otherwise we will
+	       underreport the latency of individual
+	       transactions. learned from saf by raj 2007-06-08  */
+	    (((double)1.0/thruput)*(double)1000000.0) * 
+	    (double) (1+first_burst_size),
+	    thruput,
+	    calc_thruput_interval_omni(thruput * (double)req_size,1.0),
+	    calc_thruput_interval_omni(thruput * (double)rsp_size,1.0));
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+void
+send_udp_stream(char remote_host[])
+{
+  /**********************************************************************/
+  /*									*/
+  /*               	UDP Unidirectional Send Test                    */
+  /*									*/
+  /**********************************************************************/
+
+#define UDP_LENGTH_MAX 0XFFFF - 28
+
+  char *tput_title = "\
+Socket  Message  Elapsed      Messages                \n\
+Size    Size     Time         Okay Errors   Throughput\n\
+bytes   bytes    secs            #      #   %s/sec\n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 = "\
+%6d  %6d   %-7.2f   %7d %6d    %7.2f\n\
+%6d           %-7.2f   %7d           %7.2f\n\n";
+  
+  
+  char *cpu_title = "\
+Socket  Message  Elapsed      Messages                   CPU      Service\n\
+Size    Size     Time         Okay Errors   Throughput   Util     Demand\n\
+bytes   bytes    secs            #      #   %s/sec %% %c%c     us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.2f %c\n";
+  
+  char *cpu_fmt_1 = "\
+%6d  %6d   %-7.2f   %7d %6d    %7.1f     %-6.2f   %-6.3f\n\
+%6d           %-7.2f   %7d           %7.1f     %-6.2f   %-6.3f\n\n";
+  
+  unsigned int	messages_recvd;
+  unsigned int 	messages_sent;
+  unsigned int	failed_sends;
+
+  float	elapsed_time,  
+        local_cpu_utilization,
+        remote_cpu_utilization;
+  
+  float	 local_service_demand, remote_service_demand;
+  double local_thruput, remote_thruput;
+  double bytes_sent;
+  double bytes_recvd;
+ 
+ 
+  int	len;
+  struct ring_elt *send_ring;
+  SOCKET 	data_socket;
+  
+  unsigned int sum_messages_sent;
+  unsigned int sum_messages_recvd;
+  unsigned int sum_failed_sends;
+  double sum_local_thruput;
+
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+  
+  struct	udp_stream_request_struct	*udp_stream_request;
+  struct	udp_stream_response_struct	*udp_stream_response;
+  struct	udp_stream_results_struct	*udp_stream_results;
+  
+  udp_stream_request	= 
+    (struct udp_stream_request_struct *)netperf_request.content.test_specific_data;
+  udp_stream_response	= 
+    (struct udp_stream_response_struct *)netperf_response.content.test_specific_data;
+  udp_stream_results	= 
+    (struct udp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_DGRAM,
+		     IPPROTO_UDP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("UDP UNIDIRECTIONAL SEND TEST",local_res,remote_res);
+  }
+
+  send_ring            = NULL;
+  confidence_iteration = 1;
+  init_stat();
+  sum_messages_sent    = 0;
+  sum_messages_recvd   = 0;
+  sum_failed_sends     = 0;
+  sum_local_thruput    = 0.0;
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+    
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    messages_sent  = 0;
+    messages_recvd = 0;
+    failed_sends   = 0;
+    times_up       = 0;
+    
+    /*set up the data socket			*/
+    data_socket = create_data_socket(local_res);
+    
+    if (data_socket == INVALID_SOCKET){
+      perror("udp_send: data socket");
+      exit(1);
+    }
+    
+    /* now, we want to see if we need to set the send_size */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = (lss_size < UDP_LENGTH_MAX ? lss_size : UDP_LENGTH_MAX);
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    
+    /* set-up the data buffer with the requested alignment and offset, */
+    /* most of the numbers here are just a hack to pick something nice */
+    /* and big in an attempt to never try to send a buffer a second time */
+    /* before it leaves the node...unless the user set the width */
+    /* explicitly. */
+    if (send_width == 0) send_width = 32;
+    
+    if (send_ring == NULL ) {
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+    
+    
+    /* 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);
+    
+    if (!no_control) {
+      /* 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_UDP_STREAM;
+      udp_stream_request->recv_buf_size  = rsr_size_req;
+      udp_stream_request->message_size   = send_size;
+      udp_stream_request->recv_connected = remote_connected;
+      udp_stream_request->recv_alignment = remote_recv_align;
+      udp_stream_request->recv_offset    = remote_recv_offset;
+      udp_stream_request->measure_cpu    = remote_cpu_usage;
+      udp_stream_request->cpu_rate       = remote_cpu_rate;
+      udp_stream_request->test_length    = test_time;
+      udp_stream_request->so_rcvavoid    = rem_rcvavoid;
+      udp_stream_request->so_sndavoid    = rem_sndavoid;
+      udp_stream_request->port           = atoi(remote_data_port);
+      udp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
+      
+      send_request();
+      
+      recv_response();
+      
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"send_udp_stream: remote data connection done.\n");
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	perror("send_udp_stream: error on remote");
+	exit(1);
+      }
+      
+      /* Place the port number returned by the remote into the sockaddr */
+      /* structure so our sends can be sent to the correct place. Also get */
+      /* some of the returned socket buffer information for user display. */
+      
+      /* make sure that port numbers are in the proper order */
+      set_port_number(remote_res,(short)udp_stream_response->data_port_number);
+      
+      rsr_size        = udp_stream_response->recv_buf_size;
+      rss_size        = udp_stream_response->send_buf_size;
+      remote_cpu_rate = udp_stream_response->cpu_rate;
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lss_size,rsr_size)
+#endif
+
+    /* We "connect" up to the remote post to allow is to use the send */
+    /* call instead of the sendto call. Presumeably, this is a little */
+    /* simpler, and a little more efficient. I think that it also means */
+    /* that we can be informed of certain things, but am not sure */
+    /* yet...also, this is the way I would expect a client to behave */
+    /* when talking to a server */
+    if (local_connected) { 
+       if (connect(data_socket,
+      		   remote_res->ai_addr,
+		   remote_res->ai_addrlen) == INVALID_SOCKET){
+          perror("send_udp_stream: data socket connect failed");
+          exit(1);
+       } else if (debug) {
+          fprintf(where,"send_udp_stream: connected data socket.\n");
+          fflush(where);
+       }
+    }
+    
+    /* set up the timer to call us after test_time. one of these days, */
+    /* it might be nice to figure-out a nice reliable way to have the */
+    /* test controlled by a byte count as well, but since UDP is not */
+    /* reliable, that could prove difficult. so, in the meantime, we */
+    /* only allow a UDP_STREAM test to be a timed test. */
+    
+    if (test_time) {
+      times_up = 0;
+      start_timer(test_time);
+    }
+    else {
+      fprintf(where,"Sorry, UDP_STREAM tests must be timed.\n");
+      fflush(where);
+    }
+    
+    /* Get the start count for the idle counter and the start time */
+    
+    cpu_start(local_cpu_usage);
+    
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+#ifdef WANT_DEMO
+    if (demo_mode) {
+      HIST_timestamp(demo_one_ptr);
+    }
+#endif
+
+    /* Send datagrams like there was no tomorrow. at somepoint it might */
+    /* be nice to set this up so that a quantity of bytes could be sent, */
+    /* but we still need some sort of end of test trigger on the receive */
+    /* side. that could be a select with a one second timeout, but then */
+    /* if there is a test where none of the data arrives for awile and */
+    /* then starts again, we would end the test too soon. something to */
+    /* think about... */
+    while (!times_up) {
+      
+#ifdef DIRTY
+      /* we want to dirty some number of consecutive integers in the buffer */
+      /* we are about to send. we may also want to bring some number of */
+      /* them cleanly into the cache. The clean ones will follow any dirty */
+      /* ones into the cache. */
+
+      access_buffer(send_ring->buffer_ptr,
+		    send_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+     
+      if (local_connected) { 
+         len = send(data_socket,
+	  	    send_ring->buffer_ptr,
+		    send_size,
+		    0);
+      } else {
+         len = sendto(data_socket,
+		      send_ring->buffer_ptr,
+		      send_size,
+		      0,
+		      remote_res->ai_addr,
+		      remote_res->ai_addrlen);
+      }
+
+      if (len != send_size) {
+	if ((len >= 0) || 
+	    SOCKET_EINTR(len))
+	  break;
+	if (errno == ENOBUFS) {
+	  failed_sends++;
+	  continue;
+	}
+	perror("udp_send: data send error");
+	exit(1);
+      }
+      messages_sent++;          
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer... */
+      
+      send_ring = send_ring->next;
+      
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* get the second timestamp */
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(send_size)
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#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);
+    
+    if (!no_control) {
+      /* Get the statistics from the remote end	*/
+      recv_response();
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"send_udp_stream: remote results obtained\n");
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	perror("send_udp_stream: error on remote");
+	exit(1);
+      }
+      messages_recvd = udp_stream_results->messages_recvd;
+      bytes_recvd    = (double) send_size * (double) messages_recvd;
+    }
+    else {
+      /* since there was no control connection, we've no idea what was
+	 actually received. raj 2007-02-08 */
+      messages_recvd = -1;
+      bytes_recvd = -1.0;
+    }
+
+    bytes_sent    = (double) send_size * (double) messages_sent;
+    local_thruput = calc_thruput(bytes_sent);
+    
+    
+    /* we asume that the remote ran for as long as we did */
+    
+    remote_thruput = calc_thruput(bytes_recvd);
+    
+    /* print the results for this socket and message size */
+    
+    if (local_cpu_usage || remote_cpu_usage) {
+      /* We must now do a little math for service demand and cpu */
+      /* utilization for the system(s) We pass zeros for the local */
+      /* cpu utilization and elapsed time to tell the routine to use */
+      /* the libraries own values for those. */
+      if (local_cpu_usage) {
+	local_cpu_utilization	= calc_cpu_util(0.0);
+	/* shouldn't this really be based on bytes_recvd, since that is */
+	/* the effective throughput of the test? I think that it should, */
+	/* so will make the change raj 11/94 */
+	local_service_demand	= calc_service_demand(bytes_recvd,
+						      0.0,
+						      0.0,
+						      0);
+      }
+      else {
+	local_cpu_utilization	= (float) -1.0;
+	local_service_demand	= (float) -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) {
+	remote_cpu_utilization	= udp_stream_results->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_recvd,
+						      0.0,
+						      remote_cpu_utilization,
+						      udp_stream_results->num_cpus);
+      }
+      else {
+	remote_cpu_utilization	= (float) -1.0;
+	remote_service_demand	= (float) -1.0;
+      }
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization  = (float) -1.0;
+      local_service_demand   = (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+    
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 remote_thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    /* since the routine calculate_confidence is rather generic, and */
+    /* we have a few other parms of interest, we will do a little work */
+    /* here to caclulate their average. */
+    sum_messages_sent  += messages_sent;
+    sum_messages_recvd += messages_recvd;
+    sum_failed_sends   += failed_sends;
+    sum_local_thruput  += local_thruput;
+    
+    confidence_iteration++;
+
+    /* this datapoint is done, so we don't need the socket any longer */
+    close(data_socket);
+
+  }
+
+  /* we should reach this point once the test is finished */
+
+  retrieve_confident_values(&elapsed_time,
+			    &remote_thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* some of the interesting values aren't covered by the generic */
+  /* confidence routine */
+  messages_sent    = sum_messages_sent / (confidence_iteration -1);
+  messages_recvd   = sum_messages_recvd / (confidence_iteration -1);
+  failed_sends     = sum_failed_sends / (confidence_iteration -1);
+  local_thruput    = sum_local_thruput / (confidence_iteration -1);
+
+  /* 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...  */
+    
+  
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(udp_stream_results->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		local_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput, 		/* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      local_service_demand,	/* local service demand */
+	      rsr_size,
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput,
+	      remote_cpu_utilization,	/* remote cpu */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      local_thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput,
+	      rsr_size, 		/* remote recvbuf size */
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput);
+      break;
+    }
+  }
+
+  fflush(where);
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    fprintf(where,"\nHistogram of time spent in send() call\n");
+    fflush(where);
+    HIST_report(time_hist);
+  }
+#endif /* WANT_HISTOGRAM */
+
+}
+
+
+ /* this routine implements the receive side (netserver) of the */
+ /* UDP_STREAM performance test. */
+
+void
+recv_udp_stream()
+{
+  struct ring_elt *recv_ring;
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct sockaddr_storage myaddr_in;
+  SOCKET	s_data;
+  netperf_socklen_t 	addrlen;
+  struct sockaddr_storage remote_addr;
+  netperf_socklen_t remote_addrlen;
+
+  int	len = 0;
+  unsigned int	bytes_received = 0;
+  float	elapsed_time;
+  
+  int	message_size;
+  unsigned int	messages_recvd = 0;
+  
+  struct	udp_stream_request_struct	*udp_stream_request;
+  struct	udp_stream_response_struct	*udp_stream_response;
+  struct	udp_stream_results_struct	*udp_stream_results;
+  
+  udp_stream_request  = 
+    (struct udp_stream_request_struct *)netperf_request.content.test_specific_data;
+  udp_stream_response = 
+    (struct udp_stream_response_struct *)netperf_response.content.test_specific_data;
+  udp_stream_results  = 
+    (struct udp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_udp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_udp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = UDP_STREAM_RESPONSE;
+  
+  if (debug > 2) {
+    fprintf(where,"recv_udp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_udp_stream: requested alignment of %d\n",
+	    udp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   udp_stream_request->message_size,
+				   udp_stream_request->recv_alignment,
+				   udp_stream_request->recv_offset);
+
+  if (debug > 1) {
+    fprintf(where,"recv_udp_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_udp_stream: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lsr_size_req = udp_stream_request->recv_buf_size;
+  loc_rcvavoid = udp_stream_request->so_rcvavoid;
+  loc_sndavoid = udp_stream_request->so_sndavoid;
+  local_connected = udp_stream_request->recv_connected;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(udp_stream_request->ipfamily),
+			udp_stream_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(udp_stream_request->ipfamily),
+				SOCK_DGRAM,
+				IPPROTO_UDP,
+				0);
+
+  s_data = create_data_socket(local_res);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+
+  udp_stream_response->test_length = udp_stream_request->test_length;
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_data, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_data);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  udp_stream_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  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. */
+  
+  udp_stream_response->cpu_rate    = (float)0.0; /* assume no cpu */
+  udp_stream_response->measure_cpu = 0;
+  if (udp_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... */
+    udp_stream_response->measure_cpu = 1;
+    udp_stream_response->cpu_rate = 
+      calibrate_local_cpu(udp_stream_request->cpu_rate);
+  }
+  
+  message_size	= udp_stream_request->message_size;
+  test_time	= udp_stream_request->test_length;
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  udp_stream_response->send_buf_size = lss_size;
+  udp_stream_response->recv_buf_size = lsr_size;
+  udp_stream_response->so_rcvavoid = loc_rcvavoid;
+  udp_stream_response->so_sndavoid = loc_sndavoid;
+
+  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(udp_stream_request->measure_cpu);
+  
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+  
+  /* 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_udp_stream: about to enter inner sanctum.\n");
+    fflush(where);
+  }
+
+  /* We "connect" up to the remote post to allow us to use the recv */
+  /* call instead of the recvfrom call. Presumeably, this is a little */
+  /* simpler, and a little more efficient. */
+ 
+  if (local_connected) {
+
+    /* Receive the first message using recvfrom to find the remote address */
+    remote_addrlen = sizeof(remote_addr);
+    len = recvfrom(s_data, recv_ring->buffer_ptr,
+                   message_size, 0,
+                   (struct sockaddr*)&remote_addr, &remote_addrlen);
+    if (len != message_size) {
+      if ((len == SOCKET_ERROR) && !SOCKET_EINTR(len)) {
+            netperf_response.content.serv_errno = errno;
+            send_response();
+            exit(1);
+      }
+    }
+    messages_recvd++;
+    recv_ring = recv_ring->next;
+
+
+    /* Now connect with the remote socket address */
+    if (connect(s_data,
+                (struct sockaddr*)&remote_addr,
+                remote_addrlen )== INVALID_SOCKET) {
+        netperf_response.content.serv_errno = errno;
+        close(s_data);
+        send_response();
+        exit(1);
+    }
+
+    if (debug) {
+        fprintf(where,"recv_udp_stream: connected data socket\n");
+        fflush(where);
+     }
+  }
+  
+  while (!times_up) {
+    if(local_connected) {
+       len = recv(s_data,
+                  recv_ring->buffer_ptr,
+                  message_size,
+                  0);
+    } else {
+       len = recvfrom(s_data,
+                      recv_ring->buffer_ptr,
+    	              message_size, 
+		      0,0,0);
+    }
+       
+    if (len != message_size) {
+      if ((len == SOCKET_ERROR) && !SOCKET_EINTR(len)) {
+            netperf_response.content.serv_errno = errno;
+	    send_response();
+	    exit(1);
+      }
+      break;
+    }
+    messages_recvd++;
+    recv_ring = recv_ring->next;
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_udp_stream: got %d messages.\n",messages_recvd);
+    fflush(where);
+  }
+  
+  
+  /* The loop now exits due timer or < send_size bytes received. in */
+  /* reality, we only really support a timed UDP_STREAM test. raj */
+  /* 12/95 */
+  
+  cpu_stop(udp_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_udp_stream: test ended in %f seconds.\n",elapsed_time);
+    fflush(where);
+  }
+  
+  
+  /* We will count the "off" message that got us out of the loop */
+  bytes_received = (messages_recvd * message_size) + len;
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_udp_stream: got %d bytes\n",
+	    bytes_received);
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type	= UDP_STREAM_RESULTS;
+  udp_stream_results->bytes_received	= htonl(bytes_received);
+  udp_stream_results->messages_recvd	= messages_recvd;
+  udp_stream_results->elapsed_time	= elapsed_time;
+  udp_stream_results->cpu_method        = cpu_method;
+  udp_stream_results->num_cpus          = lib_num_loc_cpus;
+  if (udp_stream_request->measure_cpu) {
+    udp_stream_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  else {
+    udp_stream_results->cpu_util	= (float) -1.0;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,
+	    "recv_udp_stream: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+
+  close(s_data);
+
+}
+
+void
+send_udp_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  float			elapsed_time;
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  int	len;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  int	bytes_xferd;
+  
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+  
+  struct	udp_rr_request_struct	*udp_rr_request;
+  struct	udp_rr_response_struct	*udp_rr_response;
+  struct	udp_rr_results_struct	*udp_rr_result;
+
+  udp_rr_request  =
+    (struct udp_rr_request_struct *)netperf_request.content.test_specific_data;
+  udp_rr_response =
+    (struct udp_rr_response_struct *)netperf_response.content.test_specific_data;
+  udp_rr_result	 =
+    (struct udp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_DGRAM,
+		     IPPROTO_UDP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("UDP REQUEST/RESPONSE TEST",local_res,remote_res);
+  }
+
+  /* initialize a few counters */
+  
+  send_ring     = NULL;
+  recv_ring     = NULL;
+  nummessages	= 0;
+  bytes_xferd	= 0;
+  times_up 	= 0;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+    
+    nummessages     = 0;
+    bytes_xferd     = 0;
+    times_up        = 0;
+    trans_remaining = 0;
+    
+    /* set-up the data buffers with the requested alignment and offset */
+    
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+    
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+    
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+    
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_udp_rr: udp rr data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_udp_rr: send_socket obtained...\n");
+    }
+    
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. If */
+    /* there is no idle counter in the kernel idle loop, the */
+    /* local_cpu_rate will be set to -1. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* 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_UDP_RR;
+      udp_rr_request->recv_buf_size	= rsr_size_req;
+      udp_rr_request->send_buf_size	= rss_size_req;
+      udp_rr_request->recv_alignment      = remote_recv_align;
+      udp_rr_request->recv_offset	        = remote_recv_offset;
+      udp_rr_request->send_alignment      = remote_send_align;
+      udp_rr_request->send_offset	        = remote_send_offset;
+      udp_rr_request->request_size	= req_size;
+      udp_rr_request->response_size	= rsp_size;
+      udp_rr_request->measure_cpu	        = remote_cpu_usage;
+      udp_rr_request->cpu_rate	        = remote_cpu_rate;
+      udp_rr_request->so_rcvavoid	        = rem_rcvavoid;
+      udp_rr_request->so_sndavoid	        = rem_sndavoid;
+      if (test_time) {
+	udp_rr_request->test_length	= test_time;
+      }
+      else {
+	udp_rr_request->test_length	= test_trans * -1;
+      }
+      udp_rr_request->port                = atoi(remote_data_port);
+      udp_rr_request->ipfamily = af_to_nf(remote_res->ai_family);
+      
+      if (debug > 1) {
+	fprintf(where,"netperf: send_udp_rr: requesting UDP r/r 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 UDP
+	 tests.  */
+    
+      recv_response();
+    
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"remote listen done.\n");
+	rsr_size	       =	udp_rr_response->recv_buf_size;
+	rss_size	       =	udp_rr_response->send_buf_size;
+	remote_cpu_usage =	udp_rr_response->measure_cpu;
+	remote_cpu_rate  = 	udp_rr_response->cpu_rate;
+	/* port numbers in proper order */
+	set_port_number(remote_res,(short)udp_rr_response->data_port_number);
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_RR_SETUP(100)
+#endif
+
+    /* Connect up to the remote port on the data socket. This will set */
+    /* the default destination address on this socket. With UDP, this */
+    /* does make a performance difference as we may not have to do as */
+    /* many routing lookups, however, I expect that a client would */
+    /* behave this way. raj 1/94 */
+    
+    if ( connect(send_socket, 
+		 remote_res->ai_addr,
+		 remote_res->ai_addrlen) == INVALID_SOCKET ) {
+      perror("netperf: data socket connect failed");
+      exit(1);
+    }
+    
+    /* Data Socket set-up is finished. If there were problems, either the */
+    /* connect would have failed, or the previous response would have */
+    /* indicated a problem. I failed to see the value of the extra */
+    /* message after the accept on the remote. If it failed, we'll see it */
+    /* here. If it didn't, we might as well start pumping data. */
+    
+    /* Set-up the test end conditions. For a request/response test, they */
+    /* can be either time or transaction based. */
+    
+    if (test_time) {
+      /* The user wanted to end the test after a period of time. */
+      times_up = 0;
+      trans_remaining = 0;
+      start_timer(test_time);
+    }
+    else {
+      /* The tester wanted to send a number of bytes. */
+      trans_remaining = test_bytes;
+      times_up = 1;
+    }
+    
+    /* The cpu_start routine will grab the current time and possibly */
+    /* value of the idle counter for later use in measuring cpu */
+    /* utilization and/or service demand and thruput. */
+    
+    cpu_start(local_cpu_usage);
+
+#ifdef WANT_DEMO
+    if (demo_mode) {
+      HIST_timestamp(demo_one_ptr);
+    }
+#endif 
+
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+    
+    /* 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. */
+
+#ifdef WANT_FIRST_BURST
+    {
+      int i;
+      for (i = 0; i < first_burst_size; i++) {
+	if((len=send(send_socket,
+		     send_ring->buffer_ptr,
+		     req_size,
+		     0)) != req_size) {
+	  /* we should never hit the end of the test in the first burst */
+	  perror("send_udp_rr: initial burst data send error");
+	  exit(-1);
+	}
+      }
+    }
+#endif /* WANT_FIRST_BURST */
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request */
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_one);
+      }
+#endif
+      if((len=send(send_socket,
+		   send_ring->buffer_ptr,
+		   req_size,
+		   0)) != req_size) {
+        if (SOCKET_EINTR(len)) {
+	      /* We likely hit */
+	      /* test-end time. */
+	      break;
+		}
+	    perror("send_udp_rr: data send error");
+	    exit(1);
+	  }
+      send_ring = send_ring->next;
+      
+      /* receive the response. with UDP we will get it all, or nothing */
+      
+      if((rsp_bytes_recvd=recv(send_socket,
+			       recv_ring->buffer_ptr,
+			       rsp_size,
+			       0)) != rsp_size) {
+	    if (SOCKET_EINTR(rsp_bytes_recvd))
+		{
+    	  /* Again, we have likely hit test-end time */
+	      break;
+		}
+	    perror("send_udp_rr: data recv error");
+	    exit(1);
+      }
+      recv_ring = recv_ring->next;
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+
+#endif
+
+      /* 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.  */
+
+#ifdef WANT_DEMO
+      DEMO_RR_INTERVAL(1);
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  fprintf(where,"Transaction %d completed\n",nummessages);
+	  fflush(where);
+	}
+      }
+      
+    }
+    
+    /* for some strange reason, I used to call shutdown on the UDP */
+    /* data socket here. I'm not sure why, because it would not have */
+    /* any effect... raj 11/94 */
+    
+    /* 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? */
+    
+    if (!no_control) {
+      /* 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);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	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 rr test, that the two numbers should be *very* close... */
+    /* We calculate bytes_sent regardless of the way the test length */
+    /* was controlled.  */
+    
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages / elapsed_time;
+    
+    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 by placing a code for the metod used in the */
+      /* test banner */
+
+      if (local_cpu_usage) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = udp_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,
+						     udp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+    
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+    
+    /* we are done with the socket */
+    close(send_socket);
+  }
+
+  /* at this point, we have made all the iterations we are going to */
+  /* make. */
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+  
+  /* 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...  */
+  
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+  
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(udp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+    
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  fflush(where);
+
+  /* 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. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+
+  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_HISTOGRAM
+    fprintf(where,"\nHistogram of request/reponse times.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+}
+
+ /* this routine implements the receive side (netserver) of a UDP_RR */
+ /* test. */
+void
+recv_udp_rr()
+{
+  
+  struct ring_elt *recv_ring;
+  struct ring_elt *send_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct sockaddr_storage        myaddr_in;
+  struct sockaddr_storage    peeraddr; 
+  SOCKET	s_data;
+  netperf_socklen_t 	addrlen;
+  int	trans_received;
+  int	trans_remaining;
+  int   request_bytes_recvd;
+  int   response_bytes_sent;
+  float	elapsed_time;
+  
+  struct	udp_rr_request_struct	*udp_rr_request;
+  struct	udp_rr_response_struct	*udp_rr_response;
+  struct	udp_rr_results_struct	*udp_rr_results;
+  
+  udp_rr_request  = 
+    (struct udp_rr_request_struct *)netperf_request.content.test_specific_data;
+  udp_rr_response = 
+    (struct udp_rr_response_struct *)netperf_response.content.test_specific_data;
+  udp_rr_results  = 
+    (struct udp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_udp_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_udp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = UDP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_udp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variables to be at the desired */
+  /* alignments with the desired offsets. */
+  
+  if (debug) {
+    fprintf(where,"recv_udp_rr: requested recv alignment of %d offset %d\n",
+	    udp_rr_request->recv_alignment,
+	    udp_rr_request->recv_offset);
+    fprintf(where,"recv_udp_rr: requested send alignment of %d offset %d\n",
+	    udp_rr_request->send_alignment,
+	    udp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   udp_rr_request->request_size,
+				   udp_rr_request->recv_alignment,
+				   udp_rr_request->recv_offset);
+
+  send_ring = allocate_buffer_ring(send_width,
+				   udp_rr_request->response_size,
+				   udp_rr_request->send_alignment,
+				   udp_rr_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_udp_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_udp_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = udp_rr_request->send_buf_size;
+  lsr_size_req = udp_rr_request->recv_buf_size;
+  loc_rcvavoid = udp_rr_request->so_rcvavoid;
+  loc_sndavoid = udp_rr_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(udp_rr_request->ipfamily),
+			udp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(udp_rr_request->ipfamily),
+				SOCK_DGRAM,
+				IPPROTO_UDP,
+				0);
+				
+  s_data = create_data_socket(local_res);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_data, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_data);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  udp_rr_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  netperf_response.content.serv_errno   = 0;
+  
+  if (debug) {
+    fprintf(where,
+	    "recv port number %d\n",
+	    ((struct sockaddr_in *)&myaddr_in)->sin_port);
+    fflush(where);
+  }
+  
+  /* 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. */
+  
+  udp_rr_response->cpu_rate    = (float)0.0; 	/* assume no cpu */
+  udp_rr_response->measure_cpu = 0;
+  if (udp_rr_request->measure_cpu) {
+    udp_rr_response->measure_cpu = 1;
+    udp_rr_response->cpu_rate = calibrate_local_cpu(udp_rr_request->cpu_rate);
+  }
+   
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  udp_rr_response->send_buf_size = lss_size;
+  udp_rr_response->recv_buf_size = lsr_size;
+  udp_rr_response->so_rcvavoid   = loc_rcvavoid;
+  udp_rr_response->so_sndavoid   = loc_sndavoid;
+ 
+  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(udp_rr_request->measure_cpu);
+  
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+  
+  if (udp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(udp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = udp_rr_request->test_length * -1;
+  }
+
+  addrlen = sizeof(peeraddr); 
+  bzero((char *)&peeraddr, addrlen);
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+    
+    /* receive the request from the other side */
+    if ((request_bytes_recvd = recvfrom(s_data,
+		 recv_ring->buffer_ptr,
+		 udp_rr_request->request_size,
+		 0,
+		 (struct sockaddr *)&peeraddr,
+		 &addrlen)) != udp_rr_request->request_size) {
+	  if ( SOCKET_EINTR(request_bytes_recvd) )
+	  {
+	    /* we must have hit the end of test time. */
+	    break;
+      }
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    recv_ring = recv_ring->next;
+
+    /* Now, send the response to the remote */
+    if ((response_bytes_sent = sendto(s_data,
+				      send_ring->buffer_ptr,
+				      udp_rr_request->response_size,
+				      0,
+				      (struct sockaddr *)&peeraddr,
+				      addrlen)) != 
+	udp_rr_request->response_size) {
+      if ( SOCKET_EINTR(response_bytes_sent) )
+	  {
+	    /* we have hit end of test time. */
+	    break;
+      }
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    send_ring = send_ring->next;
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_udp_rr: Transaction %d complete.\n",
+	      trans_received);
+      fflush(where);
+    }
+    
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(udp_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_udp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  udp_rr_results->bytes_received = (trans_received * 
+				    (udp_rr_request->request_size + 
+				     udp_rr_request->response_size));
+  udp_rr_results->trans_received = trans_received;
+  udp_rr_results->elapsed_time	 = elapsed_time;
+  udp_rr_results->cpu_method     = cpu_method;
+  udp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (udp_rr_request->measure_cpu) {
+    udp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_udp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+
+  /* we are done with the socket now */
+  close(s_data);
+
+      }
+
+
+ /* this routine implements the receive (netserver) side of a TCP_RR */
+ /* test */
+void
+recv_tcp_rr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct	sockaddr_storage        myaddr_in,
+  peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  int   sock_closed = 0;
+  float	elapsed_time;
+  
+  struct	tcp_rr_request_struct	*tcp_rr_request;
+  struct	tcp_rr_response_struct	*tcp_rr_response;
+  struct	tcp_rr_results_struct	*tcp_rr_results;
+  
+  tcp_rr_request = 
+    (struct tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_rr_response =
+    (struct tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_rr_results =
+    (struct tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_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_tcp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_tcp_rr: requested recv alignment of %d offset %d\n",
+	    tcp_rr_request->recv_alignment,
+	    tcp_rr_request->recv_offset);
+    fprintf(where,"recv_tcp_rr: requested send alignment of %d offset %d\n",
+	    tcp_rr_request->send_alignment,
+	    tcp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   tcp_rr_request->response_size,
+				   tcp_rr_request->send_alignment,
+				   tcp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   tcp_rr_request->request_size,
+				   tcp_rr_request->recv_alignment,
+				   tcp_rr_request->recv_offset);
+
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_rr_request->send_buf_size;
+  lsr_size_req = tcp_rr_request->recv_buf_size;
+  loc_nodelay = tcp_rr_request->no_delay;
+  loc_rcvavoid = tcp_rr_request->so_rcvavoid;
+  loc_sndavoid = tcp_rr_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_rr_request->ipfamily),
+			tcp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in, 
+		  &addrlen) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_rr_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  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. */
+  
+  tcp_rr_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  tcp_rr_response->measure_cpu = 0;
+
+  if (tcp_rr_request->measure_cpu) {
+    tcp_rr_response->measure_cpu = 1;
+    tcp_rr_response->cpu_rate = calibrate_local_cpu(tcp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_rr_response->send_buf_size = lss_size;
+  tcp_rr_response->recv_buf_size = lsr_size;
+  tcp_rr_response->no_delay = loc_nodelay;
+  tcp_rr_response->so_rcvavoid = loc_rcvavoid;
+  tcp_rr_response->so_sndavoid = loc_sndavoid;
+  tcp_rr_response->test_length = tcp_rr_request->test_length;
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  if ((s_data = accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    
+    exit(1);
+  }
+  
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+
+  if (debug) {
+    fprintf(where,"recv_tcp_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(tcp_rr_request->measure_cpu);
+  
+  /* The loop will exit when we hit the end of the test time, or when */
+  /* we have exchanged the requested number of transactions. */
+  
+  if (tcp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(tcp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = tcp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining	= tcp_rr_request->request_size;
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	if (SOCKET_EINTR(request_bytes_recvd))
+	{
+	  timed_out = 1;
+	  break;
+	}
+
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      else if( request_bytes_recvd == 0 ) {
+	if (debug) {
+	  fprintf(where,"zero is my hero\n");
+	  fflush(where);
+	}
+	sock_closed = 1;
+	break;
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+
+    recv_ring = recv_ring->next;
+
+    if ((timed_out) || (sock_closed)) {
+      /* we hit the end of the test based on time - or the socket
+	 closed on us along the way.  bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo5\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=send(s_data,
+			send_ring->buffer_ptr,
+			tcp_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (SOCKET_EINTR(bytes_sent)) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 992;
+      send_response();
+      exit(1);
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(tcp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer();
+
+  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_tcp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  tcp_rr_results->bytes_received = (trans_received * 
+				    (tcp_rr_request->request_size + 
+				     tcp_rr_request->response_size));
+  tcp_rr_results->trans_received = trans_received;
+  tcp_rr_results->elapsed_time   = elapsed_time;
+  tcp_rr_results->cpu_method     = cpu_method;
+  tcp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (tcp_rr_request->measure_cpu) {
+    tcp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  send_response();
+  
+}
+
+
+void
+loc_cpu_rate()
+{
+#if defined(USE_LOOPER)
+  float dummy;
+#endif
+
+  /* a rather simple little test - it merely calibrates the local cpu */
+  /* and prints the results. There are no headers to allow someone to */
+  /* find a rate and use it in other tests automagically by setting a */
+  /* variable equal to the output of this test. We ignore any rates */
+  /* that may have been specified. In fact, we ignore all of the */
+  /* command line args! */
+  
+  fprintf(where,
+	  "%g",
+	  calibrate_local_cpu(0.0));
+
+  if (verbosity > 1)
+    fprintf(where,
+	    "\nThere %s %d local %s\n",
+	    (lib_num_loc_cpus > 1) ? "are" : "is",
+	    lib_num_loc_cpus,
+	    (lib_num_loc_cpus > 1) ? "cpus" : "cpu");
+	    
+  /* we need the cpu_start, cpu_stop in the looper case to kill the */
+  /* child proceses raj 4/95 */
+
+#ifdef USE_LOOPER
+  cpu_start(1);
+  cpu_stop(1,&dummy);
+#endif /* USE_LOOPER */
+
+}	
+
+void
+rem_cpu_rate()
+{
+  /* this test is much like the local variant, except that it works for */
+  /* the remote system, so in this case, we do pay attention to the */
+  /* value of the '-H' command line argument. */
+  
+  fprintf(where,
+	  "%g",
+	  calibrate_remote_cpu());
+  
+  if (verbosity > 1)
+    fprintf(where,
+	    "\nThere %s %d remote %s\n",
+	    (lib_num_rem_cpus > 1) ? "are" : "is",
+	    lib_num_rem_cpus,
+	    (lib_num_rem_cpus > 1) ? "cpus" : "cpu");
+
+}
+
+
+ /* this test is intended to test the performance of establishing a
+    connection, exchanging a request/response pair, and repeating. it
+    is expected that this would be a good starting-point for
+    comparision of T/TCP with classic TCP for transactional workloads.
+    it will also look (can look) much like the communication pattern
+    of http for www access. */
+
+void
+send_tcp_conn_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\n\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+
+  int                           myport;
+  int                           ret;
+
+  struct	tcp_conn_rr_request_struct	*tcp_conn_rr_request;
+  struct	tcp_conn_rr_response_struct	*tcp_conn_rr_response;
+  struct	tcp_conn_rr_results_struct	*tcp_conn_rr_result;
+  
+  tcp_conn_rr_request = 
+    (struct tcp_conn_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_conn_rr_response = 
+    (struct tcp_conn_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_conn_rr_result =
+    (struct tcp_conn_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("TCP Connect/Request/Response TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_xferd	=	0.0;
+  times_up 	= 	0;
+  
+  /* set-up the data buffers with the requested alignment and offset */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   req_size,
+				   local_send_align,
+				   local_send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   rsp_size,
+				   local_recv_align,
+				   local_recv_offset);
+
+
+  if (debug) {
+    fprintf(where,"send_tcp_conn_rr: send_socket obtained...\n");
+  }
+  
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+
+  if (!no_control) {
+  
+    /* 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_TCP_CRR;
+    tcp_conn_rr_request->recv_buf_size	=	rsr_size_req;
+    tcp_conn_rr_request->send_buf_size	=	rss_size_req;
+    tcp_conn_rr_request->recv_alignment	=	remote_recv_align;
+    tcp_conn_rr_request->recv_offset	=	remote_recv_offset;
+    tcp_conn_rr_request->send_alignment	=	remote_send_align;
+    tcp_conn_rr_request->send_offset	=	remote_send_offset;
+    tcp_conn_rr_request->request_size	=	req_size;
+    tcp_conn_rr_request->response_size	=	rsp_size;
+    tcp_conn_rr_request->no_delay	=	rem_nodelay;
+    tcp_conn_rr_request->measure_cpu	=	remote_cpu_usage;
+    tcp_conn_rr_request->cpu_rate	=	remote_cpu_rate;
+    tcp_conn_rr_request->so_rcvavoid	=	rem_rcvavoid;
+    tcp_conn_rr_request->so_sndavoid	=	rem_sndavoid;
+    if (test_time) {
+      tcp_conn_rr_request->test_length	=	test_time;
+    }
+    else {
+      tcp_conn_rr_request->test_length	=	test_trans * -1;
+    }
+    tcp_conn_rr_request->port           = atoi(remote_data_port);
+    tcp_conn_rr_request->ipfamily       = af_to_nf(remote_res->ai_family);
+    
+    if (debug > 1) {
+      fprintf(where,"netperf: send_tcp_conn_rr: requesting TCP crr 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) {
+      rsr_size	       =	tcp_conn_rr_response->recv_buf_size;
+      rss_size	       =	tcp_conn_rr_response->send_buf_size;
+      rem_nodelay      =	tcp_conn_rr_response->no_delay;
+      remote_cpu_usage =	tcp_conn_rr_response->measure_cpu;
+      remote_cpu_rate  = 	tcp_conn_rr_response->cpu_rate;
+      /* make sure that port numbers are in network order */
+      set_port_number(remote_res,
+		      (unsigned short)tcp_conn_rr_response->data_port_number);
+      
+      if (debug) {
+	fprintf(where,"remote listen done.\n");
+	fprintf(where,"remote port is %u\n",get_port_number(remote_res));
+	fflush(where);
+      }
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      exit(1);
+    }
+  }
+#ifdef WANT_DEMO
+  DEMO_RR_SETUP(100)
+#endif
+
+  /* pick a nice random spot between client_port_min and */
+  /* client_port_max for our initial port number */
+  srand(getpid());
+  if (client_port_max - client_port_min) {
+    myport = client_port_min + 
+      (rand() % (client_port_max - client_port_min));
+  }
+  else {
+    myport = client_port_min;
+  }
+  /* there will be a ++ before the first call to bind, so subtract one */
+  myport--;
+  /* 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);
+
+#ifdef WANT_DEMO
+      if (demo_mode) {
+	HIST_timestamp(demo_one_ptr);
+      }
+#endif
+  
+  /* 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)) {
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      /* timestamp just before our call to create the socket, and then */
+      /* again just after the receive raj 3/95 */
+      HIST_timestamp(&time_one);
+    }
+#endif /* WANT_HISTOGRAM */
+
+newport:
+    /* pick a new port number */
+    myport++;
+
+    /* wrap the port number when we get to client_port_max. NOTE, some */
+    /* broken TCP's might treat the port number as a signed 16 bit */
+    /* quantity.  we aren't interested in testing such broken */
+    /* implementations :) so we won't make sure that it is below 32767 */
+    /* raj 8/94  */
+    if (myport >= client_port_max) {
+      myport = client_port_min;
+    }
+
+    /* we do not want to use the port number that the server is */
+    /* sitting at - this would cause us to fail in a loopback test. we */
+    /* could just rely on the failure of the bind to get us past this, */
+    /* but I'm guessing that in this one case at least, it is much */
+    /* faster, given that we *know* that port number is already in use */
+    /* (or rather would be in a loopback test) */
+
+    if (myport == get_port_number(remote_res)) myport++;
+
+    if (debug) {
+      if ((nummessages % 100) == 0) {
+	printf("port %d\n",myport);
+      }
+    }
+
+    /* set up the data socket */
+    set_port_number(local_res, (unsigned short)myport);
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket == INVALID_SOCKET) {
+      perror("netperf: send_tcp_conn_rr: tcp stream data socket");
+      exit(1);
+    }
+
+
+    /* we used to call bind here, but that is now taken-care-of by the
+       create_data_socket routine. */
+
+    /* Connect up to the remote port on the data socket  */
+    if ((ret = connect(send_socket, 
+		       remote_res->ai_addr,
+		       remote_res->ai_addrlen)) == INVALID_SOCKET){
+      if (SOCKET_EINTR(ret))
+	  {
+	    /* we hit the end of a */
+	    /* timed test. */
+	    timed_out = 1;
+	    break;
+      }
+      if ((SOCKET_EADDRINUSE(ret)) || SOCKET_EADDRNOTAVAIL(ret)) {
+	/* likely something our explicit bind() would have caught in
+           the past, so go get another port, via create_data_socket.
+           yes, this is a bit more overhead than before, but the
+           condition should be rather rare.  raj 2005-02-08 */
+	close(send_socket);
+	goto newport;
+      }
+      perror("netperf: data socket connect failed");
+      printf("\tattempted to connect on socket %d to port %d",
+	     send_socket,
+	     get_port_number(remote_res));
+      printf(" from port %d \n",get_port_number(local_res));
+      exit(1);
+    }
+
+
+    /* send the request */
+    if((len=send(send_socket,
+		 send_ring->buffer_ptr,
+		 req_size,
+		 0)) != req_size) {
+      if (SOCKET_EINTR(len))
+	  {
+	    /* we hit the end of a */
+	    /* timed test. */
+	    timed_out = 1;
+	    break;
+      }
+      perror("send_tcp_conn_rr: data send error");
+      exit(1);
+    }
+    send_ring = send_ring->next;
+
+    /* receive the response */
+    rsp_bytes_left = rsp_size;
+    temp_message_ptr  = recv_ring->buffer_ptr;
+
+
+    do {
+      rsp_bytes_recvd = recv(send_socket,
+			     temp_message_ptr,
+			     rsp_bytes_left,
+			     0);
+      if (rsp_bytes_recvd > 0) {
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr += rsp_bytes_recvd;
+      }
+      else {
+	break;
+      }
+    } while (rsp_bytes_left);
+
+
+    /* OK, we are out of the loop - now what? */
+    if (rsp_bytes_recvd < 0) {
+      /* did the timer hit, or was there an error? */
+      if (SOCKET_EINTR(rsp_bytes_recvd))
+	  {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+	  perror("send_tcp_conn_rr: data recv error");
+	  exit(1);
+    }
+
+    /* if this is a no_control test, we initiate connection close,
+       otherwise the remote netserver does it to remain just like
+       previous behaviour. raj 2007-27-08 */
+    if (!no_control) {
+      shutdown(send_socket,SHUT_WR);
+    }
+
+    /* we are expecting to get either a return of zero indicating
+       connection close, or an error.  */
+    rsp_bytes_recvd = recv(send_socket,
+			   temp_message_ptr,
+			   1,
+			   0);
+
+    /* our exit from the while loop should generally be when */
+    /* tmp_bytes_recvd is equal to zero, which implies the connection */
+    /* has been closed by the server side. By waiting until we get the */
+    /* zero return we can avoid race conditions that stick us with the */
+    /* TIME_WAIT connection and not the server. raj 8/96 */
+
+    if (rsp_bytes_recvd == 0) {
+      /* connection close, call close. we assume that the requisite */
+      /* number of bytes have been received */
+      recv_ring = recv_ring->next;
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_DEMO
+      DEMO_RR_INTERVAL(1)
+#endif
+
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+    
+      if (debug > 3) {
+	fprintf(where,
+		"Transaction %d completed on local port %d\n",
+		nummessages,
+		get_port_number(local_res));
+	fflush(where);
+      }
+
+      close(send_socket);
+
+    }
+    else {
+      /* it was less than zero - an error occured */
+      if (SOCKET_EINTR(rsp_bytes_recvd))
+	  {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+	  perror("send_tcp_conn_rr: data recv 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? */
+  
+  if (!no_control) {
+    /* 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);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      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	= (float) -1.0;
+      local_service_demand	= (float) -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 = tcp_conn_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,
+						  tcp_conn_rr_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -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:
+
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+      
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+
+void
+recv_tcp_conn_rr()
+{
+  
+  char  *message;
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct	sockaddr_storage        myaddr_in, peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  char	*recv_message_ptr;
+  char	*send_message_ptr;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	tcp_conn_rr_request_struct	*tcp_conn_rr_request;
+  struct	tcp_conn_rr_response_struct	*tcp_conn_rr_response;
+  struct	tcp_conn_rr_results_struct	*tcp_conn_rr_results;
+  
+  tcp_conn_rr_request = 
+    (struct tcp_conn_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_conn_rr_response = 
+    (struct tcp_conn_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_conn_rr_results = 
+    (struct tcp_conn_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_conn_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_tcp_conn_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_CRR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_conn_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_tcp_conn_rr: requested recv alignment of %d offset %d\n",
+	    tcp_conn_rr_request->recv_alignment,
+	    tcp_conn_rr_request->recv_offset);
+    fprintf(where,
+	    "recv_tcp_conn_rr: requested send alignment of %d offset %d\n",
+	    tcp_conn_rr_request->send_alignment,
+	    tcp_conn_rr_request->send_offset);
+    fflush(where);
+  }
+
+  recv_message_ptr = ALIGN_BUFFER(message, tcp_conn_rr_request->recv_alignment, tcp_conn_rr_request->recv_offset);
+  
+  send_message_ptr = ALIGN_BUFFER(message, tcp_conn_rr_request->send_alignment, tcp_conn_rr_request->send_offset);
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_conn_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_conn_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_conn_rr_request->send_buf_size;
+  lsr_size_req = tcp_conn_rr_request->recv_buf_size;
+  loc_nodelay = tcp_conn_rr_request->no_delay;
+  loc_rcvavoid = tcp_conn_rr_request->so_rcvavoid;
+  loc_sndavoid = tcp_conn_rr_request->so_sndavoid;
+  
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_conn_rr_request->ipfamily),
+			tcp_conn_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_conn_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    if (debug) {
+      fprintf(where,"could not create data socket\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+#ifdef WIN32
+    /* The test timer can fire during operations on the listening socket,
+       so to make the start_timer below work we have to move
+       it to close s_listen while we are blocked on accept. */
+    win_kludge_socket2 = s_listen;
+#endif
+
+
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not listen\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not getsockname\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_conn_rr_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  if (debug) {
+    fprintf(where,"telling the remote to call me at %d\n",
+	    tcp_conn_rr_response->data_port_number);
+    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 0.0 to */
+  /* the initiator. */
+  
+  tcp_conn_rr_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (tcp_conn_rr_request->measure_cpu) {
+    tcp_conn_rr_response->measure_cpu = 1;
+    tcp_conn_rr_response->cpu_rate = 
+      calibrate_local_cpu(tcp_conn_rr_request->cpu_rate);
+  }
+  
+
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_conn_rr_response->send_buf_size = lss_size;
+  tcp_conn_rr_response->recv_buf_size = lsr_size;
+  tcp_conn_rr_response->no_delay = loc_nodelay;
+  tcp_conn_rr_response->so_rcvavoid = loc_rcvavoid;
+  tcp_conn_rr_response->so_sndavoid = loc_sndavoid;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_conn_rr_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (tcp_conn_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(tcp_conn_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = tcp_conn_rr_request->test_length * -1;
+  }
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+
+    /* accept a connection from the remote */
+#ifdef WIN32
+    /* The test timer will probably fire during this accept, 
+       so to make the start_timer above work we have to move
+       it to close s_listen while we are blocked on accept. */
+    win_kludge_socket = s_listen;
+#endif
+    if ((s_data=accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+      if (errno == EINTR) {
+	/* the timer popped */
+	timed_out = 1;
+	break;
+      }
+      fprintf(where,"recv_tcp_conn_rr: accept: errno = %d\n",errno);
+      fflush(where);
+      close(s_listen);
+      
+      exit(1);
+    }
+
+    if (debug) {
+      fprintf(where,"recv_tcp_conn_rr: accepted data connection.\n");
+      fflush(where);
+    }
+  
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+    /* this is for those systems which *INCORRECTLY* fail to pass */
+    /* attributes across an accept() call. Including this goes against */
+    /* my better judgement :( raj 11/95 */
+    
+    kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+    temp_message_ptr	= recv_message_ptr;
+    request_bytes_remaining	= tcp_conn_rr_request->request_size;
+    
+    /* receive the request from the other side */
+    while (!times_up && (request_bytes_remaining > 0)) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	if (SOCKET_EINTR(request_bytes_recvd))
+	{
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	}
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+    
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      fprintf(where,"yo5\n");
+      fflush(where);						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=send(s_data,
+			send_message_ptr,
+			tcp_conn_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (errno == EINTR) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 99;
+      send_response();
+      exit(1);
+    }
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_tcp_conn_rr: Transaction %d complete\n",
+	      trans_received);
+      fflush(where);
+    }
+
+    /* close the connection. the server will likely do a graceful */
+    /* close of the connection, insuring that all data has arrived at */
+    /* the client. for this it will call shutdown(), and then recv() and */
+    /* then close(). I'm reasonably confident that this is the */
+    /* appropriate sequence of calls - I would like to hear of */
+    /* examples in web servers to the contrary. raj 10/95*/
+#ifdef TCP_CRR_SHUTDOWN
+    shutdown(s_data,SHUT_WR);
+    recv(s_data,
+	 recv_message_ptr,
+	 1,
+	 0);
+    close(s_data);
+#else
+    close(s_data);
+#endif /* TCP_CRR_SHUTDOWN */
+
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(tcp_conn_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_tcp_conn_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  tcp_conn_rr_results->bytes_received	= (trans_received * 
+					   (tcp_conn_rr_request->request_size + 
+					    tcp_conn_rr_request->response_size));
+  tcp_conn_rr_results->trans_received	= trans_received;
+  tcp_conn_rr_results->elapsed_time	= elapsed_time;
+  if (tcp_conn_rr_request->measure_cpu) {
+    tcp_conn_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_conn_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+
+
+#ifdef DO_1644
+
+ /* this test is intended to test the performance of establishing a */
+ /* connection, exchanging a request/response pair, and repeating. it */
+ /* is expected that this would be a good starting-point for */
+ /* comparision of T/TCP with classic TCP for transactional workloads. */
+ /* it will also look (can look) much like the communication pattern */
+ /* of http for www access. */
+
+int 
+send_tcp_tran_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\n\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int 			one = 1;
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+  int	sock_opt_len = sizeof(int);
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	hostent	        *hp;
+  struct	sockaddr_in	server;
+  struct        sockaddr_in     *myaddr;
+  unsigned      int             addr;
+  int                           myport;
+
+  struct	tcp_tran_rr_request_struct	*tcp_tran_rr_request;
+  struct	tcp_tran_rr_response_struct	*tcp_tran_rr_response;
+  struct	tcp_tran_rr_results_struct	*tcp_tran_rr_result;
+  
+  tcp_tran_rr_request = 
+    (struct tcp_tran_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_tran_rr_response = 
+    (struct tcp_tran_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_tran_rr_result =
+    (struct tcp_tran_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+  
+  myaddr = (struct sockaddr_storage *)malloc(sizeof(struct sockaddr_storage));
+  if (myaddr == NULL) {
+    printf("malloc(%d) failed!\n", sizeof(struct sockaddr_storage));
+    exit(1);
+  }
+
+  bzero((char *)&server,
+	sizeof(server));
+  bzero((char *)myaddr,
+	sizeof(struct sockaddr_storage));
+  myaddr->sin_family = AF_INET;
+
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("TCP Transactional/Request/Response TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_xferd	=	0.0;
+  times_up 	= 	0;
+  
+  /* set-up the data buffers with the requested alignment and offset */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   req_size,
+				   local_send_align,
+				   local_send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   rsp_size,
+				   local_recv_align,
+				   local_recv_offset);
+
+
+  if (debug) {
+    fprintf(where,"send_tcp_tran_rr: send_socket obtained...\n");
+  }
+  
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 8, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type	        =	DO_TCP_TRR;
+  tcp_tran_rr_request->recv_buf_size	=	rsr_size_req;
+  tcp_tran_rr_request->send_buf_size	=	rss_size_req;
+  tcp_tran_rr_request->recv_alignment	=	remote_recv_align;
+  tcp_tran_rr_request->recv_offset	=	remote_recv_offset;
+  tcp_tran_rr_request->send_alignment	=	remote_send_align;
+  tcp_tran_rr_request->send_offset	=	remote_send_offset;
+  tcp_tran_rr_request->request_size	=	req_size;
+  tcp_tran_rr_request->response_size	=	rsp_size;
+  tcp_tran_rr_request->no_delay	        =	rem_nodelay;
+  tcp_tran_rr_request->measure_cpu	=	remote_cpu_usage;
+  tcp_tran_rr_request->cpu_rate	        =	remote_cpu_rate;
+  tcp_tran_rr_request->so_rcvavoid	=	rem_rcvavoid;
+  tcp_tran_rr_request->so_sndavoid	=	rem_sndavoid;
+  if (test_time) {
+    tcp_tran_rr_request->test_length	=	test_time;
+  }
+  else {
+    tcp_tran_rr_request->test_length	=	test_trans * -1;
+  }
+  tcp_tran_rr_request->port             =       atoi(remote_data_port);
+  tcp_tran_rr_request->ipfamily        =       af_to_nf(remote_res->ai_family);
+
+  if (debug > 1) {
+    fprintf(where,"netperf: send_tcp_tran_rr: requesting TCP_TRR 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) {
+    rsr_size	=	tcp_tran_rr_response->recv_buf_size;
+    rss_size	=	tcp_tran_rr_response->send_buf_size;
+    rem_nodelay	=	tcp_tran_rr_response->no_delay;
+    remote_cpu_usage=	tcp_tran_rr_response->measure_cpu;
+    remote_cpu_rate = 	tcp_tran_rr_response->cpu_rate;
+    /* make sure that port numbers are in network order */
+    server.sin_port	=	tcp_tran_rr_response->data_port_number;
+    server.sin_port =	htons(server.sin_port);
+    if (debug) {
+      fprintf(where,"remote listen done.\n");
+      fprintf(where,"remote port is %d\n",ntohs(server.sin_port));
+      fflush(where);
+    }
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    fprintf(where,
+	    "netperf: remote error %d",
+	    netperf_response.content.serv_errno);
+    perror("");
+    fflush(where);
+    exit(1);
+  }
+
+  /* pick a nice random spot between client_port_min and */
+  /* client_port_max for our initial port number. if they are the */
+  /* same, then just set to _min */
+  if (client_port_max - client_port_min) {
+    srand(getpid());
+    myport = client_port_min + 
+      (rand() % (client_port_max - client_port_min));
+  }
+  else {
+    myport = client_port_min;
+  }
+
+  /* there will be a ++ before the first call to bind, so subtract one */
+  myport--;
+  myaddr->sin_port = htons((unsigned short)myport);
+  
+  /* 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)) {
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      /* timestamp just before our call to create the socket, and then */
+      /* again just after the receive raj 3/95 */
+      HIST_timestamp(&time_one);
+    }
+#endif /* WANT_HISTOGRAM */
+
+    /* set up the data socket - is this really necessary or can I just */
+    /* re-use the same socket and move this cal out of the while loop. */
+    /* it does introcudea *boatload* of system calls. I guess that it */
+    /* all depends on "reality of programming." keeping it this way is */
+    /* a bit more conservative I imagine - raj 3/95 */
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket == INVALID_SOCKET) {
+      perror("netperf: send_tcp_tran_rr: tcp stream data socket");
+      exit(1);
+    }
+
+    /* we set SO_REUSEADDR on the premis that no unreserved port */
+    /* number on the local system is going to be already connected to */
+    /* the remote netserver's port number. One thing that I might */
+    /* try later is to have the remote actually allocate a couple of */
+    /* port numbers and cycle through those as well. depends on if we */
+    /* can get through all the unreserved port numbers in less than */
+    /* the length of the TIME_WAIT state raj 8/94 */
+    one = 1;
+    if(setsockopt(send_socket, SOL_SOCKET, SO_REUSEADDR,
+		  (char *)&one, sock_opt_len) == SOCKET_ERROR) {
+      perror("netperf: send_tcp_tran_rr: so_reuseaddr");
+      exit(1);
+    }
+
+newport:
+    /* pick a new port number */
+    myport = ntohs(myaddr->sin_port);
+    myport++;
+
+    /* we do not want to use the port number that the server is */
+    /* sitting at - this would cause us to fail in a loopback test. we */
+    /* could just rely on the failure of the bind to get us past this, */
+    /* but I'm guessing that in this one case at least, it is much */
+    /* faster, given that we *know* that port number is already in use */
+    /* (or rather would be in a loopback test) */
+
+    if (myport == ntohs(server.sin_port)) myport++;
+
+    /* wrap the port number when we get to 65535. NOTE, some broken */
+    /* TCP's might treat the port number as a signed 16 bit quantity. */
+    /* we aren't interested in testing such broken implementations :) */
+    /* raj 8/94  */
+    if (myport >= client_port_max) {
+      myport = client_port_min;
+    }
+    myaddr->sin_port = htons((unsigned short)myport);
+
+    if (debug) {
+      if ((nummessages % 100) == 0) {
+	printf("port %d\n",myport);
+      }
+    }
+
+    /* we want to bind our socket to a particular port number. */
+    if (bind(send_socket,
+	     (struct sockaddr *)myaddr,
+	     sizeof(struct sockaddr_storage)) == SOCKET_ERROR) {
+      /* if the bind failed, someone else must have that port number */
+      /* - perhaps in the listen state. since we can't use it, skip to */
+      /* the next port number. we may have to do this again later, but */
+      /* that's just too bad :) */
+      if (debug > 1) {
+	fprintf(where,
+		"send_tcp_tran_rr: tried to bind to port %d errno %d\n",
+		ntohs(myaddr->sin_port),
+		errno);
+	fflush(where);
+      }
+	/* yes, goto's are supposed to be evil, but they do have their */
+	/* uses from time to time. the real world doesn't always have */
+	/* to code to ge tthe A in CS 101 :) raj 3/95 */
+	goto newport;
+    }
+
+    /* Connect up to the remote port on the data socket. Since this is */
+    /* a test for RFC_1644-style transactional TCP, we can use the */
+    /* sendto() call instead of calling connect and then send() */
+
+    /* send the request */
+    if((len=sendto(send_socket,
+		   send_ring->buffer_ptr,
+		   req_size,
+		   MSG_EOF, 
+		   (struct sockaddr *)&server,
+		   sizeof(server))) != req_size) {
+      if (SOCKET_EINTR(len))
+	  {
+	    /* we hit the end of a */
+	    /* timed test. */
+	    timed_out = 1;
+	    break;
+      }
+      perror("send_tcp_tran_rr: data send error");
+      exit(1);
+    }
+    send_ring = send_ring->next;
+
+    /* receive the response */
+    rsp_bytes_left = rsp_size;
+    temp_message_ptr  = recv_ring->buffer_ptr;
+    while(rsp_bytes_left > 0) {
+      if((rsp_bytes_recvd=recv(send_socket,
+			       temp_message_ptr,
+			       rsp_bytes_left,
+			       0)) == SOCKET_ERROR) {
+	    if (SOCKET_EINTR(rsp_bytes_recvd))
+		{
+	      /* We hit the end of a timed test. */
+	      timed_out = 1;
+	      break;
+		}
+	    perror("send_tcp_tran_rr: data recv error");
+	    exit(1);
+      }
+      rsp_bytes_left -= rsp_bytes_recvd;
+      temp_message_ptr  += rsp_bytes_recvd;
+    }	
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we may have been in a nested while loop - we need */
+      /* another call to break. */
+      break;
+    }
+
+    close(send_socket);
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+    }
+#endif /* WANT_HISTOGRAM */
+
+    nummessages++;          
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug > 3) {
+      fprintf(where,
+	      "Transaction %d completed on local port %d\n",
+	      nummessages,
+	      ntohs(myaddr->sin_port));
+      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);
+    fprintf(where,
+	    "netperf: remote error %d",
+	    netperf_response.content.serv_errno);
+    perror("");
+    fflush(where);
+    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	= (float) -1.0;
+      local_service_demand	= (float) -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 = tcp_tran_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,
+						  tcp_tran_rr_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -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:
+
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+      
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+
+int 
+recv_tcp_tran_rr()
+{
+  
+  char  *message;
+  struct	sockaddr_in        myaddr_in,
+  peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  int   NoPush = 1;
+
+  char	*recv_message_ptr;
+  char	*send_message_ptr;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	tcp_tran_rr_request_struct	*tcp_tran_rr_request;
+  struct	tcp_tran_rr_response_struct	*tcp_tran_rr_response;
+  struct	tcp_tran_rr_results_struct	*tcp_tran_rr_results;
+  
+  tcp_tran_rr_request = 
+    (struct tcp_tran_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_tran_rr_response = 
+    (struct tcp_tran_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_tran_rr_results = 
+    (struct tcp_tran_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_tran_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_tcp_tran_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_TRR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_tran_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_tcp_tran_rr: requested recv alignment of %d offset %d\n",
+	    tcp_tran_rr_request->recv_alignment,
+	    tcp_tran_rr_request->recv_offset);
+    fprintf(where,
+	    "recv_tcp_tran_rr: requested send alignment of %d offset %d\n",
+	    tcp_tran_rr_request->send_alignment,
+	    tcp_tran_rr_request->send_offset);
+    fflush(where);
+  }
+
+  recv_message_ptr = ALIGN_BUFFER(message, tcp_tran_rr_request->recv_alignment, tcp_tran_rr_request->recv_offset);
+  
+  send_message_ptr = ALIGN_BUFFER(message, tcp_tran_rr_request->send_alignment, tcp_tran_rr_request->send_offset);
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_tran_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = htons((unsigned short)tcp_tran_rr_request->port);
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_tran_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_tran_rr_request->send_buf_size;
+  lsr_size_req = tcp_tran_rr_request->recv_buf_size;
+  loc_nodelay = tcp_tran_rr_request->no_delay;
+  loc_rcvavoid = tcp_tran_rr_request->so_rcvavoid;
+  loc_sndavoid = tcp_tran_rr_request->so_sndavoid;
+  
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_tran_rr_request->ipfamily),
+			tcp_tran_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_tran_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    if (debug) {
+      fprintf(where,"could not create data socket\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  if (bind(s_listen,
+	   (struct sockaddr *)&myaddr_in,
+	   sizeof(myaddr_in)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not bind\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+  /* we want to disable the implicit PUSH on all sends. at some point, */
+  /* this might want to be a parm to the test raj 3/95 */
+  if (setsockopt(s_listen,
+		 IPPROTO_TCP,
+		 TCP_NOPUSH, 
+		 (const char *)&NoPush,
+		 sizeof(int)) == SOCKET_ERROR) {
+    fprintf(where,
+	    "recv_tcp_tran_rr: could not set TCP_NOPUSH errno %d\n",
+	    errno);
+    fflush(where);
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+  }
+
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not listen\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not geetsockname\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_tran_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  if (debug) {
+    fprintf(where,"telling the remote to call me at %d\n",
+	    tcp_tran_rr_response->data_port_number);
+    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 0.0 to */
+  /* the initiator. */
+  
+  tcp_tran_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (tcp_tran_rr_request->measure_cpu) {
+    tcp_tran_rr_response->measure_cpu = 1;
+    tcp_tran_rr_response->cpu_rate = 
+      calibrate_local_cpu(tcp_tran_rr_request->cpu_rate);
+  }
+  
+
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_tran_rr_response->send_buf_size = lss_size;
+  tcp_tran_rr_response->recv_buf_size = lsr_size;
+  tcp_tran_rr_response->no_delay = loc_nodelay;
+  tcp_tran_rr_response->so_rcvavoid = loc_rcvavoid;
+  tcp_tran_rr_response->so_sndavoid = loc_sndavoid;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_tran_rr_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (tcp_tran_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(tcp_tran_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = tcp_tran_rr_request->test_length * -1;
+  }
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+
+    /* accept a connection from the remote */
+    if ((s_data=accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+      if (errno == EINTR) {
+	/* the timer popped */
+	timed_out = 1;
+	break;
+      }
+      fprintf(where,"recv_tcp_tran_rr: accept: errno = %d\n",errno);
+      fflush(where);
+      close(s_listen);
+      
+      exit(1);
+    }
+  
+    if (debug) {
+      fprintf(where,"recv_tcp_tran_rr: accepted data connection.\n");
+      fflush(where);
+    }
+  
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+    temp_message_ptr	= recv_message_ptr;
+    request_bytes_remaining	= tcp_tran_rr_request->request_size;
+    
+    /* receive the request from the other side. we can just receive */
+    /* until we get zero bytes, but that would be a slight structure */
+    /* change in the code, with minimal perfomance effects. If */
+    /* however, I has variable-length messages, I would want to do */
+    /* this to avoid needing "double reads" - one for the message */
+    /* length, and one for the rest of the message raj 3/95 */
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	    if ( SOCKET_EINTR(request_bytes_recvd) )
+		{
+	      /* the timer popped */
+	      timed_out = 1;
+	      break;
+		}
+	    netperf_response.content.serv_errno = errno;
+	    send_response();
+	    exit(1);
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+    
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      fprintf(where,"yo5\n");
+      fflush(where);						
+      break;
+    }
+    
+    /* Now, send the response to the remote we can use sendto here to */
+    /* help remind people that this is an rfc 1644 style of test */
+    if((bytes_sent=sendto(s_data,
+			  send_message_ptr,
+			  tcp_tran_rr_request->response_size,
+			  MSG_EOF,
+			  (struct sockaddr *)&peeraddr_in,
+			  sizeof(struct sockaddr_storage))) == SOCKET_ERROR) {
+      if (SOCKET_EINTR(bytes_sent)) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 99;
+      send_response();
+      exit(1);
+    }
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_tcp_tran_rr: Transaction %d complete\n",
+	      trans_received);
+      fflush(where);
+    }
+
+    /* close the connection. since we have disable PUSH on sends, the */
+    /* FIN should be tacked-onto our last send instead of being */
+    /* standalone */
+    close(s_data);
+
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(tcp_tran_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_tcp_tran_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  tcp_tran_rr_results->bytes_received	= (trans_received * 
+					   (tcp_tran_rr_request->request_size + 
+					    tcp_tran_rr_request->response_size));
+  tcp_tran_rr_results->trans_received	= trans_received;
+  tcp_tran_rr_results->elapsed_time	= elapsed_time;
+  if (tcp_tran_rr_request->measure_cpu) {
+    tcp_tran_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_tran_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+#endif /* DO_1644 */
+
+#ifdef DO_NBRR
+ /* this routine implements the sending (netperf) side of the TCP_RR */
+ /* test using POSIX-style non-blocking sockets. */
+
+void
+send_tcp_nbrr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	hostent	        *hp;
+  struct	sockaddr_storage	server;
+  unsigned      int             addr;
+  
+  struct	tcp_rr_request_struct	*tcp_rr_request;
+  struct	tcp_rr_response_struct	*tcp_rr_response;
+  struct	tcp_rr_results_struct	*tcp_rr_result;
+
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+
+  tcp_rr_request = 
+    (struct tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_rr_response=
+    (struct tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_rr_result	=
+    (struct tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+
+  bzero((char *)&server,
+	sizeof(server));
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("TCP Non-Blocking REQUEST/RESPONSE TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_tcp_nbrr: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_tcp_nbrr: send_socket obtained...\n");
+    }
+  
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back.*/
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 8, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type	=	DO_TCP_NBRR;
+    tcp_rr_request->recv_buf_size	=	rsr_size_req;
+    tcp_rr_request->send_buf_size	=	rss_size_req;
+    tcp_rr_request->recv_alignment      =	remote_recv_align;
+    tcp_rr_request->recv_offset	        =	remote_recv_offset;
+    tcp_rr_request->send_alignment      =	remote_send_align;
+    tcp_rr_request->send_offset	        =	remote_send_offset;
+    tcp_rr_request->request_size	=	req_size;
+    tcp_rr_request->response_size	=	rsp_size;
+    tcp_rr_request->no_delay	        =	rem_nodelay;
+    tcp_rr_request->measure_cpu	        =	remote_cpu_usage;
+    tcp_rr_request->cpu_rate	        =	remote_cpu_rate;
+    tcp_rr_request->so_rcvavoid	        =	rem_rcvavoid;
+    tcp_rr_request->so_sndavoid	        =	rem_sndavoid;
+    if (test_time) {
+      tcp_rr_request->test_length	=	test_time;
+    }
+    else {
+      tcp_rr_request->test_length	=	test_trans * -1;
+    }
+    
+    if (debug > 1) {
+      fprintf(where,"netperf: send_tcp_nbrr: requesting TCP rr test\n");
+    }
+    
+    send_request();
+    
+    /* The response from the remote will contain all of the relevant 	*/
+    /* socket parameters for this test type. We will put them back into */
+    /* the variables here so they can be displayed if desired.  The	*/
+    /* remote will have calibrated CPU if necessary, and will have done	*/
+    /* all the needed set-up we will have calibrated the cpu locally	*/
+    /* before sending the request, and will grab the counter value right*/
+    /* after the connect returns. The remote will grab the counter right*/
+    /* after the accept call. This saves the hassle of extra messages	*/
+    /* being sent for the TCP tests.					*/
+  
+    recv_response();
+  
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size          = tcp_rr_response->recv_buf_size;
+      rss_size          = tcp_rr_response->send_buf_size;
+      rem_nodelay       = tcp_rr_response->no_delay;
+      remote_cpu_usage  = tcp_rr_response->measure_cpu;
+      remote_cpu_rate   = tcp_rr_response->cpu_rate;
+      /* make sure that port numbers are in network order */
+      server.sin_port   = (unsigned short)tcp_rr_response->data_port_number;
+      server.sin_port   = htons(server.sin_port);
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      exit(1);
+    }
+    
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: data socket connect failed");
+      
+      exit(1);
+    }
+    
+    /* now that we are connected, mark the socket as non-blocking */
+    if (!set_nonblock(send_socket)) {
+      perror("netperf: set_nonblock");
+      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);
+
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+    
+    /* We use an "OR" to control test execution. When the test is */
+    /* controlled by time, the byte count check will always return false. */
+    /* When the test is controlled by byte count, the time test will */
+    /* always return false. When the test is finished, the whole */
+    /* expression will go false and we will stop sending data. I think I */
+    /* just arbitrarily decrement trans_remaining for the timed test, but */
+    /* will not do that just yet... One other question is whether or not */
+    /* the send buffer and the receive buffer should be the same buffer. */
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before our call to send, and then again just */
+	/* after the receive raj 8/94 */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+
+      /* even though this is a non-blocking socket, we will assume for */
+      /* the time being that we will be able to send an entire request */
+      /* without getting an EAGAIN */
+      if((len=send(send_socket,
+		   send_ring->buffer_ptr,
+		   req_size,
+		   0)) != req_size) {
+	if (SOCKET_EINTR(len)) {
+	  /* we hit the end of a */
+	  /* timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_tcp_nbrr: data send error");
+	exit(1);
+      }
+      send_ring = send_ring->next;
+      
+      /* receive the response. since we are using non-blocking I/O, we */
+      /* will "spin" on the recvs */
+      rsp_bytes_left = rsp_size;
+      temp_message_ptr  = recv_ring->buffer_ptr;
+      while(rsp_bytes_left > 0) {
+	if((rsp_bytes_recvd=recv(send_socket,
+				 temp_message_ptr,
+				 rsp_bytes_left,
+				 0)) == SOCKET_ERROR) {
+	  if (SOCKET_EINTR(rsp_bytes_recvd))
+	  {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+#ifndef WIN32  // But what does WinNT indicate in this situation...
+	  else if (errno == EAGAIN) {
+	    Set_errno(0);
+	    continue;
+	  }
+#endif
+	  else {
+	    perror("send_tcp_nbrr: data recv error");
+	    exit(1);
+	  }
+	}
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr  += rsp_bytes_recvd;
+      }	
+      recv_ring = recv_ring->next;
+      
+      if (timed_out) {
+	/* we may have been in a nested while loop - we need */
+	/* another call to break. */
+	break;
+      }
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  fprintf(where,
+		  "Transaction %d completed\n",
+		  nummessages);
+	  fflush(where);
+	}
+      }
+    }
+
+    /* At this point we used to call shutdown on the data socket to be */
+    /* sure all the data was delivered, but this was not germane in a */
+    /* request/response test, and it was causing the tests to "hang" when */
+    /* they were being controlled by time. So, I have replaced this */
+    /* shutdown call with a call to close that can be found later in the */
+    /* procedure. */
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured? how long */
+						/* did we really run? */
+    
+    /* Get the statistics from the remote end. The remote will have */
+    /* calculated service demand and all those interesting things. If it */
+    /* wasn't supposed to care, it will return obvious values. */
+    
+    recv_response();
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote results obtained\n");
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+    
+    /* We now calculate what our thruput was for the test. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = tcp_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,
+						    tcp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    close(send_socket);
+
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(tcp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      thruput,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+ /* this routine implements the receive (netserver) side of a TCP_RR */
+ /* test */
+void 
+recv_tcp_nbrr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct	sockaddr_in        myaddr_in,
+  peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+  
+  struct	tcp_rr_request_struct	*tcp_rr_request;
+  struct	tcp_rr_response_struct	*tcp_rr_response;
+  struct	tcp_rr_results_struct	*tcp_rr_results;
+  
+  tcp_rr_request = 
+    (struct tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  tcp_rr_response =
+    (struct tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  tcp_rr_results =
+    (struct tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_nbrr: 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_tcp_nbrr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_nbrr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_tcp_nbrr: requested recv alignment of %d offset %d\n",
+	    tcp_rr_request->recv_alignment,
+	    tcp_rr_request->recv_offset);
+    fprintf(where,"recv_tcp_nbrr: requested send alignment of %d offset %d\n",
+	    tcp_rr_request->send_alignment,
+	    tcp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   tcp_rr_request->response_size,
+				   tcp_rr_request->send_alignment,
+				   tcp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   tcp_rr_request->request_size,
+				   tcp_rr_request->recv_alignment,
+				   tcp_rr_request->recv_offset);
+
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = htons((unsigned short)tcp_rr_request->port);
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_nbrr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_rr_request->send_buf_size;
+  lsr_size_req = tcp_rr_request->recv_buf_size;
+  loc_nodelay = tcp_rr_request->no_delay;
+  loc_rcvavoid = tcp_rr_request->so_rcvavoid;
+  loc_sndavoid = tcp_rr_request->so_sndavoid;
+  
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_rr_request->ipfamily),
+			tcp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  if (bind(s_listen,
+	   (struct sockaddr *)&myaddr_in,
+	   sizeof(myaddr_in)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in, &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  tcp_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  tcp_rr_response->measure_cpu = 0;
+
+  if (tcp_rr_request->measure_cpu) {
+    tcp_rr_response->measure_cpu = 1;
+    tcp_rr_response->cpu_rate = calibrate_local_cpu(tcp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_rr_response->send_buf_size = lss_size;
+  tcp_rr_response->recv_buf_size = lsr_size;
+  tcp_rr_response->no_delay = loc_nodelay;
+  tcp_rr_response->so_rcvavoid = loc_rcvavoid;
+  tcp_rr_response->so_sndavoid = loc_sndavoid;
+  tcp_rr_response->test_length = tcp_rr_request->test_length;
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  if ((s_data = accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_nbrr: accept completes on the data connection.\n");
+    fflush(where);
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+    
+  /* now that we are connected, mark the socket as non-blocking */
+  if (!set_nonblock(s_data)) {
+    close(s_data);
+    exit(1);
+  }
+
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_rr_request->measure_cpu);
+
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (tcp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(tcp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = tcp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining	= tcp_rr_request->request_size;
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	    if ( SOCKET_EINTR(request_bytes_recvd))
+		{
+	      /* the timer popped */
+	      timed_out = 1;
+	      break;
+		}
+#ifndef WIN32  // But what does WinNT indicate in this situation...
+	    else if (errno == EAGAIN) {
+	      Set_errno(0);
+	      if (times_up) {
+	        timed_out = 1;
+	        break;
+		  }
+	      continue;
+		}
+#endif
+	    else {
+	      netperf_response.content.serv_errno = errno;
+	      send_response();
+	      exit(1);
+		}
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      fprintf(where,"yo5\n");
+      fflush(where);						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=send(s_data,
+			send_ring->buffer_ptr,
+			tcp_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (SOCKET_EINTR(bytes_sent)) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 992;
+      send_response();
+      exit(1);
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(tcp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer();
+
+  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_tcp_nbrr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  tcp_rr_results->bytes_received = (trans_received * 
+				    (tcp_rr_request->request_size + 
+				     tcp_rr_request->response_size));
+  tcp_rr_results->trans_received = trans_received;
+  tcp_rr_results->elapsed_time   = elapsed_time;
+  tcp_rr_results->cpu_method     = cpu_method;
+  tcp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (tcp_rr_request->measure_cpu) {
+    tcp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_nbrr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are done with the socket, free it */
+  close(s_data);
+
+  send_response();
+  
+}
+
+#endif /* DO_NBRR */
+
+
+ /* this test is intended to test the performance of establishing a */
+ /* connection, and then closing it again. this test is of somewhat */
+ /* arcane interest since no packets are exchanged between the */
+ /* user-space processes, but it will show the raw overhead of */
+ /* establishing a TCP connection. that service demand could then be */
+ /* compared with the sum of the service demands of a TCP_CRR and */
+ /* TCP_RR test - presumeably, they would all relate */
+
+void
+send_tcp_cc(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\n\
+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;
+  
+  char	temp_message_ptr[1];
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+  int	rsp_bytes_left = 1;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+
+  int                           myport;
+  int                           ret;
+
+  struct	tcp_cc_request_struct	*tcp_cc_request;
+  struct	tcp_cc_response_struct	*tcp_cc_response;
+  struct	tcp_cc_results_struct	*tcp_cc_result;
+  
+  tcp_cc_request = 
+    (struct tcp_cc_request_struct *)netperf_request.content.test_specific_data;
+  tcp_cc_response = 
+    (struct tcp_cc_response_struct *)netperf_response.content.test_specific_data;
+  tcp_cc_result =
+    (struct tcp_cc_results_struct *)netperf_response.content.test_specific_data;
+  
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("TCP Connect/Close TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_xferd	=	0.0;
+  times_up 	= 	0;
+  
+  /* since there are no data buffers in this test, we need no send or */
+  /* recv rings */
+
+  if (debug) {
+    fprintf(where,"send_tcp_cc: send_socket obtained...\n");
+  }
+  
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 8, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type	=	DO_TCP_CC;
+  tcp_cc_request->recv_buf_size	        =	rsr_size_req;
+  tcp_cc_request->send_buf_size	        =	rss_size_req;
+  tcp_cc_request->recv_alignment	=	remote_recv_align;
+  tcp_cc_request->recv_offset	        =	remote_recv_offset;
+  tcp_cc_request->send_alignment	=	remote_send_align;
+  tcp_cc_request->send_offset	        =	remote_send_offset;
+  tcp_cc_request->request_size	        =	req_size;
+  tcp_cc_request->response_size	        =	rsp_size;
+  tcp_cc_request->no_delay	        =	rem_nodelay;
+  tcp_cc_request->measure_cpu	        =	remote_cpu_usage;
+  tcp_cc_request->cpu_rate	        =	remote_cpu_rate;
+  tcp_cc_request->so_rcvavoid	=	rem_rcvavoid;
+  tcp_cc_request->so_sndavoid	=	rem_sndavoid;
+  if (test_time) {
+    tcp_cc_request->test_length	=	test_time;
+  }
+  else {
+    tcp_cc_request->test_length	=	test_trans * -1;
+  }
+  tcp_cc_request->port          = atoi(remote_data_port);
+  tcp_cc_request->ipfamily  = af_to_nf(remote_res->ai_family);
+
+  if (debug > 1) {
+    fprintf(where,"netperf: send_tcp_cc: requesting TCP crr 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) {
+    rsr_size	=	tcp_cc_response->recv_buf_size;
+    rss_size	=	tcp_cc_response->send_buf_size;
+    rem_nodelay	=	tcp_cc_response->no_delay;
+    remote_cpu_usage=	tcp_cc_response->measure_cpu;
+    remote_cpu_rate = 	tcp_cc_response->cpu_rate;
+    /* make sure that port numbers are in network order */
+    set_port_number(remote_res,(unsigned short)tcp_cc_response->data_port_number);
+
+    if (debug) {
+      fprintf(where,"remote listen done.\n");
+      fprintf(where,"remote port is %d\n",get_port_number(remote_res));
+      fflush(where);
+    }
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    fprintf(where,
+	    "netperf: remote error %d",
+	    netperf_response.content.serv_errno);
+    perror("");
+    fflush(where);
+    exit(1);
+  }
+
+#ifdef WANT_DEMO
+  DEMO_RR_SETUP(100)
+#endif
+  
+  /* pick a nice random spot between client_port_min and */
+  /* client_port_max for our initial port number */
+  srand(getpid());
+  if (client_port_max - client_port_min) {
+    myport = client_port_min + 
+      (rand() % (client_port_max - client_port_min));
+  }
+  else {
+    myport = client_port_min;
+  }
+  /* there will be a ++ before the first call to bind, so subtract one */
+  myport--;
+  
+  /* 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);
+
+#ifdef WANT_DEMO
+  if (demo_mode) {
+    HIST_timestamp(demo_one_ptr);
+  }
+#endif
+
+  /* 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)) {
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      /* timestamp just before our call to create the socket, and then */
+      /* again just after the receive raj 3/95 */
+      HIST_timestamp(&time_one);
+    }
+#endif /* WANT_HISTOGRAM */
+
+    /* set up the data socket */
+    /* newport: is this label really required any longer? */
+    /* pick a new port number */
+    myport++;
+
+    /* wrap the port number when we get to client_port_max. NOTE, some */
+    /* broken TCP's might treat the port number as a signed 16 bit */
+    /* quantity.  we aren't interested in testing such broken */
+    /* implementations :) so we won't make sure that it is below 32767 */
+    /* raj 8/94  */
+    if (myport >= client_port_max) {
+      myport = client_port_min;
+    }
+
+    /* we do not want to use the port number that the server is */
+    /* sitting at - this would cause us to fail in a loopback test. we */
+    /* could just rely on the failure of the bind to get us past this, */
+    /* but I'm guessing that in this one case at least, it is much */
+    /* faster, given that we *know* that port number is already in use */
+    /* (or rather would be in a loopback test) */
+
+    if (myport == get_port_number(remote_res)) myport++;
+
+    if (debug) {
+      if ((nummessages % 100) == 0) {
+	printf("port %d\n",myport);
+      }
+    }
+    set_port_number(local_res, (unsigned short)myport);
+    send_socket = create_data_socket(local_res);
+
+    if (send_socket == INVALID_SOCKET) {
+      perror("netperf: send_tcp_cc: tcp stream data socket");
+      exit(1);
+    }
+
+    /* we used to have a call to bind() here, but that is being
+       taken care of by create_data_socket(). raj 2005-02-08 */
+
+    /* Connect up to the remote port on the data socket  */
+    if ((ret = connect(send_socket, 
+		       remote_res->ai_addr,
+		       remote_res->ai_addrlen)) == INVALID_SOCKET){
+      if (SOCKET_EINTR(ret))
+	  {
+	    /* we hit the end of a */
+	    /* timed test. */
+	    timed_out = 1;
+	    break;
+      }
+      perror("netperf: data socket connect failed");
+      printf("\tattempted to connect on socket %d to port %d",
+	     send_socket,
+	     get_port_number(remote_res));
+      printf(" from port %u \n",get_port_number(local_res));
+      exit(1);
+    }
+
+    /* we hang in a recv() to get the remote's close indication */
+
+    rsp_bytes_recvd=recv(send_socket,
+			 temp_message_ptr,
+			 rsp_bytes_left,
+			 0);
+
+
+    if (rsp_bytes_recvd == 0) {
+      /* connection close, call close. we assume that the requisite */
+      /* number of bytes have been received */
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_DEMO
+      DEMO_RR_INTERVAL(1)
+#endif
+
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+    
+      if (debug > 3) {
+	fprintf(where,
+		"Transaction %d completed on local port %u\n",
+		nummessages,
+		get_port_number(local_res));
+	fflush(where);
+      }
+
+      close(send_socket);
+
+    }
+    else {
+      /* it was less than zero - an error occured */
+      if (SOCKET_EINTR(rsp_bytes_recvd))
+	  {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+	  perror("send_tcp_cc: data recv 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);
+    fprintf(where,
+	    "netperf: remote error %d",
+	     netperf_response.content.serv_errno);
+    perror("");
+    fflush(where);
+      
+    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	= (float) -1.0;
+      local_service_demand	= (float) -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 = tcp_cc_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,
+						  tcp_cc_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -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:
+
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+      
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+
+void
+recv_tcp_cc()
+{
+  
+  char  *message;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct	sockaddr_storage        myaddr_in,  peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  char	*recv_message_ptr;
+  char	*send_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	tcp_cc_request_struct	*tcp_cc_request;
+  struct	tcp_cc_response_struct	*tcp_cc_response;
+  struct	tcp_cc_results_struct	*tcp_cc_results;
+  
+  tcp_cc_request = 
+    (struct tcp_cc_request_struct *)netperf_request.content.test_specific_data;
+  tcp_cc_response = 
+    (struct tcp_cc_response_struct *)netperf_response.content.test_specific_data;
+  tcp_cc_results = 
+    (struct tcp_cc_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_tcp_cc: 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_tcp_cc: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = TCP_CC_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_cc: 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_tcp_cc: requested recv alignment of %d offset %d\n",
+	    tcp_cc_request->recv_alignment,
+	    tcp_cc_request->recv_offset);
+    fprintf(where,
+	    "recv_tcp_cc: requested send alignment of %d offset %d\n",
+	    tcp_cc_request->send_alignment,
+	    tcp_cc_request->send_offset);
+    fflush(where);
+  }
+
+  recv_message_ptr = ALIGN_BUFFER(message, tcp_cc_request->recv_alignment, tcp_cc_request->recv_offset);
+  
+  send_message_ptr = ALIGN_BUFFER(message, tcp_cc_request->send_alignment, tcp_cc_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_tcp_cc: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_tcp_cc: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = tcp_cc_request->send_buf_size;
+  lsr_size_req = tcp_cc_request->recv_buf_size;
+  loc_nodelay = tcp_cc_request->no_delay;
+  loc_rcvavoid = tcp_cc_request->so_rcvavoid;
+  loc_sndavoid = tcp_cc_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(tcp_cc_request->ipfamily),
+			tcp_cc_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(tcp_cc_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    if (debug) {
+      fprintf(where,"could not create data socket\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not listen\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not geetsockname\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  tcp_cc_response->data_port_number = 
+    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
+  if (debug) {
+    fprintf(where,"telling the remote to call me at %d\n",
+	    tcp_cc_response->data_port_number);
+    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 0.0 to */
+  /* the initiator. */
+  
+  tcp_cc_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (tcp_cc_request->measure_cpu) {
+    tcp_cc_response->measure_cpu = 1;
+    tcp_cc_response->cpu_rate = 
+      calibrate_local_cpu(tcp_cc_request->cpu_rate);
+  }
+  
+
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  tcp_cc_response->send_buf_size = lss_size;
+  tcp_cc_response->recv_buf_size = lsr_size;
+  tcp_cc_response->no_delay = loc_nodelay;
+  tcp_cc_response->so_rcvavoid = loc_rcvavoid;
+  tcp_cc_response->so_sndavoid = loc_sndavoid;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(tcp_cc_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (tcp_cc_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(tcp_cc_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = tcp_cc_request->test_length * -1;
+  }
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+#ifdef WIN32
+    /* The test timer will probably fire during this accept, 
+       so to make the start_timer above work we have to move
+       it to close s_listen while we are blocked on accept. */
+    win_kludge_socket = s_listen;
+#endif
+    /* accept a connection from the remote */
+    if ((s_data=accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+      if (errno == EINTR) {
+	/* the timer popped */
+	timed_out = 1;
+	break;
+      }
+      fprintf(where,"recv_tcp_cc: accept: errno = %d\n",errno);
+      fflush(where);
+      close(s_listen);
+      
+      exit(1);
+    }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+    /* this is for those systems which *INCORRECTLY* fail to pass */
+    /* attributes across an accept() call. Including this goes against */
+    /* my better judgement :( raj 11/95 */
+    
+    kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+
+    if (debug) {
+      fprintf(where,"recv_tcp_cc: accepted data connection.\n");
+      fflush(where);
+    }
+  
+
+    /* close the connection. the server will likely do a graceful */
+    /* close of the connection, insuring that all data has arrived at */
+    /* the client. for this it will call shutdown(), and then recv() and */
+    /* then close(). I'm reasonably confident that this is the */
+    /* appropriate sequence of calls - I would like to hear of */
+    /* examples in web servers to the contrary. raj 10/95*/
+    close(s_data);
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_tcp_cc: Transaction %d complete\n",
+	      trans_received);
+      fflush(where);
+    }
+
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(tcp_cc_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_tcp_cc: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  tcp_cc_results->bytes_received	= (trans_received * 
+					   (tcp_cc_request->request_size + 
+					    tcp_cc_request->response_size));
+  tcp_cc_results->trans_received	= trans_received;
+  tcp_cc_results->elapsed_time	= elapsed_time;
+  if (tcp_cc_request->measure_cpu) {
+    tcp_cc_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_tcp_cc: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+
+void
+print_sockets_usage()
+{
+
+  fwrite(sockets_usage, sizeof(char), strlen(sockets_usage), stdout);
+  exit(1);
+
+}
+
+void
+scan_sockets_args(int argc, char *argv[])
+
+{
+
+#define SOCKETS_ARGS "b:CDnNhH:L:m:M:p:P:r:s:S:T:Vw:W:z46"
+
+  extern char	*optarg;	  /* pointer to option string	*/
+  
+  int		c;
+  
+  char	
+    arg1[BUFSIZ],  /* argument holders		*/
+    arg2[BUFSIZ];
+
+  if (debug) {
+    int i;
+    printf("%s called with the following argument vector\n",
+	   __func__);
+    for (i = 0; i< argc; i++) {
+      printf("%s ",argv[i]);
+    }
+    printf("\n");
+  }
+
+  strncpy(local_data_port,"0",sizeof(local_data_port));
+  strncpy(remote_data_port,"0",sizeof(remote_data_port));
+
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form "first," (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, SOCKETS_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case '4':
+      remote_data_family = AF_INET;
+      local_data_family = AF_INET;
+      break;
+    case '6':
+#if defined(AF_INET6)
+      remote_data_family = AF_INET6;
+      local_data_family = AF_INET6;
+#else
+      fprintf(stderr,
+	      "This netperf was not compiled on an IPv6 capable host!\n");
+      fflush(stderr);
+      exit(-1);
+#endif
+      break;
+    case 'h':
+      print_sockets_usage();
+      exit(1);
+    case 'b':
+#ifdef WANT_FIRST_BURST
+      first_burst_size = atoi(optarg);
+#else /* WANT_FIRST_BURST */
+      printf("Initial request burst functionality not compiled-in!\n");
+#endif /* WANT_FIRST_BURST */
+      break;
+    case 'C':
+#ifdef TCP_CORK
+      /* set TCP_CORK */
+      loc_tcpcork = 1;
+      rem_tcpcork = 1; /* however, at first, we ony have cork affect loc */
+#else 
+      printf("WARNING: TCP_CORK not available on this platform!\n");
+#endif /* TCP_CORK */
+      break;
+    case 'D':
+      /* set the TCP nodelay flag */
+      loc_nodelay = 1;
+      rem_nodelay = 1;
+      break;
+    case 'H':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	remote_data_address = malloc(strlen(arg1)+1);
+	strncpy(remote_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	remote_data_family = parse_address_family(arg2);
+      break;
+    case 'L':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	local_data_address = malloc(strlen(arg1)+1);
+	strncpy(local_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	local_data_family = parse_address_family(arg2);
+      break;
+    case 's':
+      /* set local socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	lss_size_req = convert(arg1);
+      if (arg2[0])
+	lsr_size_req = convert(arg2);
+      break;
+    case 'S':
+      /* set remote socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	rss_size_req = convert(arg1);
+      if (arg2[0])
+	rsr_size_req = convert(arg2);
+      break;
+    case 'r':
+      /* set the request/response sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	req_size = convert(arg1);
+      if (arg2[0])	
+	rsp_size = convert(arg2);
+      break;
+    case 'm':
+      /* set the send size */
+      send_size = convert(optarg);
+      break;
+    case 'M':
+      /* set the recv size */
+      recv_size = convert(optarg);
+      break;
+    case 'n':
+      /* set the local socket type*/
+      local_connected = 1;
+      break;
+    case 'N':
+      /* set the remote socket type*/
+      remote_connected = 1;
+      break;
+    case 'p':
+      /* set the min and max port numbers for the TCP_CRR and TCP_TRR */
+      /* tests. */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	client_port_min = atoi(arg1);
+      if (arg2[0])	
+	client_port_max = atoi(arg2);
+      break;
+    case 'P':
+      /* set the local and remote data port numbers for the tests to
+	 allow them to run through those blankety blank end-to-end
+	 breaking firewalls. raj 2004-06-15 */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(local_data_port,arg1,sizeof(local_data_port));
+      if (arg2[0])	
+	strncpy(remote_data_port,arg2,sizeof(remote_data_port));
+      break;
+    case 't':
+      /* set the test name */
+      strcpy(test_name,optarg);
+      break;
+    case 'W':
+      /* set the "width" of the user space data */
+      /* buffer. This will be the number of */
+      /* send_size buffers malloc'd in the */
+      /* *_STREAM test. It may be enhanced to set */
+      /* both send and receive "widths" but for now */
+      /* it is just the sending *_STREAM. */
+      send_width = convert(optarg);
+      break;
+    case 'V' :
+      /* we want to do copy avoidance and will set */
+      /* it for everything, everywhere, if we really */
+      /* can. of course, we don't know anything */
+      /* about the remote... */
+#ifdef SO_SND_COPYAVOID
+      loc_sndavoid = 1;
+#else
+      loc_sndavoid = 0;
+      printf("Local send copy avoidance not available.\n");
+#endif
+#ifdef SO_RCV_COPYAVOID
+      loc_rcvavoid = 1;
+#else
+      loc_rcvavoid = 0;
+      printf("Local recv copy avoidance not available.\n");
+#endif
+      rem_sndavoid = 1;
+      rem_rcvavoid = 1;
+      break;
+    };
+  }
+
+#if defined(WANT_FIRST_BURST) 
+#if defined(WANT_HISTOGRAM)
+  /* if WANT_FIRST_BURST and WANT_HISTOGRAM are defined and the user
+     indeed wants a non-zero first burst size, and we would emit a
+     histogram, then we should emit a warning that the two are not
+     compatible. raj 2006-01-31 */
+  if ((first_burst_size > 0) && (verbosity >= 2)) {
+    fprintf(stderr,
+	    "WARNING! Histograms and first bursts are incompatible!\n");
+    fflush(stderr);
+  }
+#endif
+#endif
+
+  /* we do not want to make remote_data_address non-NULL because if
+     the user has not specified a remote adata address, we want to
+     take it from the hostname in the -H global option. raj
+     2005-02-08 */
+
+  /* so, if there is to be no control connection, we want to have some
+     different settings for a few things */
+
+  if (no_control) {
+
+    if (strcmp(remote_data_port,"0") == 0) {
+      /* we need to select either the discard port, echo port or
+	 chargen port dedepending on the test name. raj 2007-02-08 */
+      if (strstr(test_name,"STREAM") ||
+	  strstr(test_name,"SENDFILE")) {
+	strncpy(remote_data_port,"discard",sizeof(remote_data_port));
+      }
+      else if (strstr(test_name,"RR")) {
+	strncpy(remote_data_port,"echo",sizeof(remote_data_port));
+      }
+      else if (strstr(test_name,"MAERTS")) {
+	strncpy(remote_data_port,"chargen",sizeof(remote_data_port));
+      }
+      else {
+	printf("No default port known for the %s test, please set one yourself\n",test_name);
+	exit(-1);
+      }
+    }
+    remote_data_port[sizeof(remote_data_port) - 1] = '\0';
+
+    /* I go back and forth on whether these should become -1 or if
+       they should become 0 for a no_control test. what do you think?
+       raj 2006-02-08 */
+
+    rem_rcvavoid = -1;
+    rem_sndavoid = -1;
+    rss_size_req = -1;
+    rsr_size_req = -1;
+    rem_nodelay = -1;
+
+    if (strstr(test_name,"STREAM") ||
+	strstr(test_name,"SENDFILE")) {
+      recv_size = -1;
+    }
+    else if (strstr(test_name,"RR")) {
+      /* I am however _certain_ that for a no control RR test the
+	 response size must equal the request size since 99 times out
+	 of ten we will be speaking to the echo service somewhere */
+      rsp_size = req_size;
+    }
+    else if (strstr(test_name,"MAERTS")) {
+      send_size = -1;
+    }
+    else {
+      printf("No default port known for the %s test, please set one yourself\n",test_name);
+      exit(-1);
+    }
+  }
+}
diff --git a/nettest_bsd.h b/nettest_bsd.h
new file mode 100644
index 0000000..5491290
--- /dev/null
+++ b/nettest_bsd.h
@@ -0,0 +1,471 @@
+/*
+        Copyright (C) 1993-2004 Hewlett-Packard Company
+*/
+
+ /* This file contains the test-specific definitions for netperf's BSD */
+ /* sockets tests */
+
+/* well boys and girls, seems that while AF_INET is "2" and AF_UNSPEC
+   is "0" the world over, AF_INET6 is different values depending on
+   the platform... grrr.  On HP-UX 11i it is "22" and on Linux 2.6 it
+   is "10" sooooo... we have to define our own space for netperf to
+   enable us to pass values around from machine to machine. raj
+   2005-02-08 */
+#define NF_UNSPEC 0
+#define NF_INET   4
+#define NF_INET6  6
+
+struct	tcp_stream_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	receive_size;   /* how many bytes do we want to receive at one */
+			/* time? */ 
+  int	recv_alignment; /* what is the alignment of the receive */
+			/* buffer? */ 
+  int	recv_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;       /* the address family of ipaddress */
+};
+
+struct	tcp_stream_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	receive_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_stream_results_struct {
+  double         bytes_received;
+  unsigned int	 recv_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	tcp_maerts_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	send_size;      /* how many bytes do we want netserver to send
+			   at one time? */
+  int	send_alignment; /* what is the alignment of the send */
+			/* buffer? */ 
+  int	send_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the send buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+struct	tcp_maerts_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_maerts_results_struct {
+  double         bytes_sent;
+  unsigned int	 send_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	tcp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+struct	tcp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_rr_results_struct {
+  unsigned int  bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	tcp_conn_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+
+struct	tcp_conn_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_conn_rr_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	tcp_tran_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+
+struct	tcp_tran_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_tran_rr_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+
+};
+
+struct	udp_stream_request_struct {
+  int	recv_buf_size;
+  int	message_size;
+  int   recv_connected;
+  int	recv_alignment;
+  int	recv_offset;
+  int	checksum_off;
+  int	measure_cpu;
+  float	cpu_rate;
+  int	test_length;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+  
+};
+
+struct	udp_stream_response_struct {
+  int	recv_buf_size;
+  int	send_buf_size;
+  int	measure_cpu;
+  int	test_length;
+  int	data_port_number;
+  float	cpu_rate;
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct	udp_stream_results_struct {
+  unsigned int	messages_recvd;
+  unsigned int	bytes_received;
+  float	        elapsed_time;
+  float	        cpu_util;
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+
+struct	udp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+struct	udp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct udp_rr_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	tcp_cc_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+
+struct	tcp_cc_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct tcp_cc_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+extern int   rss_size_req,     /* requested remote socket send buffer size */
+	     rsr_size_req,     /* requested remote socket recv buffer size */
+	     rss_size,         /* remote socket send buffer size       */
+	     rsr_size,         /* remote socket recv buffer size       */
+	     lss_size_req,     /* requested local socket send buffer size */
+	     lsr_size_req,     /* requested local socket recv buffer size */
+	     lss_size,         /* local  socket send buffer size       */
+	     lsr_size,         /* local  socket recv buffer size       */
+	     req_size,         /* request size                         */
+	     rsp_size,         /* response size                        */
+	     send_size,        /* how big are individual sends         */
+	     recv_size,        /* how big are individual receives      */
+	     loc_nodelay,          /* don't/do use NODELAY locally         */
+	     rem_nodelay,          /* don't/do use NODELAY remotely        */
+	     loc_sndavoid,         /* avoid send copies locally            */
+	     loc_rcvavoid,         /* avoid recv copies locally            */
+	     rem_sndavoid,         /* avoid send copies remotely           */
+	     rem_rcvavoid;         /* avoid recv_copies remotely           */
+
+
+extern void scan_sockets_args(int argc, char *argv[]);
+extern struct addrinfo *complete_addrinfo(char *controlhost, 
+				   char *data_address, 
+				   char *port, 
+				   int family, 
+				   int type, 
+				   int protocol, 
+				   int flags);
+extern void complete_addrinfos(struct addrinfo **remote,
+			       struct addrinfo **local, 
+			       char remote_host[], 
+			       int type, 
+			       int protocol, 
+			       int flags);
+extern int af_to_nf(int af);
+extern int nf_to_af(int nf);
+extern void print_top_test_header(char test_name[], 
+				  struct addrinfo *source, 
+				  struct addrinfo *destination);
+extern void set_port_number(struct addrinfo *res, 
+			    unsigned short port);
+extern void set_hostname_and_port(char *hostname, 
+				  char *portstr, 
+				  int family, 
+				  int port);
+extern void send_tcp_stream(char remote_host[]);
+extern void send_tcp_maerts(char remote_host[]);
+extern void send_tcp_rr(char remote_host[]);
+extern void send_tcp_conn_rr(char remote_host[]);
+extern void send_tcp_cc(char remote_host[]);
+extern void send_udp_stream(char remote_host[]);
+extern void send_udp_rr(char remote_host[]);
+
+extern void recv_tcp_stream();
+extern void recv_tcp_maerts();
+extern void recv_tcp_rr();
+extern void recv_tcp_conn_rr();
+extern void recv_tcp_cc();
+extern void recv_udp_stream();
+extern void recv_udp_rr();
+
+extern void loc_cpu_rate();
+extern void rem_cpu_rate();
+
+#ifdef HAVE_ICSC_EXS
+extern void send_exs_tcp_stream(char remotehost[]);
+#endif /* HAVE_ICSC_EXS */
+
+#ifdef HAVE_SENDFILE
+extern void sendfile_tcp_stream(char remotehost[]);
+#endif /* HAVE_SENDFILE */
+
+#if !defined(HAVE_STRUCT_SOCKADDR_STORAGE) && !defined(sockaddr_storage)
+#define sockaddr_storage sockaddr_in
+#endif
+
+#ifdef DO_NBRR
+extern void send_tcp_nbrr(char remote_host[]);
+
+extern void recv_tcp_nbrr();
+#endif
+
diff --git a/nettest_dlpi.c b/nettest_dlpi.c
new file mode 100644
index 0000000..ab3e79f
--- /dev/null
+++ b/nettest_dlpi.c
@@ -0,0 +1,3798 @@
+
+/****************************************************************/
+/*								*/
+/*	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,1995,2004 Hewlett-Packard Co. Version 2.4.3";
+
+#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"
+
+/* 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"; 
+
+
+/* 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);
+    ffluch(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 */
diff --git a/nettest_dlpi.h b/nettest_dlpi.h
new file mode 100644
index 0000000..8169237
--- /dev/null
+++ b/nettest_dlpi.h
@@ -0,0 +1,215 @@
+/*
+        Copyright (C) 1993, Hewlett-Packard Company
+*/
+
+ /* This file contains the test-specific definitions for netperf's */
+ /* DLPI tests */
+
+
+struct	dlpi_co_stream_request_struct {
+  int	recv_win_size;
+  int	send_win_size;
+  int	receive_size;   /* how many bytes do we want to */
+                        /* receive at one time? */
+  int	recv_alignment; /* what is the alignment of the */
+                        /* receive buffer? */
+  int	recv_offset;    /* and at what offset from that */
+                        /* alignment? */
+  int	measure_cpu;	/* does the client want server cpu */
+                        /* utilization measured? */
+  float	cpu_rate;	/* do we know how fast the cpu is */
+                        /* already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid */
+                        /* copies on receives? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   sap;            /* */
+  int   ppa;            /* which device do we wish to use? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  dlpi_device[32]; /* the path to the dlpi device */
+};
+
+struct	dlpi_co_stream_response_struct {
+  int	recv_win_size;	/* how big does the client want it	*/
+  int	send_win_size;
+  int	receive_size;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   station_addr_len;
+  int   station_addr[1];/* what is the station address for the */
+			/* specified ppa? */
+};
+
+struct dlpi_co_stream_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   cpu_method;     /* how was CPU util measured? */
+  int   num_cpus;       /* how many CPUs were there? */
+};
+
+struct	dlpi_co_rr_request_struct {
+  int	recv_win_size;	/* how big does the client want it	*/
+  int	send_win_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   ppa;            /* which device do we wish to use? */
+  int   sap;            /* which sap should be used? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  dlpi_device[32]; /* the path to the dlpi device */
+};
+
+struct	dlpi_co_rr_response_struct {
+  int	recv_win_size;	/* how big does the client want it	*/
+  int	send_win_size;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   station_addr_len;    /* the length of the station address */
+  int   station_addr[1];     /* the remote's station address */
+};
+
+struct dlpi_co_rr_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  int	trans_received;	/* not ignored  */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   cpu_method;     /* how was CPU util measured? */
+  int   num_cpus;       /* how many CPUs were there? */
+};
+
+struct	dlpi_cl_stream_request_struct {
+  int	recv_win_size;
+  int	message_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	checksum_off;
+  int	measure_cpu;
+  float	cpu_rate;
+  int	test_length;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   ppa;            /* which device do we wish to use? */
+  int   sap;
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  dlpi_device[32]; /* the path to the dlpi device */
+};
+
+struct	dlpi_cl_stream_response_struct {
+  int	recv_win_size;
+  int	send_win_size;
+  int	measure_cpu;
+  int	test_length;
+  int	data_port_number;
+  float	cpu_rate;
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   station_addr_len;    /* the length of the station address */
+  int   station_addr[1];     /* the remote's station address */
+};
+
+struct	dlpi_cl_stream_results_struct {
+  int	messages_recvd;
+  int	bytes_received;
+  float	elapsed_time;
+  float	cpu_util;
+  int   num_cpus;
+};
+
+
+struct	dlpi_cl_rr_request_struct {
+  int	recv_win_size;	/* how big does the client want it	*/
+  int	send_win_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   ppa;            /* which device do we wish to use? */
+  int   sap;            /* which sap? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  dlpi_device[32]; /* the path to the dlpi device */
+};
+
+struct	dlpi_cl_rr_response_struct {
+  int	recv_win_size;	/* how big does the client want it	*/
+  int	send_win_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   station_addr_len;    /* the length of the station address */
+  int   station_addr[1];     /* the remote's station address */
+};
+
+struct dlpi_cl_rr_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  int	trans_received;	/* not ignored  */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   cpu_method;     /* how was CPU util measured? */
+  int   num_cpus;       /* how many CPUs were there? */
+};
+
+extern void send_dlpi_co_stream();
+
+extern int recv_dlpi_co_stream();
+
+extern int send_dlpi_co_rr(char remote_host[]);
+
+extern void send_dlpi_cl_stream(char remote_host[]);
+
+extern int recv_dlpi_cl_stream();
+
+extern int send_dlpi_cl_rr(char remote_host[]);
+
+extern int recv_dlpi_cl_rr();
+
+extern int recv_dlpi_co_rr();
+
+extern void scan_dlpi_args(int argc, char *argv[]);
diff --git a/nettest_sctp.c b/nettest_sctp.c
new file mode 100644
index 0000000..7cfcd9f
--- /dev/null
+++ b/nettest_sctp.c
@@ -0,0 +1,4869 @@
+#ifndef lint
+char	nettest_sctp[]="\
+@(#)nettest_sctp.c (c) Copyright 2005-2007 Hewlett-Packard Co. Version 2.4.3";
+#else
+#define DIRTY
+#define WANT_HISTOGRAM
+#define WANT_INTERVALS
+#endif /* lint */
+
+/****************************************************************/
+/*								*/
+/*	nettest_sctp.c						*/
+/*								*/
+/*                                                              */
+/*      scan_sctp_args()        get the sctp command line args  */
+/*                                                              */
+/*	the actual test routines...				*/
+/*								*/
+/*	send_sctp_stream()	perform a sctp stream test	*/
+/*	recv_sctp_stream()					*/
+/*	send_sctp_rr()		perform a sctp request/response	*/
+/*	recv_sctp_rr()						*/
+/*	send_sctp_stream_udp()	perform a sctp request/response	*/
+/*	recv_sctp_stream_upd()	using UDP style API		*/
+/*	send_sctp_rr_udp()	perform a sctp request/response	*/
+/*	recv_sctp_rr_upd()	using UDP style API		*/
+/*								*/
+/*      relies on create_data_socket in nettest_bsd.c           */
+/****************************************************************/
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if defined(WANT_SCTP)
+     
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#ifdef NOSTDLIBH
+#include <malloc.h>
+#else /* NOSTDLIBH */
+#include <stdlib.h>
+#endif /* NOSTDLIBH */
+
+#if !defined(__VMS)
+#include <sys/ipc.h>
+#endif /* !defined(__VMS) */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netinet/sctp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+/* would seem that not all sctp.h files define a MSG_EOF, but that
+   MSG_EOF can be the same as MSG_FIN so lets work with that
+   assumption.  initial find by Jon Pedersen. raj 2006-02-01 */
+#ifndef MSG_EOF
+#ifdef MSG_FIN
+#define MSG_EOF MSG_FIN
+#else
+#error Must have either MSG_EOF or MSG_FIN defined
+#endif
+#endif 
+
+#include "netlib.h"
+#include "netsh.h"
+/* get some of the functions from nettest_bsd.c */
+#include "nettest_bsd.h"
+#include "nettest_sctp.h"
+
+#ifdef WANT_HISTOGRAM
+#ifdef __sgi
+#include <sys/time.h>
+#endif /* __sgi */
+#include "hist.h"
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_FIRST_BURST
+extern int first_burst_size;
+#endif /* WANT_FIRST_BURST */
+
+
+
+/* these variables are specific to SCTP tests. declare */
+/* them static to make them global only to this file. */
+
+static int	
+  msg_count = 0,	/* number of messages to transmit on association */
+  non_block = 0,	/* default to blocking sockets */
+  num_associations = 1; /* number of associations on the endpoint */
+
+static  int confidence_iteration;
+static  char  local_cpu_method;
+static  char  remote_cpu_method;
+
+#ifdef WANT_HISTOGRAM
+static struct timeval time_one;
+static struct timeval time_two;
+static HIST time_hist;
+#endif /* WANT_HISTOGRAM */
+
+
+char sctp_usage[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+SCTP Sockets Test Options:\n\
+    -b number         Send number requests at the start of _RR tests\n\
+    -D [L][,R]        Set SCTP_NODELAY locally and/or remotely\n\
+    -h                Display this text\n\
+    -H name,fam       Use name (or IP) and family as target of data connection\n\
+    -L name,fam       Use name (or IP) and family as source of data connextion\n\
+    -m bytes          Set the size of each sent message\n\
+    -M bytes          Set the size of each received messages\n\
+    -P local[,remote] Set the local/remote port for the data socket\n\
+    -r req,[rsp]      Set request/response sizes (_RR tests)\n\
+    -s send[,recv]    Set local socket send/recv buffer sizes\n\
+    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
+    -V 		      Enable copy avoidance if supported\n\
+    -N number	      Specifies the number of messages to send (_STREAM tests)\n\
+    -B		      run the test in non-blocking mode\n\
+    -T number	      Number of associations to create (_MANY tests)\n\
+    -4                Use AF_INET (eg IPv4) on both ends of the data conn\n\
+    -6                Use AF_INET6 (eg IPv6) on both ends of the data conn\n\
+\n\
+For those options taking two parms, at least one must be specified;\n\
+specifying one value without a comma will set both parms to that\n\
+value, specifying a value with a leading comma will set just the second\n\
+parm, a value with a trailing comma will set just the first. To set\n\
+each parm to unique values, specify both and separate them with a\n\
+comma.\n"; 
+     
+
+ /* This routine is intended to retrieve interesting aspects of tcp */
+ /* for the data connection. at first, it attempts to retrieve the */
+ /* maximum segment size. later, it might be modified to retrieve */
+ /* other information, but it must be information that can be */
+ /* retrieved quickly as it is called during the timing of the test. */
+ /* for that reason, a second routine may be created that can be */
+ /* called outside of the timing loop */
+static
+void
+get_sctp_info(socket, mss)
+     int socket;
+     int *mss;
+{
+
+  int sock_opt_len;
+
+  if (sctp_opt_info(socket,
+		    0,
+		    SCTP_MAXSEG,
+		    mss,
+		    &sock_opt_len) < 0) {
+    lss_size = -1;
+  }
+}
+
+
+static
+void
+sctp_enable_events(socket, ev_mask)
+    int socket;
+    int ev_mask;
+{
+    struct sctp_event_subscribe ev;
+
+    bzero(&ev, sizeof(ev));
+
+    if (ev_mask & SCTP_SNDRCV_INFO_EV)
+	ev.sctp_data_io_event = 1;
+
+    if (ev_mask & SCTP_ASSOC_CHANGE_EV)
+	ev.sctp_association_event = 1;
+
+    if (ev_mask & SCTP_PEERADDR_CHANGE_EV)
+	ev.sctp_address_event = 1;
+
+    if (ev_mask & SCTP_SND_FAILED_EV)
+	ev.sctp_send_failure_event = 1;
+
+    if (ev_mask & SCTP_REMOTE_ERROR_EV)
+	ev.sctp_peer_error_event = 1;
+
+    if (ev_mask & SCTP_SHUTDOWN_EV)
+	ev.sctp_shutdown_event = 1;
+
+    if (ev_mask & SCTP_PD_EV)
+	ev.sctp_partial_delivery_event = 1;
+
+    if (ev_mask & SCTP_ADAPT_EV)
+#ifdef HAVE_SCTP_ADAPTATION_LAYER_EVENT
+	ev.sctp_adaptation_layer_event = 1;
+#else
+	ev.sctp_adaption_layer_event = 1;
+#endif
+
+    if (setsockopt(socket,
+		   IPPROTO_SCTP,
+#ifdef SCTP_EVENTS
+		   SCTP_EVENTS,
+#else
+		   SCTP_SET_EVENTS,
+#endif
+		   (const char*)&ev,
+		   sizeof(ev)) != 0 ) {
+      fprintf(where,
+	      "sctp_enable_event: could not set sctp events errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+}
+
+
+static
+sctp_disposition_t
+sctp_process_event(socket, buf)
+    int socket;
+    void *buf;
+{
+
+    struct sctp_assoc_change *sac;
+    struct sctp_send_failed *ssf;
+    struct sctp_paddr_change *spc;
+    struct sctp_remote_error *sre;
+    union sctp_notification *snp;
+
+    snp = buf;
+
+    switch (snp->sn_header.sn_type) {
+    case SCTP_ASSOC_CHANGE:
+	if (debug) {
+	    fprintf(where, "\tSCTP_ASSOC_CHANGE event, type:");
+	    fflush(where);
+	}
+	sac = &snp->sn_assoc_change;
+	switch (sac->sac_type) {
+	    case SCTP_COMM_UP:
+		if (debug) {
+		    fprintf(where, "  SCTP_COMM_UP\n");
+		    fflush(where);
+		}
+		break;
+	    case SCTP_RESTART:
+		if (debug) {
+		    fprintf(where, "  SCTP_RESTART\n");
+		    fflush(where);
+		}
+		break;
+	    case SCTP_CANT_STR_ASSOC:
+		if (debug) {
+		    fprintf(where, "  SCTP_CANT_STR_ASSOC\n");
+		    fflush(where);
+		}
+		break;	/* FIXME ignore above status changes */
+	    case SCTP_COMM_LOST:
+		if (debug) {
+		    fprintf(where, "  SCTP_COMM_LOST\n");
+		    fflush(where);
+		}
+		return SCTP_CLOSE;
+	    case SCTP_SHUTDOWN_COMP:
+		if (debug) {
+		    fprintf(where, "  SCTP_SHUTDOWN_COMPLETE\n");
+		    fflush(where);
+		}
+		return SCTP_CLOSE;
+		break;
+	}
+
+    case SCTP_SEND_FAILED:
+	if (debug) {
+	    fprintf(where, "\tSCTP_SEND_FAILED event\n");
+	    fflush(where);
+	}
+	ssf = &snp->sn_send_failed;
+	break;  /* FIXME ??? ignore this for now */
+
+    case SCTP_PEER_ADDR_CHANGE:
+	if (debug) {
+	    fprintf(where, "\tSCTP_PEER_ADDR_CHANGE event\n");
+	    fflush(where);
+	}
+	spc = &snp->sn_paddr_change;
+	break;	/* FIXME ??? ignore this for now */
+
+    case SCTP_REMOTE_ERROR:
+	if (debug) {
+	    fprintf(where, "\tSCTP_REMOTE_ERROR event\n");
+	    fflush(where);
+	}
+	sre = &snp->sn_remote_error;
+	break;	/* FIXME ??? ignore this for now */
+    case SCTP_SHUTDOWN_EVENT:
+	if (debug) {
+	    fprintf(where, "\tSCTP_SHUTDOWN event\n");
+	    fflush(where);
+	}
+	return SCTP_CLOSE;
+    default:
+	fprintf(where, "unknown type: %hu\n", snp->sn_header.sn_type);
+	fflush(where);
+	break;
+    }
+    return SCTP_OK;
+}
+
+
+
+/* This routine implements the SCTP 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_sctp_stream(remote_host)
+char	remote_host[];
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   \n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %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";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+#ifdef WANT_INTERVALS
+  int interval_count;
+  sigset_t signal_set;
+#endif
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* send-size greater than our send window. this will insure that we */
+  /* are never trying to re-use a buffer that may still be in the hands */
+  /* of the transport. This buffer will be malloc'd after we have found */
+  /* the size of the local senc socket buffer. We will want to deal */
+  /* with alignment and offset concerns as well. */
+  
+#ifdef DIRTY
+  int	*message_int_ptr;
+#endif
+
+  struct ring_elt *send_ring;
+  
+  int len;
+  unsigned int nummessages = 0;
+  int send_socket;
+  int bytes_remaining;
+  int sctp_mss;
+  int timed_out;
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+  double	bytes_sent = 0.0;
+  
+#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 addrinfo	*remote_res;
+  struct addrinfo	*local_res;
+  struct addrinfo	*local_remote_res;
+  struct addrinfo	*local_local_res;
+
+  struct	sctp_stream_request_struct	*sctp_stream_request;
+  struct	sctp_stream_response_struct	*sctp_stream_response;
+  struct	sctp_stream_results_struct	*sctp_stream_result;
+  
+  sctp_stream_request  = 
+    (struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sctp_stream_response =
+    (struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sctp_stream_result   = 
+    (struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
+
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+  /* 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. */
+  
+  /* complete_addrinfos will either succede or exit the process */
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_SCTP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("SCTP STREAM TEST", local_res, remote_res);
+  }
+
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    timed_out	   =    0;
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+    
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_sctp_stream: sctp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_sctp_stream: send_socket obtained...\n");
+    }
+    
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one send-size greater than our socket */
+    /* buffer size. We want to be sure that there are at least two */
+    /* buffers allocated - this can be a bit of a problem when the */
+    /* send_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our send */
+    /* buffers, we should respect that wish... */
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) {
+      /* only allocate the send ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 1, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type	=	DO_SCTP_STREAM;
+    sctp_stream_request->send_buf_size	=	rss_size_req;
+    sctp_stream_request->recv_buf_size	=	rsr_size_req;
+    sctp_stream_request->receive_size	=	recv_size;
+    sctp_stream_request->no_delay	=	rem_nodelay;
+    sctp_stream_request->recv_alignment	=	remote_recv_align;
+    sctp_stream_request->recv_offset	=	remote_recv_offset;
+    sctp_stream_request->measure_cpu	=	remote_cpu_usage;
+    sctp_stream_request->cpu_rate	=	remote_cpu_rate;
+    if (test_time) {
+      sctp_stream_request->test_length	=	test_time;
+    }
+    else {
+      if (msg_count)
+	  test_bytes = send_size * msg_count;
+
+      sctp_stream_request->test_length	=	test_bytes;
+    }
+    sctp_stream_request->so_rcvavoid	=	rem_rcvavoid;
+    sctp_stream_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+    sctp_stream_request->dirty_count    =       rem_dirty_count;
+    sctp_stream_request->clean_count    =       rem_clean_count;
+#endif /* DIRTY */
+    sctp_stream_request->port		=	htonl(atoi(remote_data_port));
+    sctp_stream_request->ipfamily	=	af_to_nf(remote_res->ai_family);
+    sctp_stream_request->non_blocking   =	non_block;
+    
+    
+    if (debug > 1) {
+      fprintf(where,
+	      "netperf: send_sctp_stream: requesting sctp 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 sctp tests.					*/
+    
+    recv_response();
+    
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size	      =	sctp_stream_response->recv_buf_size;
+      rss_size	      =	sctp_stream_response->send_buf_size;
+      rem_nodelay     =	sctp_stream_response->no_delay;
+      remote_cpu_usage=	sctp_stream_response->measure_cpu;
+      remote_cpu_rate = sctp_stream_response->cpu_rate;
+
+      /* we have to make sure that the server port number is in */
+      /* network order */
+      set_port_number(remote_res, (short)sctp_stream_response->data_port_number);
+
+      rem_rcvavoid	= sctp_stream_response->so_rcvavoid;
+      rem_sndavoid	= sctp_stream_response->so_sndavoid;
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+    
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET) {
+      perror("netperf: send_sctp_stream: data socket connect failed");
+      exit(1);
+    }
+
+    sctp_enable_events(send_socket, SCTP_ASSOC_CHANGE_EV);
+
+    if (non_block) {
+	/* now that we are connected, mark the socket as non-blocking */
+	if (!set_nonblock(send_socket)) {
+	  perror("netperf: fcntl");
+	  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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      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);
+    
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_sctp_stream: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+
+#ifdef DIRTY
+    /* initialize the random number generator for putting dirty stuff */
+    /* into the send buffer. raj */
+    srand((int) getpid());
+#endif
+    
+    /* before we start, initialize a few variables */
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+#ifdef DIRTY
+      /* we want to dirty some number of consecutive integers in the buffer */
+      /* we are about to send. we may also want to bring some number of */
+      /* them cleanly into the cache. The clean ones will follow any dirty */
+      /* ones into the cache. at some point, we might want to replace */
+      /* the rand() call with something from a table to reduce our call */
+      /* overhead during the test, but it is not a high priority item. */
+      message_int_ptr = (int *)(send_ring->buffer_ptr);
+      for (i = 0; i < loc_dirty_count; i++) {
+	*message_int_ptr = rand();
+	message_int_ptr++;
+      }
+      for (i = 0; i < loc_clean_count; i++) {
+	loc_dirty_count = *message_int_ptr;
+	message_int_ptr++;
+      }
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      /* timestamp just before we go into send and then again just after */
+      /* we come out raj 8/94 */
+      HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+      
+      while ((len=sctp_sendmsg(send_socket,
+			       send_ring->buffer_ptr, send_size,
+			       NULL, 0,
+			       0, 0, 0, 0, 0)) != send_size) {
+	if (non_block && errno == EAGAIN)
+	    continue;
+	else if ((len >=0) || SOCKET_EINTR(len)) {
+	  /* the test was interrupted, must be the end of test */
+	  timed_out = 1;
+	  break;
+	}
+	perror("netperf: data send error");
+	printf("len was %d\n",len);
+	exit(1);
+      }
+
+      if (timed_out)
+	  break;	/* we timed out durint sendmsg, done with test */
+
+#ifdef WANT_HISTOGRAM
+      /* timestamp the exit from the send call and update the histogram */
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += send_size;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug > 1) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_sctp_stream: fault with sigsuspend.\n");
+	  fflush(where);
+	  exit(1);
+	}
+	interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      send_ring = send_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a */
+    /* graceful release to insure that all data has been taken by the */
+    /* remote. */ 
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the sctp maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      sctp_mss = -1;
+      get_sctp_info(send_socket, &sctp_mss);
+    }
+
+    shutdown(send_socket, SHUT_WR);
+
+    /* The test server will signal to us when it wants to shutdown.
+     * In blocking mode, we can call recvmsg.  In non-blocking
+     * mode, we need to select on the socket for reading.
+     * We'll assume that all returns are succefull
+     */
+    if (non_block) {
+	fd_set readfds;
+
+	FD_ZERO(&readfds);
+	FD_SET(send_socket, &readfds);
+	select(send_socket+1, &readfds, NULL, NULL, NULL);
+    } else {
+	sctp_recvmsg(send_socket, send_ring->buffer_ptr, send_size, NULL, 
+		0, NULL, 0);
+    }
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+    close(send_socket);
+
+    /* 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);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      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 sctp 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	= ntohd(sctp_stream_result->bytes_received);
+
+    thruput	= (double) 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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= sctp_stream_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      sctp_stream_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sctp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);/* how fast did it go */
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* sctp statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)sctp_stream_result->recv_calls,
+	    sctp_stream_result->recv_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    sctp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+
+
+/* This is the server-side routine for the sctp stream test. It is */
+/* implemented as one routine. I could break things-out somewhat, but */
+/* didn't feel it was necessary. */
+
+void
+recv_sctp_stream()
+{
+  
+  struct sockaddr_in myaddr_in; /* needed to get port number */
+  struct sockaddr_storage peeraddr;	/* used in accept */
+  int	s_listen,s_data;
+  int 	addrlen;
+  int	len;
+  unsigned int	receive_calls;
+  float	elapsed_time;
+  double   bytes_received;
+  
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+  int  msg_flags = 0;
+
+#ifdef DIRTY
+  int   *message_int_ptr;
+  int   dirty_count;
+  int   clean_count;
+  int   i;
+#endif
+  
+#ifdef DO_SELECT
+  fd_set readfds;
+  struct timeval timeout;
+#endif /* DO_SELECT */
+
+  struct	sctp_stream_request_struct	*sctp_stream_request;
+  struct	sctp_stream_response_struct	*sctp_stream_response;
+  struct	sctp_stream_results_struct	*sctp_stream_results;
+  
+#ifdef DO_SELECT
+  FD_ZERO(&readfds);
+  timeout.tv_sec = 1;
+  timeout.tv_usec = 0;
+#endif /* DO_SELECT */
+
+  sctp_stream_request	= 
+    (struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sctp_stream_response	= 
+    (struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sctp_stream_results	= 
+    (struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sctp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SCTP_STREAM_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream: requested alignment of %d\n",
+	    sctp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sctp_stream_request->send_buf_size;
+  lsr_size_req = sctp_stream_request->recv_buf_size;
+  loc_nodelay = sctp_stream_request->no_delay;
+  loc_rcvavoid = sctp_stream_request->so_rcvavoid;
+  loc_sndavoid = sctp_stream_request->so_sndavoid;
+  non_block = sctp_stream_request->non_blocking;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sctp_stream_request->ipfamily),
+			sctp_stream_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sctp_stream_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_SCTP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen < 0) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* what sort of sizes did we end-up with? */
+  if (sctp_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = sctp_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   sctp_stream_request->recv_alignment,
+				   sctp_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_sctp_stream: set recv_size = %d, align = %d, offset = %d.\n",
+		   recv_size, sctp_stream_request->recv_alignment,
+		   sctp_stream_request->recv_offset);
+    fflush(where);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == -1){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sctp_stream_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sctp_stream_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (sctp_stream_request->measure_cpu) {
+    sctp_stream_response->measure_cpu = 1;
+    sctp_stream_response->cpu_rate = 
+      calibrate_local_cpu(sctp_stream_request->cpu_rate);
+  }
+  else {
+    sctp_stream_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sctp_stream_response->send_buf_size = lss_size;
+  sctp_stream_response->recv_buf_size = lsr_size;
+  sctp_stream_response->no_delay = loc_nodelay;
+  sctp_stream_response->so_rcvavoid = loc_rcvavoid;
+  sctp_stream_response->so_sndavoid = loc_sndavoid;
+  sctp_stream_response->receive_size = recv_size;
+
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == -1) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  send_response();
+  
+  addrlen = sizeof(peeraddr);
+  
+  if ((s_data = accept(s_listen,
+		      (struct sockaddr *)&peeraddr,
+		      &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+
+  sctp_enable_events(s_data, SCTP_ASSOC_CHANGE_EV | SCTP_SHUTDOWN_EV);
+
+  /* now that we are connected, mark the socket as non-blocking */
+  if (non_block) {
+      fprintf(where, "setting socket as nonblocking\n");
+      fflush(where);
+      if (!set_nonblock(s_data)) {
+	close(s_data);
+	exit(1);
+      }
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(sctp_stream_request->measure_cpu);
+
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+#ifdef DIRTY
+    /* we want to dirty some number of consecutive integers in the buffer */
+    /* we are about to recv. we may also want to bring some number of */
+    /* them cleanly into the cache. The clean ones will follow any dirty */
+    /* ones into the cache. */
+
+  dirty_count = sctp_stream_request->dirty_count;
+  clean_count = sctp_stream_request->clean_count;
+  message_int_ptr = (int *)recv_ring->buffer_ptr;
+  for (i = 0; i < dirty_count; i++) {
+    *message_int_ptr = rand();
+    message_int_ptr++;
+  }
+  for (i = 0; i < clean_count; i++) {
+    dirty_count = *message_int_ptr;
+    message_int_ptr++;
+  }
+#endif /* DIRTY */
+
+  bytes_received = 0;
+  receive_calls  = 0;
+  
+  while ((len = sctp_recvmsg(s_data,
+			    recv_ring->buffer_ptr, recv_size,
+			    NULL, 0, NULL, &msg_flags)) != 0) {
+    if (len == SOCKET_ERROR) {
+	if (non_block && errno == EAGAIN) {
+	   if (debug){
+	     fprintf(where,
+		    "recv_sctp_stream: sctp_recvmsg timed out, trying again\n");
+	     fflush(where);
+	   }
+	   Set_errno(0);
+	   continue;
+	}
+	if (debug) {
+	    fprintf(where,
+		    "recv_sctp_stream: sctp_recvmsg error %d, exiting",
+		    errno);
+	    fflush(where);
+        }
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	close(s_data);
+	exit(1);
+    }
+
+    if (msg_flags & MSG_NOTIFICATION) {
+	 msg_flags = 0;
+	 if (debug) {
+	   fprintf(where,
+		    "recv_sctp_stream: Got notification... processing\n");
+	     fflush(where);
+	}
+	if (sctp_process_event(s_data, recv_ring->buffer_ptr) == SCTP_CLOSE)
+	    break;	/* break out of the recvmsg loop */
+
+	continue;
+    }
+
+    bytes_received += len;
+    receive_calls++;
+
+    /* more to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+
+#ifdef PAUSE
+    sleep(1);
+#endif /* PAUSE */
+
+#ifdef DIRTY
+    message_int_ptr = (int *)(recv_ring->buffer_ptr);
+    for (i = 0; i < dirty_count; i++) {
+      *message_int_ptr = rand();
+      message_int_ptr++;
+    }
+    for (i = 0; i < clean_count; i++) {
+      dirty_count = *message_int_ptr;
+      message_int_ptr++;
+    }
+#endif /* DIRTY */
+
+#ifdef DO_SELECT
+	FD_SET(s_data,&readfds);
+	select(s_data+1,&readfds,NULL,NULL,&timeout);
+#endif /* DO_SELECT */
+
+  }
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (close(s_data) == -1) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+  
+  cpu_stop(sctp_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_stream: got %g bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_sctp_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  sctp_stream_results->bytes_received	= htond(bytes_received);
+  sctp_stream_results->elapsed_time	= elapsed_time;
+  sctp_stream_results->recv_calls	= receive_calls;
+  
+  if (sctp_stream_request->measure_cpu) {
+    sctp_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_stream: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_received %g receive_calls %d\n",
+	    bytes_received,
+	    receive_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+  
+  sctp_stream_results->cpu_method = cpu_method;
+  sctp_stream_results->num_cpus   = lib_num_loc_cpus;
+  send_response();
+
+  /* we are now done with the sockets */
+  close(s_listen);
+
+}
+
+
+/* This routine implements the SCTP 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_sctp_stream_1toMany(remote_host)
+char	remote_host[];
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   \n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %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";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+#ifdef WANT_INTERVALS
+  int interval_count;
+  sigset_t signal_set;
+#endif
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* send-size greater than our send window. this will insure that we */
+  /* are never trying to re-use a buffer that may still be in the hands */
+  /* of the transport. This buffer will be malloc'd after we have found */
+  /* the size of the local senc socket buffer. We will want to deal */
+  /* with alignment and offset concerns as well. */
+  
+#ifdef DIRTY
+  int	*message_int_ptr;
+#endif
+
+  struct ring_elt *send_ring;
+  
+  int len;
+  unsigned int nummessages = 0;
+  int *send_socket;
+  int bytes_remaining;
+  int sctp_mss;
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+  double	bytes_sent = 0.0;
+  
+#ifdef DIRTY
+  int	i;
+#endif /* DIRTY */
+  int j;
+
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+  struct addrinfo *last_remote_res;
+  struct addrinfo *last_local_res;
+
+  struct	sctp_stream_request_struct	*sctp_stream_request;
+  struct	sctp_stream_response_struct	*sctp_stream_response;
+  struct	sctp_stream_results_struct	*sctp_stream_result;
+  
+  sctp_stream_request  = 
+    (struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sctp_stream_response =
+    (struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sctp_stream_result   = 
+    (struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
+
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_SEQPACKET,
+		     IPPROTO_SCTP,
+		     0);
+  
+  if ( print_headers ) {
+    print_top_test_header("SCTP 1-TO-MANY STREAM TEST",local_res,remote_res);
+  }
+
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  send_socket = malloc(sizeof (int) * num_associations);
+  if (send_socket == NULL) {
+      fprintf(where, "send_sctp_stream_1toMany: failed to allocation sockets!\n");
+      exit(1);
+  }
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    int		j=0;
+    int		timed_out = 0;
+    
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one send-size greater than our socket */
+    /* buffer size. We want to be sure that there are at least two */
+    /* buffers allocated - this can be a bit of a problem when the */
+    /* send_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our send */
+    /* buffers, we should respect that wish... */
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) {
+      /* only allocate the send ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 1, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type	=	DO_SCTP_STREAM_MANY;
+    sctp_stream_request->send_buf_size	=	rss_size_req;
+    sctp_stream_request->recv_buf_size	=	rsr_size_req;
+    sctp_stream_request->receive_size	=	recv_size;
+    sctp_stream_request->no_delay	=	rem_nodelay;
+    sctp_stream_request->recv_alignment	=	remote_recv_align;
+    sctp_stream_request->recv_offset	=	remote_recv_offset;
+    sctp_stream_request->measure_cpu	=	remote_cpu_usage;
+    sctp_stream_request->cpu_rate	=	remote_cpu_rate;
+    if (test_time) {
+      sctp_stream_request->test_length	=	test_time;
+    }
+    else {
+      if (msg_count)
+	  test_bytes = send_size * msg_count;
+
+      sctp_stream_request->test_length	=	test_bytes*num_associations;
+    }
+    sctp_stream_request->so_rcvavoid	=	rem_rcvavoid;
+    sctp_stream_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+    sctp_stream_request->dirty_count    =       rem_dirty_count;
+    sctp_stream_request->clean_count    =       rem_clean_count;
+#endif /* DIRTY */
+    sctp_stream_request->port		= 	(atoi(remote_data_port));
+    sctp_stream_request->ipfamily	=	af_to_nf(remote_res->ai_family);
+    sctp_stream_request->non_blocking   =	non_block;
+    
+    
+    if (debug > 1) {
+      fprintf(where,
+	      "netperf: send_sctp_stream_1toMany: requesting sctp 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 sctp tests.					*/
+    
+    recv_response();
+    
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size	      =	sctp_stream_response->recv_buf_size;
+      rss_size	      =	sctp_stream_response->send_buf_size;
+      rem_nodelay     =	sctp_stream_response->no_delay;
+      remote_cpu_usage=	sctp_stream_response->measure_cpu;
+      remote_cpu_rate = sctp_stream_response->cpu_rate;
+
+      /* we have to make sure that the server port number is in */
+      /* network order */
+      set_port_number(remote_res, (unsigned short)sctp_stream_response->data_port_number);
+      rem_rcvavoid	= sctp_stream_response->so_rcvavoid;
+      rem_sndavoid	= sctp_stream_response->so_sndavoid;
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+    
+    /*set up the the array of data sockets  and connect them to the server */
+
+    for (j = 0; j < num_associations; j++) {
+	send_socket[j] = create_data_socket(local_res);
+    
+	if (send_socket[j] < 0){
+	  perror("netperf: send_sctp_stream_1toMany: sctp stream data socket");
+	  exit(1);
+	}
+	
+	if (debug) {
+	  fprintf(where,"send_sctp_stream_1toMany: send_socket obtained...\n");
+	}
+
+	/*Connect up to the remote port on the data socket  */
+	if (connect(send_socket[j], 
+		    remote_res->ai_addr,
+		    remote_res->ai_addrlen) == INVALID_SOCKET){
+	  perror("netperf: send_sctp_stream_1toMany: data socket connect failed");
+	  exit(1);
+	}
+
+	/* Do it after connect is successfull, so that we don't see COMM_UP */
+	sctp_enable_events(send_socket[j], SCTP_ASSOC_CHANGE_EV);
+
+	if (non_block) {
+	    /* now that we are connected, mark the socket as non-blocking */
+	    if (!set_nonblock(send_socket[j])) {
+	      perror("netperf: fcntl");
+	      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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      start_timer(test_time);
+    }
+    else {
+      /* The tester wanted to send a number of bytes. */
+      bytes_remaining = test_bytes * num_associations;
+      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);
+    
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_sctp_stream_1toMany: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+
+#ifdef DIRTY
+    /* initialize the random number generator for putting dirty stuff */
+    /* into the send buffer. raj */
+    srand((int) getpid());
+#endif
+    
+    /* before we start, initialize a few variables */
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+#ifdef DIRTY
+      /* we want to dirty some number of consecutive integers in the buffer */
+      /* we are about to send. we may also want to bring some number of */
+      /* them cleanly into the cache. The clean ones will follow any dirty */
+      /* ones into the cache. at some point, we might want to replace */
+      /* the rand() call with something from a table to reduce our call */
+      /* overhead during the test, but it is not a high priority item. */
+      message_int_ptr = (int *)(send_ring->buffer_ptr);
+      for (i = 0; i < loc_dirty_count; i++) {
+	*message_int_ptr = rand();
+	message_int_ptr++;
+      }
+      for (i = 0; i < loc_clean_count; i++) {
+	loc_dirty_count = *message_int_ptr;
+	message_int_ptr++;
+      }
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      /* timestamp just before we go into send and then again just after */
+      /* we come out raj 8/94 */
+      gettimeofday(&time_one,NULL);
+#endif /* WANT_HISTOGRAM */
+      
+      for (j = 0; j < num_associations; j++) {
+
+	  if((len=sctp_sendmsg(send_socket[j],
+			       send_ring->buffer_ptr,
+			       send_size,
+			       (struct sockaddr *)remote_res->ai_addr,
+			       remote_res->ai_addrlen,
+			       0, 0, 0, 0, 0)) != send_size) {
+	    if ((len >=0) || SOCKET_EINTR(len)) {
+	      /* the test was interrupted, must be the end of test */
+	      timed_out = 1;
+	      break;
+	    } else if (non_block && errno == EAGAIN) {
+		j--;	 /* send again on the same socket */
+		Set_errno(0);
+		continue;
+	    }
+	    perror("netperf: data send error");
+	    printf("len was %d\n",len);
+	    exit(1);
+	  }
+      }
+
+      if (timed_out)
+	  break;	/* test is over, try next iteration */
+
+#ifdef WANT_HISTOGRAM
+      /* timestamp the exit from the send call and update the histogram */
+      gettimeofday(&time_two,NULL);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += send_size;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug > 1) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_sctp_stream_1toMany: fault with sigsuspend.\n");
+	  fflush(where);
+	  exit(1);
+	}
+	interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      send_ring = send_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a */
+    /* graceful release to insure that all data has been taken by the */
+    /* remote. */ 
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the sctp maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      sctp_mss = -1;
+      get_sctp_info(send_socket[0], &sctp_mss);
+    }
+
+    /* signal the server that we are all done writing, this will
+     * initiate a shutdonw of one of the associations on the
+     * server and trigger an event telling the server it's all done
+     */ 
+    sctp_sendmsg(send_socket[0], NULL, 0, remote_res->ai_addr,
+		 remote_res->ai_addrlen, 0, MSG_EOF, 0, 0, 0);
+
+    
+    /* The test server will initiate closure of all associations
+     * when it's done reading. We want a basic mechanism to catch this
+     * and are using SCTP events for this.
+     * In blocking mode, we can call recvmsg with the last socket we created.
+     * In non-blocking  mode, we need to select on the socket for reading.
+     * We'll assume that all returns are succefull and signify
+     * closure.
+     * It is sufficient to do this on a single socket in the client.
+     * We choose to do it on a socket other then the one that send MSG_EOF.
+     * This means that anything comming in on that socket will be a shutdown.
+     */
+    if (non_block) {
+	fd_set readfds;
+
+	FD_ZERO(&readfds);
+	FD_SET(send_socket[num_associations-1], &readfds);
+	select(send_socket[num_associations-1]+1, &readfds, NULL, NULL, NULL);
+    } else {
+	sctp_recvmsg(send_socket[num_associations], send_ring->buffer_ptr,
+		     send_size, NULL, 0, NULL, 0);
+    }
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with our sockets, so close them to prevent hitting */
+    /* the limit on maximum open files. */
+    for (j = 0; j < num_associations; j++)
+	close(send_socket[j]);
+
+    /* 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);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      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 sctp 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	= ntohd(sctp_stream_result->bytes_received);
+
+    thruput	= (double) 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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= sctp_stream_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      sctp_stream_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sctp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);/* how fast did it go */
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* sctp statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)sctp_stream_result->recv_calls,
+	    sctp_stream_result->recv_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    sctp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+
+/* This is the server-side routine for the sctp stream test. It is */
+/* implemented as one routine. I could break things-out somewhat, but */
+/* didn't feel it was necessary. */
+
+void
+recv_sctp_stream_1toMany()
+{
+  
+  struct sockaddr_in myaddr_in;
+  int	s_recv;
+  int 	addrlen;
+  int	len;
+  unsigned int	receive_calls;
+  float	elapsed_time;
+  double   bytes_received;
+  int	msg_flags = 0;
+  
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+#ifdef DIRTY
+  int   *message_int_ptr;
+  int   dirty_count;
+  int   clean_count;
+  int   i;
+#endif
+  
+#ifdef DO_SELECT
+  fd_set readfds;
+  struct timeval timeout;
+#endif
+
+  struct	sctp_stream_request_struct	*sctp_stream_request;
+  struct	sctp_stream_response_struct	*sctp_stream_response;
+  struct	sctp_stream_results_struct	*sctp_stream_results;
+  
+#ifdef DO_SELECT
+  FD_ZERO(&readfds);
+  timeout.tv_sec = 1;
+  timeout.tv_usec = 0;
+#endif
+
+  sctp_stream_request	= 
+    (struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sctp_stream_response	= 
+    (struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sctp_stream_results	= 
+    (struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sctp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream_1toMany: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SCTP_STREAM_MANY_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream_1toMany: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_stream_1toMany: requested alignment of %d\n",
+	    sctp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sctp_stream_request->send_buf_size;
+  lsr_size_req = sctp_stream_request->recv_buf_size;
+  loc_nodelay = sctp_stream_request->no_delay;
+  loc_rcvavoid = sctp_stream_request->so_rcvavoid;
+  loc_sndavoid = sctp_stream_request->so_sndavoid;
+  non_block = sctp_stream_request->non_blocking;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sctp_stream_request->ipfamily),
+			sctp_stream_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sctp_stream_request->ipfamily),
+				SOCK_SEQPACKET,
+				IPPROTO_SCTP,
+				0);
+
+  s_recv = create_data_socket(local_res);
+  
+  if (s_recv < 0) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* what sort of sizes did we end-up with? */
+  if (sctp_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = sctp_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   sctp_stream_request->recv_alignment,
+				   sctp_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_sctp_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_recv, 5) == -1) {
+    netperf_response.content.serv_errno = errno;
+    close(s_recv);
+    send_response();
+    
+    exit(1);
+  }
+
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_recv, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == -1){
+    netperf_response.content.serv_errno = errno;
+    close(s_recv);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sctp_stream_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sctp_stream_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (sctp_stream_request->measure_cpu) {
+    sctp_stream_response->measure_cpu = 1;
+    sctp_stream_response->cpu_rate = 
+      calibrate_local_cpu(sctp_stream_request->cpu_rate);
+  }
+  else {
+    sctp_stream_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sctp_stream_response->send_buf_size = lss_size;
+  sctp_stream_response->recv_buf_size = lsr_size;
+  sctp_stream_response->no_delay = loc_nodelay;
+  sctp_stream_response->so_rcvavoid = loc_rcvavoid;
+  sctp_stream_response->so_sndavoid = loc_sndavoid;
+  sctp_stream_response->receive_size = recv_size;
+
+  send_response();
+  
+
+  sctp_enable_events(s_recv, SCTP_ASSOC_CHANGE_EV | SCTP_SHUTDOWN_EV);
+  
+  /* now that we are connected, mark the socket as non-blocking */
+  if (non_block) {
+      if (!set_nonblock(s_recv)) {
+	close(s_recv);
+	exit(1);
+      }
+  }
+
+
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(sctp_stream_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+#ifdef DIRTY
+    /* we want to dirty some number of consecutive integers in the buffer */
+    /* we are about to recv. we may also want to bring some number of */
+    /* them cleanly into the cache. The clean ones will follow any dirty */
+    /* ones into the cache. */
+
+  dirty_count = sctp_stream_request->dirty_count;
+  clean_count = sctp_stream_request->clean_count;
+  message_int_ptr = (int *)recv_ring->buffer_ptr;
+  for (i = 0; i < dirty_count; i++) {
+    *message_int_ptr = rand();
+    message_int_ptr++;
+  }
+  for (i = 0; i < clean_count; i++) {
+    dirty_count = *message_int_ptr;
+    message_int_ptr++;
+  }
+#endif /* DIRTY */
+
+  bytes_received = 0;
+  receive_calls  = 0;
+  
+  while ((len = sctp_recvmsg(s_recv, recv_ring->buffer_ptr, recv_size,
+			     NULL, 0,  /* we don't care who it's from */
+			     NULL, &msg_flags)) != 0) {
+    if (len < 0) {
+      if (non_block && errno == EAGAIN) {
+	Set_errno(0);
+	continue;
+      }
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      close(s_recv);
+      exit(1);
+    }
+
+    if (msg_flags & MSG_NOTIFICATION) {
+	if (sctp_process_event(s_recv, recv_ring->buffer_ptr) == SCTP_CLOSE)
+	    break;
+
+	continue;
+    }
+    
+    bytes_received += len;
+    receive_calls++;
+
+    /* more to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+
+#ifdef PAUSE
+    sleep(1);
+#endif /* PAUSE */
+
+#ifdef DIRTY
+    message_int_ptr = (int *)(recv_ring->buffer_ptr);
+    for (i = 0; i < dirty_count; i++) {
+      *message_int_ptr = rand();
+      message_int_ptr++;
+    }
+    for (i = 0; i < clean_count; i++) {
+      dirty_count = *message_int_ptr;
+      message_int_ptr++;
+    }
+#endif /* DIRTY */
+
+#ifdef DO_SELECT
+	FD_SET(s_recv,&readfds);
+	select(s_recv+1,&readfds,NULL,NULL,&timeout);
+#endif /* DO_SELECT */
+
+  }
+  
+  /* perform a shutdown to signal the sender.  in this case, sctp
+   * will close all associations on this socket
+   */
+  if (close(s_recv) == -1) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+  }
+  
+  cpu_stop(sctp_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_stream: got %g bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_sctp_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  sctp_stream_results->bytes_received	= htond(bytes_received);
+  sctp_stream_results->elapsed_time	= elapsed_time;
+  sctp_stream_results->recv_calls	= receive_calls;
+  
+  if (sctp_stream_request->measure_cpu) {
+    sctp_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_stream: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_received %g receive_calls %d\n",
+	    bytes_received,
+	    receive_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+  
+  sctp_stream_results->cpu_method = cpu_method;
+  sctp_stream_results->num_cpus   = lib_num_loc_cpus;
+  send_response();
+}
+
+
+ /* this routine implements the sending (netperf) side of the SCTP_RR */
+ /* test. */
+
+void
+send_sctp_rr(remote_host)
+     char	remote_host[];
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  int	send_socket;
+  int	trans_remaining;
+  int   msg_flags = 0;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+
+  struct sockaddr_storage peer;
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+
+  struct	sctp_rr_request_struct	*sctp_rr_request;
+  struct	sctp_rr_response_struct	*sctp_rr_response;
+  struct	sctp_rr_results_struct	*sctp_rr_result;
+  
+#ifdef WANT_INTERVALS
+  int	interval_count;
+  sigset_t signal_set;
+#endif /* WANT_INTERVALS */
+
+  sctp_rr_request = 
+    (struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sctp_rr_response =
+    (struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sctp_rr_result =
+    (struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+
+  /* complete_addrinfos will either succede or exit the process */
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_SCTP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("SCTP REQUEST/RESPONSE TEST", local_res, remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket < 0){
+      perror("netperf: send_sctp_rr: sctp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_sctp_rr: send_socket obtained...\n");
+    }
+  
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back.*/
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 8, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type	=	DO_SCTP_RR;
+    sctp_rr_request->recv_buf_size	=	rsr_size_req;
+    sctp_rr_request->send_buf_size	=	rss_size_req;
+    sctp_rr_request->recv_alignment     =	remote_recv_align;
+    sctp_rr_request->recv_offset        =	remote_recv_offset;
+    sctp_rr_request->send_alignment     =	remote_send_align;
+    sctp_rr_request->send_offset	=	remote_send_offset;
+    sctp_rr_request->request_size	=	req_size;
+    sctp_rr_request->response_size	=	rsp_size;
+    sctp_rr_request->no_delay	        =	rem_nodelay;
+    sctp_rr_request->measure_cpu	=	remote_cpu_usage;
+    sctp_rr_request->cpu_rate	        =	remote_cpu_rate;
+    sctp_rr_request->so_rcvavoid	        =	rem_rcvavoid;
+    sctp_rr_request->so_sndavoid	        =	rem_sndavoid;
+    if (test_time) {
+      sctp_rr_request->test_length	=	test_time;
+    }
+    else {
+      sctp_rr_request->test_length	=	test_trans * -1;
+    }
+    sctp_rr_request->non_blocking	= 	non_block;
+    sctp_rr_request->ipfamily           = af_to_nf(remote_res->ai_family);
+
+    if (debug > 1) {
+      fprintf(where,"netperf: send_sctp_rr: requesting SCTP rr test\n");
+    }
+    
+    send_request();
+    
+    /* The response from the remote will contain all of the relevant 	*/
+    /* socket parameters for this test type. We will put them back into */
+    /* the variables here so they can be displayed if desired.  The	*/
+    /* remote will have calibrated CPU if necessary, and will have done	*/
+    /* all the needed set-up we will have calibrated the cpu locally	*/
+    /* before sending the request, and will grab the counter value right*/
+    /* after the connect returns. The remote will grab the counter right*/
+    /* after the accept call. This saves the hassle of extra messages	*/
+    /* being sent for the sctp tests.					*/
+  
+    recv_response();
+  
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size          = sctp_rr_response->recv_buf_size;
+      rss_size          = sctp_rr_response->send_buf_size;
+      rem_nodelay       = sctp_rr_response->no_delay;
+      remote_cpu_usage  = sctp_rr_response->measure_cpu;
+      remote_cpu_rate   = sctp_rr_response->cpu_rate;
+      /* make sure that port numbers are in network order */
+      set_port_number(remote_res, 
+		      (unsigned short)sctp_rr_response->data_port_number);
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+    
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) <0){
+      perror("netperf: send_sctp_rr data socket connect failed");
+      exit(1);
+    }
+
+    /* don't need events for 1-to-1 API with request-response tests */
+    sctp_enable_events(send_socket, 0);
+
+    /* set non-blocking if needed */
+    if (non_block) {
+       if (!set_nonblock(send_socket)) {
+	    close(send_socket);
+	    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);
+
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_sctp_rr: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+
+    /* 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. */
+
+#ifdef WANT_FIRST_BURST
+    {
+      int i;
+      for (i = 0; i < first_burst_size; i++) {
+ 	if((len=sctp_sendmsg(send_socket,
+ 			     send_ring->buffer_ptr, req_size,
+ 			     NULL, 0,	/* don't need addrs with 1-to-1 */
+ 			     0, 0, 0, 0, 0)) != req_size) {
+	  /* we should never hit the end of the test in the first burst */
+	  perror("send_sctp_rr: initial burst data send error");
+	  exit(1);
+	}
+      }
+    }
+#endif /* WANT_FIRST_BURST */
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+      
+#ifdef WANT_HISTOGRAM
+      /* timestamp just before our call to send, and then again just */
+      /* after the receive raj 8/94 */
+      HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+      
+      while ((len=sctp_sendmsg(send_socket,
+			       send_ring->buffer_ptr, req_size,
+			       NULL, 0, /* don't need addrs with 1-to-1 */
+			       0, 0, 0, 0, 0)) != req_size) {
+	if (non_block && errno == EAGAIN) {
+	    /* try sending again */
+	    continue;
+	} else if (SOCKET_EINTR(len) || (errno == 0)) {
+	  /* we hit the end of a */
+	  /* timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_sctp_rr: data send error");
+	exit(1);
+      }
+
+      if (timed_out) {
+	/* we timed out while sending. break out another level */
+	break;
+      }
+      send_ring = send_ring->next;
+      
+      /* receive the response */
+      rsp_bytes_left = rsp_size;
+      temp_message_ptr  = recv_ring->buffer_ptr;
+      do {
+	msg_flags = 0;
+	if ((rsp_bytes_recvd=sctp_recvmsg(send_socket,
+					 temp_message_ptr, rsp_bytes_left,
+					 NULL, 0,
+					 NULL, &msg_flags)) < 0) {
+	  if (errno == EINTR) {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  } else if (non_block && errno == EAGAIN) {
+	      continue;
+	  }
+	  perror("send_sctp_rr: data recv error");
+	  exit(1);
+	}
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr  += rsp_bytes_recvd;
+      }	while (!(msg_flags & MSG_EOR));
+      
+      recv_ring = recv_ring->next;
+      
+      if (timed_out) {
+	/* we may have been in a nested while loop - we need */
+	/* another call to break. */
+	break;
+      }
+      
+#ifdef WANT_HISTOGRAM
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += 1;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug > 1) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_sctp_rr: fault with signal set!\n");
+	  fflush(where);
+	  exit(1);
+	}
+	interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  fprintf(where,
+		  "Transaction %d completed\n",
+		  nummessages);
+	  fflush(where);
+	}
+      }
+    }
+
+    /* At this point we used to call shutdown on the data socket to be */
+    /* sure all the data was delivered, but this was not germane in a */
+    /* request/response test, and it was causing the tests to "hang" when */
+    /* they were being controlled by time. So, I have replaced this */
+    /* shutdown call with a call to close that can be found later in the */
+    /* procedure. */
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured? how long */
+						/* did we really run? */
+    
+    /* Get the statistics from the remote end. The remote will have */
+    /* calculated CPU utilization. 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);
+      fprintf(where,"netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      exit(1);
+    }
+    
+    /* We now calculate what our throughput was for the test. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = sctp_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,
+						    sctp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    close(send_socket);
+
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sctp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      thruput,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+
+ /* this routine implements the receive (netserver) side of a TCP_RR */
+ /* test */
+void
+recv_sctp_rr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct sockaddr_in        myaddr_in, peeraddr_in;
+  int	s_listen, s_data;
+  int 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	sctp_rr_request_struct	*sctp_rr_request;
+  struct	sctp_rr_response_struct	*sctp_rr_response;
+  struct	sctp_rr_results_struct	*sctp_rr_results;
+  
+  sctp_rr_request = 
+    (struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sctp_rr_response =
+    (struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sctp_rr_results =
+    (struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sctp_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_sctp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SCTP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_sctp_rr: requested recv alignment of %d offset %d\n",
+	    sctp_rr_request->recv_alignment,
+	    sctp_rr_request->recv_offset);
+    fprintf(where,"recv_sctp_rr: requested send alignment of %d offset %d\n",
+	    sctp_rr_request->send_alignment,
+	    sctp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   sctp_rr_request->response_size,
+				   sctp_rr_request->send_alignment,
+				   sctp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   sctp_rr_request->request_size,
+				   sctp_rr_request->recv_alignment,
+				   sctp_rr_request->recv_offset);
+
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sctp_rr_request->send_buf_size;
+  lsr_size_req = sctp_rr_request->recv_buf_size;
+  loc_nodelay = sctp_rr_request->no_delay;
+  loc_rcvavoid = sctp_rr_request->so_rcvavoid;
+  loc_sndavoid = sctp_rr_request->so_sndavoid;
+  non_block = sctp_rr_request->non_blocking;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sctp_rr_request->ipfamily),
+			sctp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sctp_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_SCTP,
+				0);
+
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen < 0) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == -1) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in, &addrlen) == -1){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sctp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sctp_rr_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  sctp_rr_response->measure_cpu = 0;
+
+  if (sctp_rr_request->measure_cpu) {
+    sctp_rr_response->measure_cpu = 1;
+    sctp_rr_response->cpu_rate = calibrate_local_cpu(sctp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sctp_rr_response->send_buf_size = lss_size;
+  sctp_rr_response->recv_buf_size = lsr_size;
+  sctp_rr_response->no_delay = loc_nodelay;
+  sctp_rr_response->so_rcvavoid = loc_rcvavoid;
+  sctp_rr_response->so_sndavoid = loc_sndavoid;
+  sctp_rr_response->test_length = sctp_rr_request->test_length;
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+
+  if ((s_data = accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == -1) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    
+    exit(1);
+  }
+
+  /* we do not need events on a 1-to-1 RR test.  The test will finish
+   * once all transactions are done.
+   */
+
+  /* now that we are connected, mark the socket as non-blocking */
+  if (non_block) {
+    if (!set_nonblock(s_data)) {
+      perror("netperf: set_nonblock");
+	exit(1);
+    }
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+
+  if (debug) {
+    fprintf(where,"recv_sctp_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(sctp_rr_request->measure_cpu);
+  
+  /* The loop will exit when we hit the end of the test time, or when */
+  /* we have exchanged the requested number of transactions. */
+  
+  if (sctp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(sctp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = sctp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    int msg_flags = 0;
+
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining = sctp_rr_request->request_size;
+    while(!(msg_flags & MSG_EOR)) {
+      if((request_bytes_recvd=sctp_recvmsg(s_data,
+					temp_message_ptr,
+					request_bytes_remaining,
+					NULL, 0,
+					NULL, &msg_flags)) < 0) {
+	if (errno == EINTR) {
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	} else if (non_block && errno == EAGAIN) {
+	    continue;  /* while request_bytes_remaining */
+	}
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      request_bytes_remaining -= request_bytes_recvd;
+      temp_message_ptr += request_bytes_recvd;
+    }
+
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo55\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+
+    /* Now, send the response to the remote
+     * In 1-to-1 API destination addr is not needed.
+     */
+    while ((bytes_sent=sctp_sendmsg(s_data,
+				    send_ring->buffer_ptr,
+				    sctp_rr_request->response_size,
+				    NULL, 0,
+				    0, 0, 0, 0, 0)) == -1) {
+      if (errno == EINTR) {
+	/* the test timer has popped */
+	timed_out = 1;
+	break;
+      } else if (non_block && errno == EAGAIN) {
+	 continue;
+      }
+
+      netperf_response.content.serv_errno = 982;
+      send_response();
+      exit(1);
+    }
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo6\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(sctp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer();
+
+  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_sctp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  sctp_rr_results->bytes_received = (trans_received * 
+				    (sctp_rr_request->request_size + 
+				     sctp_rr_request->response_size));
+  sctp_rr_results->trans_received = trans_received;
+  sctp_rr_results->elapsed_time   = elapsed_time;
+  sctp_rr_results->cpu_method     = cpu_method;
+  sctp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (sctp_rr_request->measure_cpu) {
+    sctp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are now done with the sockets */
+  send_response();
+
+  close(s_data);
+  close(s_listen);
+  
+}
+
+
+
+/* this routine implements the sending (netperf) side of the
+   SCTP_RR_1TOMANY test */
+
+void
+send_sctp_rr_1toMany(remote_host)
+     char	remote_host[];
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len, j = 0;
+  char	*temp_message_ptr;
+  int	nummessages;
+  int	*send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+  int   msg_flags = 0;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+
+  struct sockaddr_storage peer;
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+
+  struct	sctp_rr_request_struct	*sctp_rr_request;
+  struct	sctp_rr_response_struct	*sctp_rr_response;
+  struct	sctp_rr_results_struct	*sctp_rr_result;
+  
+#ifdef WANT_INTERVALS
+  int	interval_count;
+  sigset_t signal_set;
+#endif /* WANT_INTERVALS */
+
+  sctp_rr_request = 
+    (struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sctp_rr_response =
+    (struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sctp_rr_result =
+    (struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_SEQPACKET,
+		     IPPROTO_SCTP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("SCTP 1-TO-MANY REQUEST/RESPONSE TEST",local_res,remote_res);
+  }
+
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  send_socket = malloc(sizeof(int) * num_associations);
+  if (send_socket == NULL) {
+      fprintf(where,
+	      "Could not create the socket array for %d associations",
+	      num_associations);
+      fflush(where);
+      exit(1);
+  }
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back.*/
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 8, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type =	DO_SCTP_RR_MANY;
+    sctp_rr_request->recv_buf_size     =	rsr_size_req;
+    sctp_rr_request->send_buf_size     =	rss_size_req;
+    sctp_rr_request->recv_alignment    =	remote_recv_align;
+    sctp_rr_request->recv_offset       =	remote_recv_offset;
+    sctp_rr_request->send_alignment    =	remote_send_align;
+    sctp_rr_request->send_offset       =	remote_send_offset;
+    sctp_rr_request->request_size      =	req_size;
+    sctp_rr_request->response_size     =	rsp_size;
+    sctp_rr_request->no_delay	       =	rem_nodelay;
+    sctp_rr_request->measure_cpu       =	remote_cpu_usage;
+    sctp_rr_request->cpu_rate	       =	remote_cpu_rate;
+    sctp_rr_request->so_rcvavoid       =	rem_rcvavoid;
+    sctp_rr_request->so_sndavoid       =	rem_sndavoid;
+    if (test_time) {
+      sctp_rr_request->test_length     =	test_time;
+    }
+    else {
+      sctp_rr_request->test_length     =	test_trans * num_associations
+						* -1;
+    }
+    sctp_rr_request->non_blocking      = 	non_block;
+    sctp_rr_request->port              =       atoi(remote_data_port);
+    sctp_rr_request->ipfamily          =       af_to_nf(remote_res->ai_family);
+    if (debug > 1) {
+      fprintf(where,"netperf: send_sctp_rr_1toMany: requesting SCTP rr test\n");
+    }
+    
+    send_request();
+    
+    /* The response from the remote will contain all of the relevant 	*/
+    /* socket parameters for this test type. We will put them back into */
+    /* the variables here so they can be displayed if desired.  The	*/
+    /* remote will have calibrated CPU if necessary, and will have done	*/
+    /* all the needed set-up we will have calibrated the cpu locally	*/
+    /* before sending the request, and will grab the counter value right*/
+    /* after the connect returns. The remote will grab the counter right*/
+    /* after the accept call. This saves the hassle of extra messages	*/
+    /* being sent for the sctp tests.					*/
+  
+    recv_response();
+  
+    if (!netperf_response.content.serv_errno) {
+      rsr_size          = sctp_rr_response->recv_buf_size;
+      rss_size          = sctp_rr_response->send_buf_size;
+      rem_nodelay       = sctp_rr_response->no_delay;
+      remote_cpu_usage  = sctp_rr_response->measure_cpu;
+      remote_cpu_rate   = sctp_rr_response->cpu_rate;
+      /* make sure that port numbers are in network order */
+      set_port_number(remote_res,
+		      (unsigned short)sctp_rr_response->data_port_number);
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      fprintf(where,
+	      "netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      
+      exit(1);
+    }
+    
+    /*set up the data socket list  */
+    for (j = 0; j < num_associations; j++) {
+      send_socket[j] = create_data_socket(local_res);
+  
+      if (send_socket < 0){
+	perror("netperf: send_sctp_rr_1toMany: sctp stream data socket");
+	exit(1);
+      }
+      
+      /*Connect up to the remote port on the data socket  */
+      if (connect(send_socket[j], 
+		  remote_res->ai_addr,
+		  remote_res->ai_addrlen) < 0){
+	perror("netperf: data socket connect failed");
+	
+	exit(1);
+      }
+      
+      /* The client end of the 1-to-Many test uses 1-to-1 sockets.
+       * it doesn't need events.
+       */
+      sctp_enable_events(send_socket[j], 0);
+      
+      if (non_block) {
+        if (!set_nonblock(send_socket[j])) {
+	  close(send_socket[j]);
+	  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 * num_associations;
+      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);
+
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_sctp_rr_1toMany: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+
+    /* 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. */
+
+#ifdef WANT_FIRST_BURST
+    {
+      int i;
+      for (j = 0; j < num_associations; j++) {
+	  for (i = 0; i < first_burst_size; i++) {
+	    if((len=sctp_sendmsg(send_socket[j],
+			 send_ring->buffer_ptr, send_size,
+			 remote_res->ai_addr,
+			 remote_res->ai_addrlen,
+			 0, 0, 0, 0, 0)) != req_size) {
+	      /* we should never hit the end of the test in the first burst */
+	      perror("send_sctp_rr_1toMany: initial burst data send error");
+	      exit(1);
+	    }
+	  }
+      }
+    }
+#endif /* WANT_FIRST_BURST */
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+      
+      /* this is a fairly poor way of testing 1toMany connections.
+       * For each association we measure round trip time to account for
+       * any delay in lookups and delivery.  To stress the server a bit
+       * more we would need a distributed client test, or at least multiple
+       * processes.  I want to force as much paralellism as possible, but
+       * this will do for the fist take. vlad
+       */
+      for (j = 0; j < num_associations; j++) {
+#ifdef WANT_HISTOGRAM
+	/* timestamp just before our call to send, and then again just */
+	/* after the receive raj 8/94 */
+	gettimeofday(&time_one,NULL);
+#endif /* WANT_HISTOGRAM */
+	
+	while ((len=sctp_sendmsg(send_socket[j],
+				 send_ring->buffer_ptr, send_size,
+				 remote_res->ai_addr,
+				 remote_res->ai_addrlen,
+				 0, 0, 0, 0, 0)) != req_size) {
+	  if (non_block && errno == EAGAIN) {
+	    /* try sending again */
+	    continue;
+	  } else if ((errno == EINTR) || (errno == 0)) {
+	    /* we hit the end of a */
+	    /* timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+	  perror("send_sctp_rr_1toMany: data send error");
+	  exit(1);
+	}
+
+	if (timed_out) {
+	  /* we may have been in a nested while loop - we need */
+	  /* another call to break. */
+	  break;
+	}
+	
+	/* setup for the next time */
+	send_ring = send_ring->next;
+	
+	rsp_bytes_left = rsp_size;
+	temp_message_ptr  = recv_ring->buffer_ptr;
+	while (!(msg_flags & MSG_EOR)) {
+	  if((rsp_bytes_recvd = sctp_recvmsg(send_socket[j],
+					     temp_message_ptr,
+					     rsp_bytes_left,
+					     NULL, 0,
+					     NULL, &msg_flags)) < 0) {
+	    if (errno == EINTR) {
+	      /* We hit the end of a timed test. */
+	      timed_out = 1;
+	      break;
+	    } else if (non_block && errno == EAGAIN) {
+	      continue;
+	    }
+	    perror("send_sctp_rr_1toMany: data recv error");
+	    exit(1);
+	  }
+	  rsp_bytes_left -= rsp_bytes_recvd;
+	  temp_message_ptr  += rsp_bytes_recvd;
+	}	
+	recv_ring = recv_ring->next;
+	
+	if (timed_out) {
+	  /* we may have been in a nested while loop - we need */
+	  /* another call to break. */
+	  break;
+	}
+	
+#ifdef WANT_HISTOGRAM
+	gettimeofday(&time_two,NULL);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */
+	
+	nummessages++;          
+	if (trans_remaining) {
+	  trans_remaining--;
+	}
+	
+	if (debug > 3) {
+	  if ((nummessages % 100) == 0) {
+	    fprintf(where,
+		    "Transaction %d completed\n",
+		    nummessages);
+	    fflush(where);
+	  }
+	}
+      }
+    }
+    
+    /* At this point we used to call shutdown on the data socket to be */
+    /* sure all the data was delivered, but this was not germane in a */
+    /* request/response test, and it was causing the tests to "hang" when */
+    /* they were being controlled by time. So, I have replaced this */
+    /* shutdown call with a call to close that can be found later in the */
+    /* procedure. */
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured? how long */
+						/* did we really run? */
+    
+    /* Get the statistics from the remote end. The remote will have */
+    /* calculated CPU utilization. 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);
+      fprintf(where,"netperf: remote error %d",
+	      netperf_response.content.serv_errno);
+      perror("");
+      fflush(where);
+      exit(1);
+    }
+    
+    /* We now calculate what our throughput was for the test. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = sctp_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,
+						    sctp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    for (j = 0; j < num_associations; j++)
+	close(send_socket[j]);
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sctp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      thruput,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+
+ /* this routine implements the receive (netserver) side of a TCP_RR */
+ /* test */
+void
+recv_sctp_rr_1toMany()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+
+  struct sockaddr_in        myaddr_in; 	/* needed to get the port number */
+  struct sockaddr_storage   peeraddr;   /* to communicate with peer */
+  struct addrinfo *local_res;
+  char   local_name[BUFSIZ];
+  char   port_buffer[PORTBUFSIZE];
+  int    msg_flags;
+
+  int	s_rcv;
+  int 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	bytes_recvd;
+  int	recv_buf_size;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	sctp_rr_request_struct	*sctp_rr_request;
+  struct	sctp_rr_response_struct	*sctp_rr_response;
+  struct	sctp_rr_results_struct	*sctp_rr_results;
+  
+  sctp_rr_request = 
+    (struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sctp_rr_response =
+    (struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sctp_rr_results =
+    (struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sctp_rr_1toMany: 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_sctp_rr_1toMany: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SCTP_RR_MANY_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sctp_rr_1toMany: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_sctp_rr_1toMany: requested recv alignment of %d offset %d\n",
+	    sctp_rr_request->recv_alignment,
+	    sctp_rr_request->recv_offset);
+    fprintf(where,"recv_sctp_rr_1toMany: requested send alignment of %d offset %d\n",
+	    sctp_rr_request->send_alignment,
+	    sctp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   sctp_rr_request->response_size,
+				   sctp_rr_request->send_alignment,
+				   sctp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   sctp_rr_request->request_size,
+				   sctp_rr_request->recv_alignment,
+				   sctp_rr_request->recv_offset);
+
+  
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sctp_rr_request->send_buf_size;
+  lsr_size_req = sctp_rr_request->recv_buf_size;
+  loc_nodelay = sctp_rr_request->no_delay;
+  loc_rcvavoid = sctp_rr_request->so_rcvavoid;
+  loc_sndavoid = sctp_rr_request->so_sndavoid;
+  non_block = sctp_rr_request->non_blocking;
+
+  set_hostname_and_port(local_name,
+		        port_buffer,
+			nf_to_af(sctp_rr_request->ipfamily),
+			sctp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sctp_rr_request->ipfamily),
+				SOCK_SEQPACKET,
+				IPPROTO_SCTP,
+				0);
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  if (debug) {
+    fprintf(where,"recv_sctp_rr_1toMany: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  s_rcv = create_data_socket(local_res);
+  
+  if (s_rcv < 0) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_rcv, 5) == -1) {
+    netperf_response.content.serv_errno = errno;
+    close(s_rcv);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_rcv,
+		  (struct sockaddr *)&myaddr_in, &addrlen) == -1){
+    netperf_response.content.serv_errno = errno;
+    close(s_rcv);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sctp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sctp_rr_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  sctp_rr_response->measure_cpu = 0;
+
+  if (sctp_rr_request->measure_cpu) {
+    sctp_rr_response->measure_cpu = 1;
+    sctp_rr_response->cpu_rate = calibrate_local_cpu(sctp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sctp_rr_response->send_buf_size = lss_size;
+  sctp_rr_response->recv_buf_size = lsr_size;
+  sctp_rr_response->no_delay = loc_nodelay;
+  sctp_rr_response->so_rcvavoid = loc_rcvavoid;
+  sctp_rr_response->so_sndavoid = loc_sndavoid;
+  sctp_rr_response->test_length = sctp_rr_request->test_length;
+  send_response();
+  
+  /* Don't need events */
+  sctp_enable_events(s_rcv, 0);
+
+  /* now that we are connected, mark the socket as non-blocking */
+  if (non_block) {
+    if (!set_nonblock(s_rcv)) {
+      perror("netperf: set_nonblock");
+	exit(1);
+    }
+  }
+
+  /* FIXME:  The way 1-to-Many test operates right now, we are including
+   * association setup time into our measurements.  The reason for this
+   * is that the client creates multiple endpoints and connects each
+   * endpoint to us using the connect call.  On this end we simply call
+   * recvmsg() to get data becuase there is no equivalen of accept() for
+   * 1-to-Many API.  
+   * I think this is OK, but if it were to be fixed, the server side
+   * would need to know how many associations are being setup and
+   * have a recvmsg() loop with SCTP_ASSOC_CHANGE events waiting for
+   * all the associations to be be established.
+   * I am punting on this for now.
+   */
+
+
+  addrlen = sizeof(peeraddr);
+
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(sctp_rr_request->measure_cpu);
+  
+  /* The loop will exit when we hit the end of the test time, or when */
+  /* we have exchanged the requested number of transactions. */
+  
+  if (sctp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(sctp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = sctp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+
+    recv_buf_size = sctp_rr_request->request_size;
+ 
+    /* Receive the data.  We don't particularly care which association
+     * the data came in on.  We'll simply be doing a receive untill
+     * we get and MSG_EOR flag (meaning that a single transmission was
+     * received) and a send to the same address, so the RR would be for
+     * the same associations.
+     * We can get away with this because the client will establish all
+     * the associations before transmitting any data.  Any partial data
+     * will not have EOR thus will we will not send a response untill
+     * we get everything.
+     */
+    
+    do {
+      msg_flags = 0;
+      if((bytes_recvd = sctp_recvmsg(s_rcv,
+				     recv_ring->buffer_ptr,
+				     recv_buf_size,
+				     (struct sockaddr *)&peeraddr, &addrlen,
+				     0, &msg_flags)) == SOCKET_ERROR) {
+	if (SOCKET_EINTR(bytes_recvd)) {
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	} else if (non_block & errno == EAGAIN) {
+	    /* do recvmsg again */
+	    continue;
+	}
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+    } while(!(msg_flags & MSG_EOR));
+
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo5\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    while ((bytes_sent=sctp_sendmsg(s_rcv,
+			      send_ring->buffer_ptr,
+			      sctp_rr_request->response_size,
+			      (struct sockaddr *)&peeraddr, addrlen,
+			      0, 0, 0, 0, 0)) == SOCKET_ERROR) {
+      if (SOCKET_EINTR(bytes_sent)) {
+	/* the test timer has popped */
+	timed_out = 1;
+	break;
+      } else if (non_block && errno == EAGAIN) {
+	 continue;
+      }
+
+      netperf_response.content.serv_errno = 992;
+      send_response();
+      exit(1);
+    }
+
+    if (timed_out) {
+      if (debug) {
+	fprintf(where,"yo6\n");
+	fflush(where);
+      }						
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      break;
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(sctp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer();
+
+  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_sctp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  sctp_rr_results->bytes_received = (trans_received * 
+				    (sctp_rr_request->request_size + 
+				     sctp_rr_request->response_size));
+  sctp_rr_results->trans_received = trans_received;
+  sctp_rr_results->elapsed_time   = elapsed_time;
+  sctp_rr_results->cpu_method     = cpu_method;
+  sctp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (sctp_rr_request->measure_cpu) {
+    sctp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sctp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are now done with the sockets */
+  close(s_rcv);
+
+  send_response();
+  
+}
+
+
+void
+print_sctp_usage()
+{
+
+  printf("%s",sctp_usage);
+  exit(1);
+
+}
+void
+scan_sctp_args(argc, argv)
+     int	argc;
+     char	*argv[];
+
+{
+
+#define SOCKETS_ARGS "BDhH:I:L:m:M:P:r:s:S:VN:T:46"
+
+  extern char	*optarg;	  /* pointer to option string	*/
+  
+  int		c;
+  
+  char	
+    arg1[BUFSIZ],  /* argument holders		*/
+    arg2[BUFSIZ];
+
+  if (no_control) {
+    fprintf(where,
+	    "The SCTP tests do not know how to deal with no control tests\n");
+    exit(-1);
+  }
+
+  strncpy(local_data_port,"0",sizeof(local_data_port));
+  strncpy(remote_data_port,"0",sizeof(remote_data_port));
+  
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form "first," (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, SOCKETS_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case '4':
+      remote_data_family = AF_INET;
+      local_data_family = AF_INET;
+      break;
+    case '6':
+#if defined(AF_INET6)
+      remote_data_family = AF_INET6;
+      local_data_family = AF_INET6;
+#else
+      fprintf(stderr,
+	      "This netperf was not compiled on an IPv6 capable host!\n");
+      fflush(stderr);
+      exit(-1);
+#endif
+      break;
+    case 'h':
+      print_sctp_usage();
+      exit(1);
+    case 'b':
+#ifdef WANT_FIRST_BURST
+      first_burst_size = atoi(optarg);
+#else /* WANT_FIRST_BURST */
+      printf("Initial request burst functionality not compiled-in!\n");
+#endif /* WANT_FIRST_BURST */
+      break;
+    case 'D':
+      /* set the nodelay flag */
+      loc_nodelay = 1;
+      rem_nodelay = 1;
+      break;
+    case 'H':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	remote_data_address = malloc(strlen(arg1)+1);
+	strncpy(remote_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	remote_data_family = parse_address_family(arg2);
+      break;
+    case 'L':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	local_data_address = malloc(strlen(arg1)+1);
+	strncpy(local_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	local_data_family = parse_address_family(arg2);
+      break;
+    case 'P':
+      /* set the local and remote data port numbers for the tests to
+	 allow them to run through those blankety blank end-to-end
+	 breaking firewalls. raj 2004-06-15 */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(local_data_port,arg1,sizeof(local_data_port));
+      if (arg2[0])	
+	strncpy(remote_data_port,arg2,sizeof(remote_data_port));
+      break;
+    case 's':
+      /* set local socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	lss_size_req = convert(arg1);
+      if (arg2[0])
+	lsr_size_req = convert(arg2);
+      break;
+    case 'S':
+      /* set remote socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	rss_size_req = convert(arg1);
+      if (arg2[0])
+	rsr_size_req = convert(arg2);
+      break;
+    case 'r':
+      /* set the request/response sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	req_size = convert(arg1);
+      if (arg2[0])	
+	rsp_size = convert(arg2);
+      break;
+    case 'm':
+      /* set size of the buffer for each sent message */
+      send_size = convert(optarg);
+      break;
+    case 'M':
+      /* set the size of the buffer for each received message */
+      recv_size = convert(optarg);
+      break;
+    case 't':
+      /* set the test name */
+      strcpy(test_name,optarg);
+      break;
+    case 'W':
+	/* set the "width" of the user space data */
+	/* buffer. This will be the number of */
+	/* send_size buffers malloc'd in the */
+	/* *_STREAM test. It may be enhanced to set */
+	/* both send and receive "widths" but for now */
+	/* it is just the sending *_STREAM. */
+	send_width = convert(optarg);
+	break;
+    case 'V':
+      /* we want to do copy avoidance and will set */
+      /* it for everything, everywhere, if we really */
+      /* can. of course, we don't know anything */
+      /* about the remote... */
+#ifdef SO_SND_COPYAVOID
+      loc_sndavoid = 1;
+#else
+      loc_sndavoid = 0;
+      printf("Local send copy avoidance not available.\n");
+#endif
+#ifdef SO_RCV_COPYAVOID
+      loc_rcvavoid = 1;
+#else
+      loc_rcvavoid = 0;
+      printf("Local recv copy avoidance not available.\n");
+#endif
+      rem_sndavoid = 1;
+      rem_rcvavoid = 1;
+      break;
+    case 'N':
+      /* this opton allows the user to set the number of 
+       * messages to send.  This in effect modifies the test
+       * time.  If we know the message size, then the we can
+       * express the test time as message_size * number_messages
+       */
+      msg_count = convert (optarg);
+      if (msg_count > 0)
+	  test_time = 0;
+      break;
+    case 'B':
+      non_block = 1;
+      break;
+    case 'T':
+      num_associations = atoi(optarg);
+      if (num_associations <= 1) {
+	  printf("Number of SCTP associations must be >= 1\n");
+	  exit(1);
+      }
+      break;
+    };
+  }
+}
+
+#endif  /* WANT_SCTP */
diff --git a/nettest_sctp.h b/nettest_sctp.h
new file mode 100644
index 0000000..5297853
--- /dev/null
+++ b/nettest_sctp.h
@@ -0,0 +1,128 @@
+/*
+        Copyright (C) 1993-2003 Hewlett-Packard Company
+*/
+
+ /* This file contains the test-specific definitions for netperf's BSD */
+ /* sockets tests */
+
+
+struct	sctp_stream_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	receive_size;   /* how many bytes do we want to receive at one */
+			/* time? */ 
+  int	recv_alignment; /* what is the alignment of the receive */
+			/* buffer? */ 
+  int	recv_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   port;		/* the to port to which recv side should bind
+			   to allow netperf to run through firewalls */
+  int   ipfamily;	/* address family of ipaddress */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct	sctp_stream_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	receive_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct sctp_stream_results_struct {
+  double         bytes_received;
+  unsigned int	 recv_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	sctp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;		/* the to port to which recv side should bind
+			   to allow netperf to run through firewalls */
+  int   ipfamily;	/* address family of ipaddress */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct	sctp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct sctp_rr_results_struct {
+  unsigned int  bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+#define SCTP_SNDRCV_INFO_EV		0x01
+#define SCTP_ASSOC_CHANGE_EV		0x02
+#define SCTP_PEERADDR_CHANGE_EV		0x04
+#define SCTP_SND_FAILED_EV		0x08
+#define SCTP_REMOTE_ERROR_EV		0x10
+#define SCTP_SHUTDOWN_EV		0x20
+#define SCTP_PD_EV			0x40
+#define SCTP_ADAPT_EV			0x80
+
+typedef enum sctp_disposition {
+    SCTP_OK = 1,
+    SCTP_CLOSE,
+} sctp_disposition_t;
+
+extern void send_sctp_stream();
+extern void send_sctp_rr();
+
+extern void recv_sctp_stream();
+extern void recv_sctp_rr();
+
+extern void loc_cpu_rate();
+extern void rem_cpu_rate();
diff --git a/nettest_sdp.c b/nettest_sdp.c
new file mode 100644
index 0000000..696fd3e
--- /dev/null
+++ b/nettest_sdp.c
@@ -0,0 +1,3553 @@
+#ifndef lint
+char	nettest_sdp[]="\
+@(#)nettest_sdp.c (c) Copyright 2007 Hewlett-Packard Co. Version 2.4.4";
+#else
+#define DIRTY
+#define WANT_HISTOGRAM
+#define WANT_INTERVALS
+#endif /* lint */
+
+/****************************************************************/
+/*								*/
+/*	nettest_sdp.c						*/
+/*								*/
+/*                                                              */
+/*      scan_sdp_args()        get the sdp command line args  */
+/*                                                              */
+/*	the actual test routines...				*/
+/*								*/
+/*	send_sdp_stream()	perform a sdp stream test	*/
+/*	recv_sdp_stream()					*/
+/*	send_sdp_rr()		perform a sdp request/response	*/
+/*	recv_sdp_rr()						*/
+/*								*/
+/*      relies on create_data_socket in nettest_bsd.c           */
+/****************************************************************/
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if defined(WANT_SDP)
+     
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#ifdef NOSTDLIBH
+#include <malloc.h>
+#else /* NOSTDLIBH */
+#include <stdlib.h>
+#endif /* NOSTDLIBH */
+
+#if !defined(__VMS)
+#include <sys/ipc.h>
+#endif /* !defined(__VMS) */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+/* would seem that not all sdp.h files define a MSG_EOF, but that
+   MSG_EOF can be the same as MSG_FIN so lets work with that
+   assumption.  initial find by Jon Pedersen. raj 2006-02-01 */
+#ifndef MSG_EOF
+#ifdef MSG_FIN
+#define MSG_EOF MSG_FIN
+#else
+#error Must have either MSG_EOF or MSG_FIN defined
+#endif
+#endif 
+
+#include "netlib.h"
+#include "netsh.h"
+/* get some of the functions from nettest_bsd.c */
+#include "nettest_bsd.h"
+#include "nettest_sdp.h"
+
+#ifdef WANT_HISTOGRAM
+#ifdef __sgi
+#include <sys/time.h>
+#endif /* __sgi */
+#include "hist.h"
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_FIRST_BURST
+extern int first_burst_size;
+#endif /* WANT_FIRST_BURST */
+
+
+
+/* these variables are specific to SDP tests. declare */
+/* them static to make them global only to this file. */
+
+static int	
+  msg_count = 0,	/* number of messages to transmit on association */
+  non_block = 0,	/* default to blocking sockets */
+  num_associations = 1; /* number of associations on the endpoint */
+
+static  int confidence_iteration;
+static  char  local_cpu_method;
+static  char  remote_cpu_method;
+
+#ifdef WANT_HISTOGRAM
+static struct timeval time_one;
+static struct timeval time_two;
+static HIST time_hist;
+#endif /* WANT_HISTOGRAM */
+
+
+char sdp_usage[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+SDP Sockets Test Options:\n\
+    -b number         Send number requests at the start of _RR tests\n\
+    -D [L][,R]        Set SDP_NODELAY locally and/or remotely\n\
+    -h                Display this text\n\
+    -H name,fam       Use name (or IP) and family as target of data connection\n\
+    -L name,fam       Use name (or IP) and family as source of data connextion\n\
+    -m bytes          Set the size of each sent message\n\
+    -M bytes          Set the size of each received messages\n\
+    -P local[,remote] Set the local/remote port for the data socket\n\
+    -r req,[rsp]      Set request/response sizes (_RR tests)\n\
+    -s send[,recv]    Set local socket send/recv buffer sizes\n\
+    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
+    -V 		      Enable copy avoidance if supported\n\
+    -4                Use AF_INET (eg IPv4) on both ends of the data conn\n\
+    -6                Use AF_INET6 (eg IPv6) on both ends of the data conn\n\
+\n\
+For those options taking two parms, at least one must be specified;\n\
+specifying one value without a comma will set both parms to that\n\
+value, specifying a value with a leading comma will set just the second\n\
+parm, a value with a trailing comma will set just the first. To set\n\
+each parm to unique values, specify both and separate them with a\n\
+comma.\n"; 
+     
+
+ /* This routine is intended to retrieve interesting aspects of sdp */
+ /* for the data connection. at first, it attempts to retrieve the */
+ /* maximum segment size. later, it might be modified to retrieve */
+ /* other information, but it must be information that can be */
+ /* retrieved quickly as it is called during the timing of the test. */
+ /* for that reason, a second routine may be created that can be */
+ /* called outside of the timing loop */
+static
+void
+get_sdp_info(int socket, int * mss)
+{
+
+#ifdef TCP_MAXSEG
+  netperf_socklen_t sock_opt_len;
+
+  sock_opt_len = sizeof(netperf_socklen_t);
+  if (getsockopt(socket,
+		 getprotobyname("tcp")->p_proto,	
+		 TCP_MAXSEG,
+		 (char *)mss,
+		 &sock_opt_len) == SOCKET_ERROR) {
+    fprintf(where,
+	    "netperf: get_sdp_info: getsockopt TCP_MAXSEG: errno %d\n",
+	    errno);
+    fflush(where);
+    *mss = -1;
+  }
+#else
+  *mss = -1;
+#endif /* TCP_MAXSEG */
+
+}
+
+void 
+send_sdp_stream(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   %s\n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %6d    %-6.2f     %7.2f   %-6.2f   %-6.2f   %-6.3f  %-6.3f %s\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";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+  /* 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;
+  
+  int len;
+  unsigned int nummessages = 0;
+  SOCKET send_socket;
+  int bytes_remaining;
+  int sdp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+
+  unsigned long long local_bytes_sent = 0;
+  double	bytes_sent = 0.0;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+  
+  struct	sdp_stream_request_struct	*sdp_stream_request;
+  struct	sdp_stream_response_struct	*sdp_stream_response;
+  struct	sdp_stream_results_struct	*sdp_stream_result;
+  
+  sdp_stream_request  = 
+    (struct sdp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sdp_stream_response =
+    (struct sdp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sdp_stream_result   = 
+    (struct sdp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+  /* 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. */
+  
+  /* complete_addrinfos will either succede or exit the process */
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+  
+  if ( print_headers ) {
+    print_top_test_header("SDP STREAM TEST",local_res,remote_res);
+  }
+
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /*set up the data socket                        */
+    /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+    local_res->ai_family = AF_INET_SDP;
+    local_res->ai_protocol = 0;
+    send_socket = create_data_socket(local_res);
+    
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_sdp_stream: sdp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_sdp_stream: send_socket obtained...\n");
+    }
+    
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one send-size greater than our socket */
+    /* buffer size. We want to be sure that there are at least two */
+    /* buffers allocated - this can be a bit of a problem when the */
+    /* send_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our send */
+    /* buffers, we should respect that wish... */
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) {
+      /* only allocate the send ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* Tell the remote end to do a listen. The server alters the
+	 socket paramters on the other side at this point, hence the
+	 reason for all the values being passed in the setup
+	 message. If the user did not specify any of the parameters,
+	 they will be passed as 0, which will indicate to the remote
+	 that no changes beyond the system's default should be
+	 used. Alignment is the exception, it will default to 1, which
+	 will be no alignment alterations. */
+    
+      netperf_request.content.request_type =	DO_SDP_STREAM;
+      sdp_stream_request->send_buf_size	=	rss_size_req;
+      sdp_stream_request->recv_buf_size	=	rsr_size_req;
+      sdp_stream_request->receive_size	=	recv_size;
+      sdp_stream_request->no_delay	=	rem_nodelay;
+      sdp_stream_request->recv_alignment	=	remote_recv_align;
+      sdp_stream_request->recv_offset	=	remote_recv_offset;
+      sdp_stream_request->measure_cpu	=	remote_cpu_usage;
+      sdp_stream_request->cpu_rate	=	remote_cpu_rate;
+      if (test_time) {
+	sdp_stream_request->test_length	=	test_time;
+      }
+      else {
+	sdp_stream_request->test_length	=	test_bytes;
+      }
+      sdp_stream_request->so_rcvavoid	=	rem_rcvavoid;
+      sdp_stream_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+      sdp_stream_request->dirty_count     =       rem_dirty_count;
+      sdp_stream_request->clean_count     =       rem_clean_count;
+#endif /* DIRTY */
+      sdp_stream_request->port            =    atoi(remote_data_port);
+      sdp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
+      if (debug > 1) {
+	fprintf(where,
+		"netperf: send_sdp_stream: requesting SDP 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 SDP
+         tests.  */
+    
+      recv_response();
+    
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"remote listen done.\n");
+	rsr_size	      =	sdp_stream_response->recv_buf_size;
+	rss_size	      =	sdp_stream_response->send_buf_size;
+	rem_nodelay     =	sdp_stream_response->no_delay;
+	remote_cpu_usage=	sdp_stream_response->measure_cpu;
+	remote_cpu_rate = sdp_stream_response->cpu_rate;
+	
+	/* we have to make sure that the server port number is in
+	   network order */
+	set_port_number(remote_res,
+			(short)sdp_stream_response->data_port_number);
+	
+	rem_rcvavoid	= sdp_stream_response->so_rcvavoid;
+	rem_sndavoid	= sdp_stream_response->so_sndavoid;
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lss_size,rsr_size)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: send_sdp_stream: data socket connect failed");
+      exit(1);
+    }
+
+    /* Data Socket set-up is finished. If there were problems, either */
+    /* the connect would have failed, or the previous response would */
+    /* have indicated a problem. I failed to see the value of the */
+    /* extra  message after the accept on the remote. If it failed, */
+    /* we'll see it here. If it didn't, we might as well start pumping */
+    /* data. */ 
+    
+    /* Set-up the test end conditions. For a 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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      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 only start the interval timer if we are using the
+       timer-timed intervals rather than the sit and spin ones. raj
+       2006-02-06 */    
+#if defined(WANT_INTERVALS)
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+    /* before we start, initialize a few variables */
+
+#ifdef WANT_DEMO
+      if (demo_mode) {
+	HIST_timestamp(demo_one_ptr);
+      }
+#endif
+      
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+#ifdef DIRTY
+      access_buffer(send_ring->buffer_ptr,
+		    send_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before we go into send and then again just
+	 after we come out raj 8/94 */
+	/* but lets only do this if there is going to be a histogram
+	   displayed */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+
+      if((len=send(send_socket,
+		   send_ring->buffer_ptr,
+		   send_size,
+		   0)) != send_size) {
+      if ((len >=0) || SOCKET_EINTR(len)) {
+	    /* the test was interrupted, must be the end of test */
+	    break;
+	  }
+	perror("netperf: data send error");
+	printf("len was %d\n",len);
+	exit(1);
+      }
+
+      local_bytes_sent += send_size;
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp the exit from the send call and update the histogram */
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(send_size)
+#endif 
+
+#if defined(WANT_INTERVALS)
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      send_ring = send_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a */
+    /* graceful release to insure that all data has been taken by the */
+    /* remote. */ 
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the SDP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      sdp_mss = -1;
+      get_sdp_info(send_socket,&sdp_mss);
+    }
+    
+    if (shutdown(send_socket,SHUT_WR) == SOCKET_ERROR) {
+      perror("netperf: cannot shutdown sdp stream socket");
+      exit(1);
+    }
+    
+    /* hang a recv() off the socket to block until the remote has */
+    /* brought all the data up into the application. it will do a */
+    /* shutdown to cause a FIN to be sent our way. We will assume that */
+    /* any exit from the recv() call is good... raj 4/93 */
+    
+    recv(send_socket, send_ring->buffer_ptr, send_size, 0);
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+
+    close(send_socket);
+
+    if (!no_control) {
+      /* 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);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	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
+	 SDP 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	= ntohd(sdp_stream_result->bytes_received);
+    }
+    else {
+      bytes_sent = (double)local_bytes_sent;
+    }
+
+    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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= sdp_stream_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      sdp_stream_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sdp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+		fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand,	/* remote service demand */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+		fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput,                  /* how fast did it go */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      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 */
+    /* SDP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)sdp_stream_result->recv_calls,
+	    sdp_stream_result->recv_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    sdp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+
+/* This routine implements the netperf-side SDP unidirectional data
+   transfer test (a.k.a. stream) for the sockets interface where the
+   data flow is from the netserver to the netperf.  It receives its
+   parameters via global variables from the shell and writes its
+   output to the standard output. */
+
+
+void 
+send_sdp_maerts(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   \n %s";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %6d    %-6.2f     %7.2f   %-6.2f   %-6.2f   %-6.3f  %-6.3f %s\n";
+  
+  char *ksink_fmt = "\n\
+Alignment      Offset         %-8.8s %-8.8s    Recvs   %-8.8s Sends\n\
+Local  Remote  Local  Remote  Xfered   Per                 Per\n\
+Recv   Send    Recv   Send             Recv (avg)          Send (avg)\n\
+%5d   %5d  %5d   %5d %6.4g  %6.2f    %6d   %6.2f %6d\n";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* recv-size greater than our recv 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 *recv_ring;
+  
+  int len;
+  unsigned int nummessages = 0;
+  SOCKET recv_socket;
+  int bytes_remaining;
+  int sdp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can recv > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+  double	bytes_sent = 0.0;
+  unsigned long long local_bytes_recvd = 0;
+
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  struct addrinfo *remote_res;
+  struct addrinfo *local_res;
+  
+  struct	sdp_maerts_request_struct	*sdp_maerts_request;
+  struct	sdp_maerts_response_struct	*sdp_maerts_response;
+  struct	sdp_maerts_results_struct	*sdp_maerts_result;
+  
+  sdp_maerts_request  = 
+    (struct sdp_maerts_request_struct *)netperf_request.content.test_specific_data;
+  sdp_maerts_response =
+    (struct sdp_maerts_response_struct *)netperf_response.content.test_specific_data;
+  sdp_maerts_result   = 
+    (struct sdp_maerts_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+  /* 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. */
+  
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+  
+  if ( print_headers ) {
+    print_top_test_header("SDP MAERTS TEST",local_res,remote_res);
+  }
+
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /*set up the data socket                        */
+    /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+    local_res->ai_family = AF_INET_SDP;
+    local_res->ai_protocol = 0;
+    recv_socket = create_data_socket(local_res);
+    
+    if (recv_socket == INVALID_SOCKET){
+      perror("netperf: send_sdp_maerts: sdp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_sdp_maerts: recv_socket obtained...\n");
+    }
+
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the recv */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the recv size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (recv_size == 0) {
+      if (lsr_size > 0) {
+	recv_size = lsr_size;
+      }
+      else {
+	recv_size = 4096;
+      }
+    }
+
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one recv-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 */
+    /* recv_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our recv */
+    /* buffers, we should respect that wish... */
+    if (recv_width == 0) {
+      recv_width = (lsr_size/recv_size) + 1;
+      if (recv_width == 1) recv_width++;
+    }
+    
+    if (recv_ring == NULL) {
+      /* only allocate the recv ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      recv_ring = allocate_buffer_ring(recv_width,
+				       recv_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* Tell the remote end to do a listen. The server alters the
+	 socket paramters on the other side at this point, hence the
+	 reason for all the values being passed in the setup
+	 message. If the user did not specify any of the parameters,
+	 they will be passed as 0, which will indicate to the remote
+	 that no changes beyond the system's default should be
+	 used. Alignment is the exception, it will default to 1, which
+	 will be no alignment alterations. */
+
+      netperf_request.content.request_type	=	DO_SDP_MAERTS;
+      sdp_maerts_request->send_buf_size	=	rss_size_req;
+      sdp_maerts_request->recv_buf_size	=	rsr_size_req;
+      sdp_maerts_request->send_size	=	send_size;
+      sdp_maerts_request->no_delay	=	rem_nodelay;
+      sdp_maerts_request->send_alignment	=	remote_send_align;
+      sdp_maerts_request->send_offset	=	remote_send_offset;
+      sdp_maerts_request->measure_cpu	=	remote_cpu_usage;
+      sdp_maerts_request->cpu_rate	=	remote_cpu_rate;
+      if (test_time) {
+	sdp_maerts_request->test_length	=	test_time;
+      }
+      else {
+	sdp_maerts_request->test_length	=	test_bytes;
+      }
+      sdp_maerts_request->so_rcvavoid	=	rem_rcvavoid;
+      sdp_maerts_request->so_sndavoid	=	rem_sndavoid;
+#ifdef DIRTY
+      sdp_maerts_request->dirty_count       =       rem_dirty_count;
+      sdp_maerts_request->clean_count       =       rem_clean_count;
+#endif /* DIRTY */
+      sdp_maerts_request->port            = atoi(remote_data_port);
+      sdp_maerts_request->ipfamily        = af_to_nf(remote_res->ai_family);
+      if (debug > 1) {
+	fprintf(where,
+		"netperf: send_sdp_maerts: requesting SDP maerts 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 SDP
+	 tests.  */
+      
+      recv_response();
+    
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"remote listen done.\n");
+	rsr_size	=	sdp_maerts_response->recv_buf_size;
+	rss_size	=	sdp_maerts_response->send_buf_size;
+	rem_nodelay     =	sdp_maerts_response->no_delay;
+	remote_cpu_usage=	sdp_maerts_response->measure_cpu;
+	remote_cpu_rate = sdp_maerts_response->cpu_rate;
+	send_size       = sdp_maerts_response->send_size;
+	
+	/* we have to make sure that the server port number is in
+	 network order */
+      set_port_number(remote_res,
+		      (short)sdp_maerts_response->data_port_number);
+      rem_rcvavoid	= sdp_maerts_response->so_rcvavoid;
+      rem_sndavoid	= sdp_maerts_response->so_sndavoid;
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_STREAM_SETUP(lsr_size,rss_size)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(recv_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: send_sdp_maerts: data socket connect failed");
+      exit(1);
+    }
+
+    /* Data Socket set-up is finished. If there were problems, either */
+    /* the connect would have failed, or the previous response would */
+    /* have indicated a problem. I failed to see the value of the */
+    /* extra  message after the accept on the remote. If it failed, */
+    /* we'll see it here. If it didn't, we might as well start pumping */
+    /* data. */ 
+    
+    /* Set-up the test end conditions. For a maerts 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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      if (!no_control) {
+	/* this is a netperf to netserver test, netserver will close
+	   to tell us the test is over, so use PAD_TIME to avoid
+	   causing the netserver fits. */
+	start_timer(test_time + PAD_TIME);
+      }
+      else {
+	/* this is a netperf to data source test, no PAD_TIME */
+	start_timer(test_time);
+      }
+    }
+    else {
+      /* The tester wanted to recv a number of bytes. we don't do that 
+	 in a SDP_MAERTS test. sorry. raj 2002-06-21 */
+      printf("netperf: send_sdp_maerts: test must be timed\n");
+      exit(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);
+    
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+
+    /* before we start, initialize a few variables */
+
+#ifdef WANT_DEMO
+    if (demo_mode) {
+      HIST_timestamp(demo_one_ptr);
+    }
+#endif
+
+    /* the test will continue until we either get a zero-byte recv()
+       on the socket or our failsafe timer expires. most of the time
+       we trust that we get a zero-byte recieve from the socket. raj
+       2002-06-21 */
+
+#ifdef WANT_HISTOGRAM
+    if (verbosity > 1) {
+      /* timestamp just before we go into recv and then again just
+	 after we come out raj 8/94 */
+      /* but only if we are actually going to display a histogram. raj
+	 2006-02-07 */
+      HIST_timestamp(&time_one);
+    }
+#endif /* WANT_HISTOGRAM */
+    
+    while ((!times_up) && (len=recv(recv_socket,
+				    recv_ring->buffer_ptr,
+				    recv_size,
+				    0)) > 0 ) {
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp the exit from the recv call and update the histogram */
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef DIRTY
+      access_buffer(recv_ring->buffer_ptr,
+		    recv_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+
+#ifdef WANT_DEMO
+      DEMO_STREAM_INTERVAL(len);
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the recv width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      recv_ring = recv_ring->next;
+      if (bytes_remaining) {
+	bytes_remaining -= len;
+      }
+
+      local_bytes_recvd += len;
+
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* make sure we timestamp just before we go into recv  */
+	/* raj 2004-06-15 */
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+    
+    }
+
+    /* an EINTR is to be expected when this is a no_control test */
+    if (((len < 0) || SOCKET_EINTR(len)) && (!no_control)) {
+      perror("send_sdp_maerts: data recv error");
+      printf("len was %d\n",len);
+      exit(1);
+    }
+    
+    /* if we get here, it must mean we had a recv return of 0 before
+       the watchdog timer expired, or the watchdog timer expired and
+       this was a no_control test */
+
+    /* The test is over. Flush the buffers to the remote end. We do a
+       graceful release to tell the  remote we have all the data. */  
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the SDP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      sdp_mss = -1;
+      get_sdp_info(recv_socket,&sdp_mss);
+    }
+    
+    if (shutdown(recv_socket,SHUT_WR) == SOCKET_ERROR) {
+      perror("netperf: cannot shutdown sdp maerts socket");
+      exit(1);
+    }
+
+    stop_timer();
+    
+    /* this call will always give us the local elapsed time for the
+       test, and will also store-away the necessaries for cpu
+       utilization */ 
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */
+    
+    /* we are finished with the socket, so close it to prevent hitting */
+    /* the limit on maximum open files. */
+
+    close(recv_socket);
+
+    if (!no_control) {
+      /* 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);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	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
+	 SDP maerts 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 recv_size, so we
+	 really didn't recv what he asked for ;-) */
+    
+      bytes_sent	= ntohd(sdp_maerts_result->bytes_sent);
+    }
+    else {
+      bytes_sent = (double)local_bytes_recvd;
+    }
+
+
+    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) {
+	
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	
+	remote_cpu_utilization	= sdp_maerts_result->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      sdp_maerts_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sdp_maerts_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the recvs */
+	      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 */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      lsr_size, 		/* local recvbuf size */
+	      rss_size, 		/* remot sendbuf size */
+	      send_size,		/* how large were the recvs */
+	      elapsed_time, 		/* how long did it take */
+	      thruput,                  /* how fast did it go */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      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 */
+    /* SDP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    fprintf(where,
+	    ksink_fmt,
+	    "Bytes",
+	    "Bytes",
+	    "Bytes",
+	    local_recv_align,
+	    remote_recv_align,
+	    local_recv_offset,
+	    remote_recv_offset,
+	    bytes_sent,
+	    bytes_sent / (double)nummessages,
+	    nummessages,
+	    bytes_sent / (double)sdp_maerts_result->send_calls,
+	    sdp_maerts_result->send_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    sdp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in recv() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+/* This is the server-side routine for the sdp stream test. It is */
+/* implemented as one routine. I could break things-out somewhat, but */
+/* didn't feel it was necessary. */
+
+void
+recv_sdp_stream()
+{
+  
+  struct sockaddr_in myaddr_in, peeraddr_in;
+  SOCKET s_listen,s_data;
+  netperf_socklen_t addrlen;
+  int	len;
+  unsigned int	receive_calls;
+  float	elapsed_time;
+  double   bytes_received;
+  
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+#ifdef DO_SELECT
+  fd_set readfds;
+  struct timeval timeout;
+#endif /* DO_SELECT */
+
+  struct	sdp_stream_request_struct	*sdp_stream_request;
+  struct	sdp_stream_response_struct	*sdp_stream_response;
+  struct	sdp_stream_results_struct	*sdp_stream_results;
+  
+#ifdef DO_SELECT
+  FD_ZERO(&readfds);
+  timeout.tv_sec = 1;
+  timeout.tv_usec = 0;
+#endif /* DO_SELECT */
+
+  sdp_stream_request	= 
+    (struct sdp_stream_request_struct *)netperf_request.content.test_specific_data;
+  sdp_stream_response	= 
+    (struct sdp_stream_response_struct *)netperf_response.content.test_specific_data;
+  sdp_stream_results	= 
+    (struct sdp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sdp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SDP_STREAM_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_stream: requested alignment of %d\n",
+	    sdp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sdp_stream_request->send_buf_size;
+  lsr_size_req = sdp_stream_request->recv_buf_size;
+  loc_nodelay  = sdp_stream_request->no_delay;
+  loc_rcvavoid = sdp_stream_request->so_rcvavoid;
+  loc_sndavoid = sdp_stream_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sdp_stream_request->ipfamily),
+			sdp_stream_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sdp_stream_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+  local_res->ai_family = AF_INET_SDP;
+  local_res->ai_protocol = 0;
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+  
+  /* what sort of sizes did we end-up with? */
+  if (sdp_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = sdp_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   sdp_stream_request->recv_alignment,
+				   sdp_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_sdp_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sdp_stream_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sdp_stream_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (sdp_stream_request->measure_cpu) {
+    sdp_stream_response->measure_cpu = 1;
+    sdp_stream_response->cpu_rate = 
+      calibrate_local_cpu(sdp_stream_request->cpu_rate);
+  }
+  else {
+    sdp_stream_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sdp_stream_response->send_buf_size = lss_size;
+  sdp_stream_response->recv_buf_size = lsr_size;
+  sdp_stream_response->no_delay = loc_nodelay;
+  sdp_stream_response->so_rcvavoid = loc_rcvavoid;
+  sdp_stream_response->so_sndavoid = loc_sndavoid;
+  sdp_stream_response->receive_size = recv_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  if ((s_data=accept(s_listen,
+		     (struct sockaddr *)&peeraddr_in,
+		     &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(sdp_stream_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  /* there used to be an #ifdef DIRTY call to access_buffer() here,
+     but we have switched from accessing the buffer before the recv()
+     call to accessing the buffer after the recv() call.  The
+     accessing before was, IIRC, related to having dirty data when
+     doing page-flipping copy avoidance. */
+
+  bytes_received = 0;
+  receive_calls  = 0;
+
+  while ((len = recv(s_data, recv_ring->buffer_ptr, recv_size, 0)) != 0) {
+    if (len == SOCKET_ERROR )
+	{
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    bytes_received += len;
+    receive_calls++;
+
+#ifdef DIRTY
+    /* we access the buffer after the recv() call now, rather than before */
+    access_buffer(recv_ring->buffer_ptr,
+		  recv_size,
+		  sdp_stream_request->dirty_count,
+		  sdp_stream_request->clean_count);
+#endif /* DIRTY */
+
+
+    /* move to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+
+#ifdef PAUSE
+    sleep(1);
+#endif /* PAUSE */
+
+#ifdef DO_SELECT
+	FD_SET(s_data,&readfds);
+	select(s_data+1,&readfds,NULL,NULL,&timeout);
+#endif /* DO_SELECT */
+
+  }
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (shutdown(s_data,SHUT_WR) == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+  
+  cpu_stop(sdp_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sdp_stream: got %g bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_sdp_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  sdp_stream_results->bytes_received	= htond(bytes_received);
+  sdp_stream_results->elapsed_time	= elapsed_time;
+  sdp_stream_results->recv_calls	= receive_calls;
+  
+  sdp_stream_results->cpu_method = cpu_method;
+  sdp_stream_results->num_cpus   = lib_num_loc_cpus;
+  
+  if (sdp_stream_request->measure_cpu) {
+    sdp_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sdp_stream: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_received %g receive_calls %d\n",
+	    bytes_received,
+	    receive_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+
+  send_response();
+
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  }
+
+/* This is the server-side routine for the sdp maerts test. It is
+   implemented as one routine. I could break things-out somewhat, but
+   didn't feel it was necessary. */ 
+
+void
+recv_sdp_maerts()
+{
+  
+  struct sockaddr_in myaddr_in, peeraddr_in;
+  struct addrinfo *local_res;
+  char  local_name[BUFSIZ];
+  char  port_buffer[PORTBUFSIZE];
+
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  int	len;
+  unsigned int	send_calls;
+  float	elapsed_time;
+  double   bytes_sent = 0.0 ;
+  
+  struct ring_elt *send_ring;
+
+  struct	sdp_maerts_request_struct	*sdp_maerts_request;
+  struct	sdp_maerts_response_struct	*sdp_maerts_response;
+  struct	sdp_maerts_results_struct	*sdp_maerts_results;
+  
+  sdp_maerts_request	= 
+    (struct sdp_maerts_request_struct *)netperf_request.content.test_specific_data;
+  sdp_maerts_response	= 
+    (struct sdp_maerts_response_struct *)netperf_response.content.test_specific_data;
+  sdp_maerts_results	= 
+    (struct sdp_maerts_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sdp_maerts: 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_sdp_maerts: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SDP_MAERTS_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_maerts: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_maerts: requested alignment of %d\n",
+	    sdp_maerts_request->send_alignment);
+    fflush(where);
+  }
+
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_maerts: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sdp_maerts_request->send_buf_size;
+  lsr_size_req = sdp_maerts_request->recv_buf_size;
+  loc_nodelay = sdp_maerts_request->no_delay;
+  loc_rcvavoid = sdp_maerts_request->so_rcvavoid;
+  loc_sndavoid = sdp_maerts_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sdp_maerts_request->ipfamily),
+			sdp_maerts_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sdp_maerts_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+  local_res->ai_family = AF_INET_SDP;
+  local_res->ai_protocol = 0;
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+  
+  /* what sort of sizes did we end-up with? */
+  if (sdp_maerts_request->send_size == 0) {
+    if (lss_size > 0) {
+      send_size = lss_size;
+    }
+    else {
+      send_size = 4096;
+    }
+  }
+  else {
+    send_size = sdp_maerts_request->send_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the recving side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (send_width == 0) {
+    send_width = (lsr_size/send_size) + 1;
+    if (send_width == 1) send_width++;
+  }
+
+  send_ring = allocate_buffer_ring(send_width,
+				   send_size,
+				   sdp_maerts_request->send_alignment,
+				   sdp_maerts_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_sdp_maerts: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sdp_maerts_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sdp_maerts_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  if (sdp_maerts_request->measure_cpu) {
+    sdp_maerts_response->measure_cpu = 1;
+    sdp_maerts_response->cpu_rate = 
+      calibrate_local_cpu(sdp_maerts_request->cpu_rate);
+  }
+  else {
+    sdp_maerts_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sdp_maerts_response->send_buf_size = lss_size;
+  sdp_maerts_response->recv_buf_size = lsr_size;
+  sdp_maerts_response->no_delay = loc_nodelay;
+  sdp_maerts_response->so_rcvavoid = loc_rcvavoid;
+  sdp_maerts_response->so_sndavoid = loc_sndavoid;
+  sdp_maerts_response->send_size = send_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+
+  /* we will start the timer before the accept() to be somewhat
+     analagous to the starting of the timer before the connect() call
+     in the SDP_STREAM test. raj 2002-06-21 */
+
+  start_timer(sdp_maerts_request->test_length);
+
+  /* Now it's time to start receiving data on the connection. We will
+     first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(sdp_maerts_request->measure_cpu);
+  
+
+  if ((s_data=accept(s_listen,
+		     (struct sockaddr *)&peeraddr_in,
+		     &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+
+#ifdef KLUDGE_SOCKET_OPTIONS
+  
+  /* this is for those systems which *INCORRECTLY* fail to pass
+     attributes across an accept() call. Including this goes against
+     my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  bytes_sent = 0.0;
+  send_calls  = 0;
+
+  len = 0;   /* nt-lint; len is not initialized (printf far below) if
+		times_up initially true.*/
+  times_up = 0; /* must remember to initialize this little beauty */
+  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. */
+
+  access_buffer(send_ring->buffer_ptr,
+		send_size,
+		sdp_maerts_request->dirty_count,
+		sdp_maerts_request->clean_count);
+
+#endif /* DIRTY */
+
+    if((len=send(s_data,
+		 send_ring->buffer_ptr,
+		 send_size,
+		 0)) != send_size) {
+		if ((len >=0) || SOCKET_EINTR(len)) {
+	      /* the test was interrupted, must be the end of test */
+	      break;
+		}
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+
+    bytes_sent += len;
+    send_calls++;
+
+    /* more to the next buffer in the send_ring */
+    send_ring = send_ring->next;
+
+  }
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (shutdown(s_data,SHUT_WR) == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+
+  /* hang a recv() off the socket to block until the remote has
+     brought all the data up into the application. it will do a
+     shutdown to cause a FIN to be sent our way. We will assume that
+     any exit from the recv() call is good... raj 4/93 */
+    
+  recv(s_data, send_ring->buffer_ptr, send_size, 0);
+    
+  
+  cpu_stop(sdp_maerts_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sdp_maerts: got %g bytes\n",
+	    bytes_sent);
+    fprintf(where,
+	    "recv_sdp_maerts: got %d sends\n",
+	    send_calls);
+    fflush(where);
+  }
+  
+  sdp_maerts_results->bytes_sent	= htond(bytes_sent);
+  sdp_maerts_results->elapsed_time	= elapsed_time;
+  sdp_maerts_results->send_calls	= send_calls;
+  
+  if (sdp_maerts_request->measure_cpu) {
+    sdp_maerts_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sdp_maerts: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_sent %g send_calls %d\n",
+	    bytes_sent,
+	    send_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+  
+  sdp_maerts_results->cpu_method = cpu_method;
+  sdp_maerts_results->num_cpus   = lib_num_loc_cpus;
+  send_response();
+
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  }
+
+
+ /* this routine implements the sending (netperf) side of the SDP_RR */
+ /* test. */
+
+void
+send_sdp_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f %s\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   %s\n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c %s\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f %s\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET	send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct addrinfo *local_res;
+  struct addrinfo *remote_res;
+
+  struct	sdp_rr_request_struct	*sdp_rr_request;
+  struct	sdp_rr_response_struct	*sdp_rr_response;
+  struct	sdp_rr_results_struct	*sdp_rr_result;
+
+#ifdef WANT_FIRST_BURST
+#define REQUEST_CWND_INITIAL 2
+  /* "in the beginning..." the WANT_FIRST_BURST stuff was like both
+     Unix and the state of New Jersey - both were simple an unspoiled.
+     then it was realized that some stacks are quite picky about
+     initial congestion windows and a non-trivial initial burst of
+     requests would not be individual segments even with TCP_NODELAY
+     set. so, we have to start tracking a poor-man's congestion window
+     up here in window space because we want to try to make something
+     happen that frankly, we cannot guarantee with the specification
+     of SDP.  ain't that grand?-)  raj 2006-01-30 */
+  int requests_outstanding = 0;
+  int request_cwnd = REQUEST_CWND_INITIAL;  /* we ass-u-me that having
+					       three requests
+					       outstanding at the
+					       beginning of the test
+					       is ok with SDP stacks
+					       of interest. the first
+					       two will come from our
+					       first_burst loop, and
+					       the third from our
+					       regularly scheduled
+					       send */
+#endif
+
+  sdp_rr_request = 
+    (struct sdp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sdp_rr_response=
+    (struct sdp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sdp_rr_result	=
+    (struct sdp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    time_hist = HIST_new();
+  }
+#endif /* WANT_HISTOGRAM */
+
+  /* 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. */
+
+  complete_addrinfos(&remote_res,
+		     &local_res,
+		     remote_host,
+		     SOCK_STREAM,
+		     IPPROTO_TCP,
+		     0);
+
+  if ( print_headers ) {
+    print_top_test_header("SDP REQUEST/RESPONSE TEST",local_res,remote_res);
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+#ifdef WANT_FIRST_BURST
+    /* we have to remember to reset the number of transactions
+       outstanding and the "congestion window for each new
+       iteration. raj 2006-01-31 */
+    requests_outstanding = 0;
+    request_cwnd = REQUEST_CWND_INITIAL;
+#endif
+
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+    local_res->ai_family = AF_INET_SDP;
+    local_res->ai_protocol = 0;
+    send_socket = create_data_socket(local_res);
+  
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_sdp_rr: sdp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_sdp_rr: send_socket obtained...\n");
+    }
+  
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back.*/
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    if (!no_control) {
+      /* 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_SDP_RR;
+      sdp_rr_request->recv_buf_size	=	rsr_size_req;
+      sdp_rr_request->send_buf_size	=	rss_size_req;
+      sdp_rr_request->recv_alignment    =	remote_recv_align;
+      sdp_rr_request->recv_offset	=	remote_recv_offset;
+      sdp_rr_request->send_alignment    =	remote_send_align;
+      sdp_rr_request->send_offset	=	remote_send_offset;
+      sdp_rr_request->request_size	=	req_size;
+      sdp_rr_request->response_size	=	rsp_size;
+      sdp_rr_request->no_delay	        =	rem_nodelay;
+      sdp_rr_request->measure_cpu	=	remote_cpu_usage;
+      sdp_rr_request->cpu_rate	        =	remote_cpu_rate;
+      sdp_rr_request->so_rcvavoid	=	rem_rcvavoid;
+      sdp_rr_request->so_sndavoid	=	rem_sndavoid;
+      if (test_time) {
+	sdp_rr_request->test_length	=	test_time;
+      }
+      else {
+	sdp_rr_request->test_length	=	test_trans * -1;
+      }
+      sdp_rr_request->port              =      atoi(remote_data_port);
+      sdp_rr_request->ipfamily = af_to_nf(remote_res->ai_family);
+      
+      if (debug > 1) {
+	fprintf(where,"netperf: send_sdp_rr: requesting SDP rr test\n");
+      }
+      
+      send_request();
+      
+      /* The response from the remote will contain all of the relevant
+	 socket parameters for this test type. We will put them back
+	 into the variables here so they can be displayed if desired.
+	 The remote will have calibrated CPU if necessary, and will
+	 have done all the needed set-up we will have calibrated the
+	 cpu locally before sending the request, and will grab the
+	 counter value right after the connect returns. The remote
+	 will grab the counter right after the accept call. This saves
+	 the hassle of extra messages being sent for the SDP
+	 tests.  */
+  
+      recv_response();
+  
+      if (!netperf_response.content.serv_errno) {
+	if (debug)
+	  fprintf(where,"remote listen done.\n");
+	rsr_size          = sdp_rr_response->recv_buf_size;
+	rss_size          = sdp_rr_response->send_buf_size;
+	rem_nodelay       = sdp_rr_response->no_delay;
+	remote_cpu_usage  = sdp_rr_response->measure_cpu;
+	remote_cpu_rate   = sdp_rr_response->cpu_rate;
+	/* make sure that port numbers are in network order */
+	set_port_number(remote_res,(short)sdp_rr_response->data_port_number);
+      }
+      else {
+	Set_errno(netperf_response.content.serv_errno);
+	fprintf(where,
+		"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	
+	exit(1);
+      }
+    }
+
+#ifdef WANT_DEMO
+    DEMO_RR_SETUP(1000)
+#endif
+
+    /*Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		remote_res->ai_addr,
+		remote_res->ai_addrlen) == INVALID_SOCKET){
+      perror("netperf: data socket connect failed");
+      
+      exit(1);
+    }
+    
+    /* Data Socket set-up is finished. If there were problems, either the */
+    /* connect would have failed, or the previous response would have */
+    /* indicated a problem. I failed to see the value of the extra */
+    /* message after the accept on the remote. If it failed, we'll see it */
+    /* here. If it didn't, we might as well start pumping data. */
+    
+    /* Set-up the test end conditions. For a request/response test, they */
+    /* can be either time or transaction based. */
+    
+    if (test_time) {
+      /* The user wanted to end the test after a period of time. */
+      times_up = 0;
+      trans_remaining = 0;
+      start_timer(test_time);
+    }
+    else {
+      /* The tester wanted to send a number of bytes. */
+      trans_remaining = test_bytes;
+      times_up = 1;
+    }
+    
+    /* The cpu_start routine will grab the current time and possibly */
+    /* value of the idle counter for later use in measuring cpu */
+    /* utilization and/or service demand and thruput. */
+    
+    cpu_start(local_cpu_usage);
+
+#ifdef WANT_INTERVALS
+    INTERVALS_INIT();
+#endif /* WANT_INTERVALS */
+    
+    /* 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. */
+
+#ifdef WANT_DEMO
+      if (demo_mode) {
+	HIST_timestamp(demo_one_ptr);
+      }
+#endif
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+
+#ifdef WANT_FIRST_BURST
+      /* we can inject no more than request_cwnd, which will grow with
+	 time, and no more than first_burst_size.  we don't use <= to
+	 account for the "regularly scheduled" send call.  of course
+	 that makes it more a "max_outstanding_ than a
+	 "first_burst_size" but for now we won't fix the names. also,
+	 I suspect the extra check against < first_burst_size is
+	 redundant since later I expect to make sure that request_cwnd
+	 can never get larger than first_burst_size, but just at the
+	 moment I'm feeling like a belt and suspenders kind of
+	 programmer. raj 2006-01-30 */
+      while ((first_burst_size > 0) &&
+	     (requests_outstanding < request_cwnd) &&
+	     (requests_outstanding < first_burst_size)) {
+	if (debug) {
+	  fprintf(where,
+		  "injecting, req_outstndng %d req_cwnd %d burst %d\n",
+		  requests_outstanding,
+		  request_cwnd,
+		  first_burst_size);
+	}
+	if ((len = send(send_socket,
+			send_ring->buffer_ptr,
+			req_size,
+			0)) != req_size) {
+	  /* we should never hit the end of the test in the first burst */
+	  perror("send_sdp_rr: initial burst data send error");
+	  exit(-1);
+	}
+	requests_outstanding += 1;
+      }
+
+#endif /* WANT_FIRST_BURST */
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	/* timestamp just before our call to send, and then again just
+	   after the receive raj 8/94 */
+	/* but only if we are actually going to display one. raj
+	   2007-02-07 */
+
+	HIST_timestamp(&time_one);
+      }
+#endif /* WANT_HISTOGRAM */
+      
+      if ((len = send(send_socket,
+		      send_ring->buffer_ptr,
+		      req_size,
+		      0)) != req_size) {
+	if (SOCKET_EINTR(len) || (errno == 0)) {
+	  /* we hit the end of a */
+	  /* timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_sdp_rr: data send error");
+	exit(1);
+      }
+      send_ring = send_ring->next;
+
+#ifdef WANT_FIRST_BURST
+      requests_outstanding += 1;
+#endif
+
+      /* receive the response */
+      rsp_bytes_left = rsp_size;
+      temp_message_ptr  = recv_ring->buffer_ptr;
+      while(rsp_bytes_left > 0) {
+	if((rsp_bytes_recvd=recv(send_socket,
+				 temp_message_ptr,
+				 rsp_bytes_left,
+				 0)) == SOCKET_ERROR) {
+		if ( SOCKET_EINTR(rsp_bytes_recvd) ) {
+		    /* We hit the end of a timed test. */
+			timed_out = 1;
+			break;
+		}
+	  perror("send_sdp_rr: data recv error");
+	  exit(1);
+	}
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr  += rsp_bytes_recvd;
+      }	
+      recv_ring = recv_ring->next;
+      
+#ifdef WANT_FIRST_BURST
+      /* so, since we've gotten a response back, update the
+	 bookkeeping accordingly.  there is one less request
+	 outstanding and we can put one more out there than before. */
+      requests_outstanding -= 1;
+      if (request_cwnd < first_burst_size) {
+	request_cwnd += 1;
+	if (debug) {
+	  fprintf(where,
+		  "incr req_cwnd to %d first_burst %d reqs_outstndng %d\n",
+		  request_cwnd,
+		  first_burst_size,
+		  requests_outstanding);
+	}
+      }
+#endif
+      if (timed_out) {
+	/* we may have been in a nested while loop - we need */
+	/* another call to break. */
+	break;
+      }
+      
+#ifdef WANT_HISTOGRAM
+      if (verbosity > 1) {
+	HIST_timestamp(&time_two);
+	HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      }
+#endif /* WANT_HISTOGRAM */
+
+#ifdef WANT_DEMO
+      DEMO_RR_INTERVAL(1);
+#endif
+
+#ifdef WANT_INTERVALS      
+      INTERVALS_WAIT();
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  fprintf(where,
+		  "Transaction %d completed\n",
+		  nummessages);
+	  fflush(where);
+	}
+      }
+    }
+
+    /* At this point we used to call shutdown on the data socket to be
+       sure all the data was delivered, but this was not germane in a
+       request/response test, and it was causing the tests to "hang"
+       when they were being controlled by time. So, I have replaced
+       this shutdown call with a call to close that can be found later
+       in the procedure. */
+    
+    /* this call will always give us the elapsed time for the test,
+       and will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured? how long */
+						/* did we really run? */
+    
+    if (!no_control) {
+      /* Get the statistics from the remote end. The remote will have
+	 calculated CPU utilization. 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);
+	fprintf(where,"netperf: remote error %d",
+		netperf_response.content.serv_errno);
+	perror("");
+	fflush(where);
+	exit(1);
+      }
+    }
+    
+    /* We now calculate what our throughput was for the test. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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	= (float) -1.0;
+	local_service_demand	= (float) -1.0;
+      }
+      
+      if (remote_cpu_usage) {
+	remote_cpu_utilization = sdp_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,
+						    sdp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = (float) -1.0;
+	remote_service_demand  = (float) -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= (float) -1.0;
+      local_service_demand	= (float) -1.0;
+      remote_cpu_utilization = (float) -1.0;
+      remote_service_demand  = (float) -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information.
+       if debugging is on, calculate_confidence will print-out the
+       parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    close(send_socket);
+
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(sdp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method,
+		((print_headers) || 
+		 (result_brand == NULL)) ? "" : result_brand);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      thruput,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand,	/* remote service demand */
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      thruput,
+	      ((print_headers) || 
+	       (result_brand == NULL)) ? "" : result_brand);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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 */
+    /* SDP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+ /* this routine implements the receive (netserver) side of a SDP_RR */
+ /* test */
+void
+recv_sdp_rr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct addrinfo *local_res;
+  char local_name[BUFSIZ];
+  char port_buffer[PORTBUFSIZE];
+
+  struct	sockaddr_in        myaddr_in,
+  peeraddr_in;
+  SOCKET	s_listen,s_data;
+  netperf_socklen_t 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  int   sock_closed = 0;
+  float	elapsed_time;
+  
+  struct	sdp_rr_request_struct	*sdp_rr_request;
+  struct	sdp_rr_response_struct	*sdp_rr_response;
+  struct	sdp_rr_results_struct	*sdp_rr_results;
+  
+  sdp_rr_request = 
+    (struct sdp_rr_request_struct *)netperf_request.content.test_specific_data;
+  sdp_rr_response =
+    (struct sdp_rr_response_struct *)netperf_response.content.test_specific_data;
+  sdp_rr_results =
+    (struct sdp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_sdp_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_sdp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = SDP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_sdp_rr: requested recv alignment of %d offset %d\n",
+	    sdp_rr_request->recv_alignment,
+	    sdp_rr_request->recv_offset);
+    fprintf(where,"recv_sdp_rr: requested send alignment of %d offset %d\n",
+	    sdp_rr_request->send_alignment,
+	    sdp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   sdp_rr_request->response_size,
+				   sdp_rr_request->send_alignment,
+				   sdp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   sdp_rr_request->request_size,
+				   sdp_rr_request->recv_alignment,
+				   sdp_rr_request->recv_offset);
+
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_sdp_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_data_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = sdp_rr_request->send_buf_size;
+  lsr_size_req = sdp_rr_request->recv_buf_size;
+  loc_nodelay = sdp_rr_request->no_delay;
+  loc_rcvavoid = sdp_rr_request->so_rcvavoid;
+  loc_sndavoid = sdp_rr_request->so_sndavoid;
+
+  set_hostname_and_port(local_name,
+			port_buffer,
+			nf_to_af(sdp_rr_request->ipfamily),
+			sdp_rr_request->port);
+
+  local_res = complete_addrinfo(local_name,
+				local_name,
+				port_buffer,
+				nf_to_af(sdp_rr_request->ipfamily),
+				SOCK_STREAM,
+				IPPROTO_TCP,
+				0);
+
+  /* fake things out by changing local_res->ai_family to AF_INET_SDP */
+  local_res->ai_family = AF_INET_SDP;
+  local_res->ai_protocol = 0;
+  s_listen = create_data_socket(local_res);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+#ifdef WIN32
+  /* The test timer can fire during operations on the listening socket,
+     so to make the start_timer below work we have to move
+     it to close s_listen while we are blocked on accept. */
+  win_kludge_socket2 = s_listen;
+#endif
+
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in, 
+		  &addrlen) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  sdp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  sdp_rr_response->cpu_rate = (float)0.0; 	/* assume no cpu */
+  sdp_rr_response->measure_cpu = 0;
+
+  if (sdp_rr_request->measure_cpu) {
+    sdp_rr_response->measure_cpu = 1;
+    sdp_rr_response->cpu_rate = calibrate_local_cpu(sdp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  sdp_rr_response->send_buf_size = lss_size;
+  sdp_rr_response->recv_buf_size = lsr_size;
+  sdp_rr_response->no_delay = loc_nodelay;
+  sdp_rr_response->so_rcvavoid = loc_rcvavoid;
+  sdp_rr_response->so_sndavoid = loc_sndavoid;
+  sdp_rr_response->test_length = sdp_rr_request->test_length;
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  if ((s_data = accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    
+    exit(1);
+  }
+  
+#ifdef KLUDGE_SOCKET_OPTIONS
+  /* this is for those systems which *INCORRECTLY* fail to pass */
+  /* attributes across an accept() call. Including this goes against */
+  /* my better judgement :( raj 11/95 */
+
+  kludge_socket_options(s_data);
+
+#endif /* KLUDGE_SOCKET_OPTIONS */
+
+#ifdef WIN32
+  /* this is used so the timer thread can close the socket out from */
+  /* under us, which to date is the easiest/cleanest/least */
+  /* Windows-specific way I can find to force the winsock calls to */
+  /* return WSAEINTR with the test is over. anything that will run on */
+  /* 95 and NT and is closer to what netperf expects from Unix signals */
+  /* and such would be appreciated raj 1/96 */
+  win_kludge_socket = s_data;
+#endif /* WIN32 */
+
+  if (debug) {
+    fprintf(where,"recv_sdp_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(sdp_rr_request->measure_cpu);
+  
+  /* The loop will exit when we hit the end of the test time, or when */
+  /* we have exchanged the requested number of transactions. */
+  
+  if (sdp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(sdp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = sdp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining	= sdp_rr_request->request_size;
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	if (SOCKET_EINTR(request_bytes_recvd))
+	{
+	  timed_out = 1;
+	  break;
+	}
+
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      else if( request_bytes_recvd == 0 ) {
+	if (debug) {
+	  fprintf(where,"zero is my hero\n");
+	  fflush(where);
+	}
+	sock_closed = 1;
+	break;
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+
+    recv_ring = recv_ring->next;
+
+    if ((timed_out) || (sock_closed)) {
+      /* we hit the end of the test based on time - or the socket
+	 closed on us along the way.  bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo5\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=send(s_data,
+			send_ring->buffer_ptr,
+			sdp_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (SOCKET_EINTR(bytes_sent)) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 992;
+      send_response();
+      exit(1);
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(sdp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer();
+
+  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_sdp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  sdp_rr_results->bytes_received = (trans_received * 
+				    (sdp_rr_request->request_size + 
+				     sdp_rr_request->response_size));
+  sdp_rr_results->trans_received = trans_received;
+  sdp_rr_results->elapsed_time   = elapsed_time;
+  sdp_rr_results->cpu_method     = cpu_method;
+  sdp_rr_results->num_cpus       = lib_num_loc_cpus;
+  if (sdp_rr_request->measure_cpu) {
+    sdp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_sdp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are now done with the sockets */
+  close(s_data);
+  close(s_listen);
+
+  send_response();
+  
+}
+
+
+
+void
+print_sdp_usage()
+{
+
+  printf("%s",sdp_usage);
+  exit(1);
+
+}
+void
+scan_sdp_args(argc, argv)
+     int	argc;
+     char	*argv[];
+
+{
+
+#define SOCKETS_ARGS "b:DhH:I:L:m:M:P:r:s:S:V46"
+
+  extern char	*optarg;	  /* pointer to option string	*/
+  
+  int		c;
+  
+  char	
+    arg1[BUFSIZ],  /* argument holders		*/
+    arg2[BUFSIZ];
+
+  if (no_control) {
+    fprintf(where,
+	    "The SDP tests do not know how to deal with no control tests\n");
+    exit(-1);
+  }
+
+  strncpy(local_data_port,"0",sizeof(local_data_port));
+  strncpy(remote_data_port,"0",sizeof(remote_data_port));
+  
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form "first," (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, SOCKETS_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case '4':
+      remote_data_family = AF_INET;
+      local_data_family = AF_INET;
+      break;
+    case '6':
+#if defined(AF_INET6)
+      remote_data_family = AF_INET6;
+      local_data_family = AF_INET6;
+#else
+      fprintf(stderr,
+	      "This netperf was not compiled on an IPv6 capable host!\n");
+      fflush(stderr);
+      exit(-1);
+#endif
+      break;
+    case 'h':
+      print_sdp_usage();
+      exit(1);
+    case 'b':
+#ifdef WANT_FIRST_BURST
+      first_burst_size = atoi(optarg);
+#else /* WANT_FIRST_BURST */
+      printf("Initial request burst functionality not compiled-in!\n");
+#endif /* WANT_FIRST_BURST */
+      break;
+    case 'D':
+      /* set the nodelay flag */
+      loc_nodelay = 1;
+      rem_nodelay = 1;
+      break;
+    case 'H':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	remote_data_address = malloc(strlen(arg1)+1);
+	strncpy(remote_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	remote_data_family = parse_address_family(arg2);
+      break;
+    case 'L':
+      break_args_explicit(optarg,arg1,arg2);
+      if (arg1[0]) {
+	/* make sure we leave room for the NULL termination boys and
+	   girls. raj 2005-02-82 */ 
+	local_data_address = malloc(strlen(arg1)+1);
+	strncpy(local_data_address,arg1,strlen(arg1));
+      }
+      if (arg2[0])
+	local_data_family = parse_address_family(arg2);
+      break;
+    case 'P':
+      /* set the local and remote data port numbers for the tests to
+	 allow them to run through those blankety blank end-to-end
+	 breaking firewalls. raj 2004-06-15 */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	strncpy(local_data_port,arg1,sizeof(local_data_port));
+      if (arg2[0])	
+	strncpy(remote_data_port,arg2,sizeof(remote_data_port));
+      break;
+    case 's':
+      /* set local socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	lss_size_req = convert(arg1);
+      if (arg2[0])
+	lsr_size_req = convert(arg2);
+      break;
+    case 'S':
+      /* set remote socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	rss_size_req = convert(arg1);
+      if (arg2[0])
+	rsr_size_req = convert(arg2);
+      break;
+    case 'r':
+      /* set the request/response sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	req_size = convert(arg1);
+      if (arg2[0])	
+	rsp_size = convert(arg2);
+      break;
+    case 'm':
+      /* set size of the buffer for each sent message */
+      send_size = convert(optarg);
+      break;
+    case 'M':
+      /* set the size of the buffer for each received message */
+      recv_size = convert(optarg);
+      break;
+    case 't':
+      /* set the test name */
+      strcpy(test_name,optarg);
+      break;
+    case 'W':
+	/* set the "width" of the user space data */
+	/* buffer. This will be the number of */
+	/* send_size buffers malloc'd in the */
+	/* *_STREAM test. It may be enhanced to set */
+	/* both send and receive "widths" but for now */
+	/* it is just the sending *_STREAM. */
+	send_width = convert(optarg);
+	break;
+    case 'V':
+      /* we want to do copy avoidance and will set */
+      /* it for everything, everywhere, if we really */
+      /* can. of course, we don't know anything */
+      /* about the remote... */
+#ifdef SO_SND_COPYAVOID
+      loc_sndavoid = 1;
+#else
+      loc_sndavoid = 0;
+      printf("Local send copy avoidance not available.\n");
+#endif
+#ifdef SO_RCV_COPYAVOID
+      loc_rcvavoid = 1;
+#else
+      loc_rcvavoid = 0;
+      printf("Local recv copy avoidance not available.\n");
+#endif
+      rem_sndavoid = 1;
+      rem_rcvavoid = 1;
+      break;
+    case 'N':
+      /* this opton allows the user to set the number of 
+       * messages to send.  This in effect modifies the test
+       * time.  If we know the message size, then the we can
+       * express the test time as message_size * number_messages
+       */
+      msg_count = convert (optarg);
+      if (msg_count > 0)
+	  test_time = 0;
+      break;
+    case 'B':
+      non_block = 1;
+      break;
+    case 'T':
+      num_associations = atoi(optarg);
+      if (num_associations <= 1) {
+	  printf("Number of SDP associations must be >= 1\n");
+	  exit(1);
+      }
+      break;
+    };
+  }
+}
+
+#endif  /* WANT_SDP */
diff --git a/nettest_sdp.h b/nettest_sdp.h
new file mode 100644
index 0000000..31d76bc
--- /dev/null
+++ b/nettest_sdp.h
@@ -0,0 +1,170 @@
+/*
+        Copyright (C) 2007 Hewlett-Packard Company
+*/
+
+ /* This file contains the test-specific definitions for netperf's SDP */
+ /* sockets tests */
+
+/* one of these days, this should not be required */
+#ifndef AF_INET_SDP
+#define AF_INET_SDP 27
+#define PF_INET_SDP AF_INET_SDP
+#endif 
+
+struct	sdp_stream_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	receive_size;   /* how many bytes do we want to receive at one */
+			/* time? */ 
+  int	recv_alignment; /* what is the alignment of the receive */
+			/* buffer? */ 
+  int	recv_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   port;		/* the to port to which recv side should bind
+			   to allow netperf to run through firewalls */
+  int   ipfamily;	/* address family of ipaddress */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct	sdp_stream_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	receive_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct sdp_stream_results_struct {
+  double         bytes_received;
+  unsigned int	 recv_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	sdp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   port;		/* the to port to which recv side should bind
+			   to allow netperf to run through firewalls */
+  int   ipfamily;	/* address family of ipaddress */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct	sdp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   non_blocking;   /* run the test in non-blocking mode */
+};
+
+struct sdp_rr_results_struct {
+  unsigned int  bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs had the remote? */
+};
+
+struct	sdp_maerts_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	send_size;      /* how many bytes do we want netserver to send
+			   at one time? */
+  int	send_alignment; /* what is the alignment of the send */
+			/* buffer? */ 
+  int	send_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the send buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   port;           /* the port to which the recv side should bind
+			   to allow netperf to run through those evil
+			   firewall things */
+  int   ipfamily;
+};
+
+struct	sdp_maerts_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct sdp_maerts_results_struct {
+  double         bytes_sent;
+  unsigned int	 send_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs had the remote? */
+};
+
+extern void send_sdp_stream();
+extern void send_sdp_rr();
+
+extern void recv_sdp_stream();
+extern void recv_sdp_rr();
+
+extern void loc_cpu_rate();
+extern void rem_cpu_rate();
diff --git a/nettest_unix.c b/nettest_unix.c
new file mode 100644
index 0000000..e4716a4
--- /dev/null
+++ b/nettest_unix.c
@@ -0,0 +1,3431 @@
+#ifdef lint
+#define WANT_UNIX
+#define DIRTY
+#define WANT_INTERVALS
+#endif /* lint */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WANT_UNIX
+char	nettest_unix_id[]="\
+@(#)nettest_unix.c (c) Copyright 1994-2007 Hewlett-Packard Co. Version 2.4.3";
+     
+/****************************************************************/
+/*								*/
+/*	nettest_bsd.c						*/
+/*								*/
+/*      the BSD sockets parsing routine...                      */
+/*                                                              */
+/*      scan_unix_args()                                        */
+/*                                                              */
+/*	the actual test routines...				*/
+/*								*/
+/*	send_stream_stream()  perform a stream stream test	*/
+/*	recv_stream_stream()					*/
+/*	send_stream_rr()      perform a stream request/response	*/
+/*	recv_stream_rr()					*/
+/*	send_dg_stream()      perform a dg stream test	        */
+/*	recv_dg_stream()					*/
+/*	send_dg_rr()	      perform a dg request/response	*/
+/*	recv_dg_rr()						*/
+/*	loc_cpu_rate()	      determine the local cpu maxrate   */
+/*	rem_cpu_rate()	      find the remote cpu maxrate	*/
+/*								*/
+/****************************************************************/
+     
+ /* at some point, I might want to go-in and see if I really need all */
+ /* these includes, but for the moment, we'll let them all just sit */
+ /* there. raj 8/94 */
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef WIN32
+#include <sys/ipc.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/un.h>
+#include <unistd.h>
+#else /* WIN32 */
+#include <process.h>
+#include <winsock2.h>
+#include <windows.h>
+#endif /* WIN32 */
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+
+#ifdef NOSTDLIBH
+#include <malloc.h>
+#else /* NOSTDLIBH */
+#include <stdlib.h>
+#endif /* NOSTDLIBH */
+
+#include <sys/stat.h>
+
+   
+#include "netlib.h"
+#include "netsh.h"
+#include "nettest_unix.h"
+
+
+
+ /* these variables are specific to the UNIX sockets tests. declare */
+ /* them static to make them global only to this file. */
+
+#define UNIX_PRFX "netperf."
+#define UNIX_LENGTH_MAX 0xFFFF - 28
+
+static char
+  path_prefix[32]; 
+
+static int	
+  rss_size,		/* remote socket send buffer size	*/
+  rsr_size,		/* remote socket recv buffer size	*/
+  lss_size_req,		/* requested local socket send buffer size */
+  lsr_size_req,		/* requested local socket recv buffer size */
+  lss_size,		/* local  socket send buffer size 	*/
+  lsr_size,		/* local  socket recv buffer size 	*/
+  req_size = 1,		/* request size                   	*/
+  rsp_size = 1,		/* response size			*/
+  send_size,		/* how big are individual sends		*/
+  recv_size;		/* how big are individual receives	*/
+
+ /* different options for the sockets				*/
+
+
+char unix_usage[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+STREAM/DG UNIX Sockets Test Options:\n\
+    -h                Display this text\n\
+    -m bytes          Set the send size (STREAM_STREAM, DG_STREAM)\n\
+    -M bytes          Set the recv size (STREAM_STREAM, DG_STREAM)\n\
+    -p dir            Set the directory where pipes are created\n\
+    -r req,res        Set request,response size (STREAM_RR, DG_RR)\n\
+    -s send[,recv]    Set local socket send/recv buffer sizes\n\
+    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
+\n\
+For those options taking two parms, at least one must be specified;\n\
+specifying one value without a comma will set both parms to that\n\
+value, specifying a value with a leading comma will set just the second\n\
+parm, a value with a trailing comma will set just the first. To set\n\
+each parm to unique values, specify both and separate them with a\n\
+comma.\n"; 
+
+ /* this routing initializes all the test specific variables */
+
+static void
+init_test_vars()
+{
+  rss_size  = 0;
+  rsr_size  = 0;
+  lss_size_req = 0;
+  lsr_size_req = 0;
+  lss_size  = 0;
+  lsr_size  = 0;
+  req_size  = 1;
+  rsp_size  = 1;
+  send_size = 0;
+  recv_size = 0;
+
+  strcpy(path_prefix,"/tmp");
+
+}     
+
+ /* This routine will create a data (listen) socket with the apropriate */
+ /* options set and return it to the caller. this replaces all the */
+ /* duplicate code in each of the test routines and should help make */
+ /* things a little easier to understand. since this routine can be */
+ /* called by either the netperf or netserver programs, all output */
+ /* should be directed towards "where." family is generally AF_UNIX, */
+ /* and type will be either SOCK_STREAM or SOCK_DGRAM */
+SOCKET
+create_unix_socket(int family, int type)
+{
+
+  SOCKET temp_socket;
+  int sock_opt_len;
+
+  /*set up the data socket                        */
+  temp_socket = socket(family, 
+		       type,
+		       0);
+  
+  if (temp_socket == INVALID_SOCKET){
+    fprintf(where,
+	    "netperf: create_unix_socket: socket: %d\n",
+	    errno);
+    fflush(where);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"create_unix_socket: socket %d obtained...\n",temp_socket);
+    fflush(where);
+  }
+  
+  /* Modify the local socket size. The reason we alter the send buffer */
+  /* size here rather than when the connection is made is to take care */
+  /* of decreases in buffer size. Decreasing the window size after */
+  /* connection establishment is a STREAM no-no. Also, by setting the */
+  /* buffer (window) size before the connection is established, we can */
+  /* control the STREAM MSS (segment size). The MSS is never more that 1/2 */
+  /* the minimum receive buffer size at each half of the connection. */
+  /* This is why we are altering the receive buffer size on the sending */
+  /* size of a unidirectional transfer. If the user has not requested */
+  /* that the socket buffers be altered, we will try to find-out what */
+  /* their values are. If we cannot touch the socket buffer in any way, */
+  /* we will set the values to -1 to indicate that.  */
+  
+  set_sock_buffer(temp_socket, SEND_BUFFER, lss_size_req, &lss_size);
+  set_sock_buffer(temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size);
+
+  return(temp_socket);
+
+}
+
+
+/* This routine implements the STREAM unidirectional data transfer test */
+/* (a.k.a. stream) for the sockets interface. It receives its */
+/* parameters via global variables from the shell and writes its */
+/* output to the standard output. */
+
+
+void 
+send_stream_stream(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%5d  %5d  %6d    %-6.2f   %7.2f   \n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization    Service Demand\n\
+Socket Socket  Message  Elapsed              Send   Recv    Send    Recv\n\
+Size   Size    Size     Time     Throughput  local  remote  local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %%      %%       us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1 =
+    "%5d  %5d  %6d    %-6.2f     %7.2f   %-6.2f %-6.2f  %-6.3f  %-6.3f\n";
+  
+  char *ksink_fmt = "\n\
+Alignment      Offset         %-8.8s %-8.8s    Sends   %-8.8s Recvs\n\
+Local  Remote  Local  Remote  Xfered   Per                 Per\n\
+Send   Recv    Send   Recv             Send (avg)          Recv (avg)\n\
+%5d   %5d  %5d   %5d %6.4g  %6.2f     %6d %6.2f   %6d\n";
+  
+  
+  float			elapsed_time;
+  
+#ifdef WANT_INTERVALS
+  int interval_count;
+#endif
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* send-size greater than our send window. this will insure that we */
+  /* are never trying to re-use a buffer that may still be in the hands */
+  /* of the transport. This buffer will be malloc'd after we have found */
+  /* the size of the local senc socket buffer. We will want to deal */
+  /* with alignment and offset concerns as well. */
+  
+#ifdef DIRTY
+  int	*message_int_ptr;
+#endif
+#include <sys/stat.h>
+
+  struct ring_elt *send_ring;
+  
+  int	len = 0;
+  int	nummessages;
+  SOCKET send_socket;
+  int	bytes_remaining;
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) */
+  double	bytes_sent;
+  
+#ifdef DIRTY
+  int	i;
+#endif /* DIRTY */
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	sockaddr_un	server;
+  
+  struct	stream_stream_request_struct	*stream_stream_request;
+  struct	stream_stream_response_struct	*stream_stream_response;
+  struct	stream_stream_results_struct	*stream_stream_result;
+  
+  stream_stream_request  = 
+    (struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
+  stream_stream_response =
+    (struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
+  stream_stream_result   = 
+    (struct stream_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  server.sun_family = AF_UNIX;
+  
+  
+  if ( print_headers ) {
+    fprintf(where,"STREAM STREAM TEST\n");
+    if (local_cpu_usage || remote_cpu_usage)
+      fprintf(where,cpu_title,format_units());
+    else
+      fprintf(where,tput_title,format_units());
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_sent	=	0.0;
+  times_up 	= 	0;
+  
+  /*set up the data socket                        */
+  send_socket = create_unix_socket(AF_UNIX, 
+				   SOCK_STREAM);
+  
+  if (send_socket == INVALID_SOCKET){
+    perror("netperf: send_stream_stream: stream stream data socket");
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"send_stream_stream: send_socket obtained...\n");
+  }
+  
+  /* at this point, we have either retrieved the socket buffer sizes, */
+  /* or have tried to set them, so now, we may want to set the send */
+  /* size based on that (because the user either did not use a -m */
+  /* option, or used one with an argument of 0). If the socket buffer */
+  /* size is not available, we will set the send size to 4KB - no */
+  /* particular reason, just arbitrary... */
+  if (send_size == 0) {
+    if (lss_size > 0) {
+      send_size = lss_size;
+    }
+    else {
+      send_size = 4096;
+    }
+  }
+  
+  /* set-up the data buffer ring with the requested alignment and offset. */
+  /* note also that we have allocated a quantity */
+  /* of memory that is at least one send-size greater than our socket */
+  /* buffer size. We want to be sure that there are at least two */
+  /* buffers allocated - this can be a bit of a problem when the */
+  /* send_size is bigger than the socket size, so we must check... the */
+  /* user may have wanted to explicitly set the "width" of our send */
+  /* buffers, we should respect that wish... */
+  if (send_width == 0) {
+    send_width = (lss_size/send_size) + 1;
+    if (send_width == 1) send_width++;
+  }
+  
+  send_ring = allocate_buffer_ring(send_width,
+				   send_size,
+				   local_send_align,
+				   local_send_offset);
+
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 1, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type		=	DO_STREAM_STREAM;
+  stream_stream_request->send_buf_size	=	rss_size;
+  stream_stream_request->recv_buf_size	=	rsr_size;
+  stream_stream_request->receive_size	=	recv_size;
+  stream_stream_request->recv_alignment	=	remote_recv_align;
+  stream_stream_request->recv_offset	=	remote_recv_offset;
+  stream_stream_request->measure_cpu	=	remote_cpu_usage;
+  stream_stream_request->cpu_rate	=	remote_cpu_rate;
+  if (test_time) {
+    stream_stream_request->test_length	=	test_time;
+  }
+  else {
+    stream_stream_request->test_length	=	test_bytes;
+  }
+#ifdef DIRTY
+  stream_stream_request->dirty_count    =       rem_dirty_count;
+  stream_stream_request->clean_count    =       rem_clean_count;
+#endif /* DIRTY */
+  
+  
+  if (debug > 1) {
+    fprintf(where,
+	    "netperf: send_stream_stream: requesting STREAM stream test\n");
+  }
+  
+  send_request();
+  
+  /* The response from the remote will contain all of the relevant 	*/
+  /* socket parameters for this test type. We will put them back into 	*/
+  /* the variables here so they can be displayed if desired.  The	*/
+  /* remote will have calibrated CPU if necessary, and will have done	*/
+  /* all the needed set-up we will have calibrated the cpu locally	*/
+  /* before sending the request, and will grab the counter value right	*/
+  /* after the connect returns. The remote will grab the counter right	*/
+  /* after the accept call. This saves the hassle of extra messages	*/
+  /* being sent for the STREAM tests.					*/
+  
+  recv_response();
+  
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote listen done.\n");
+    rsr_size	        =	stream_stream_response->recv_buf_size;
+    rss_size	        =	stream_stream_response->send_buf_size;
+    remote_cpu_usage    =	stream_stream_response->measure_cpu;
+    remote_cpu_rate     = 	stream_stream_response->cpu_rate;
+    strcpy(server.sun_path,stream_stream_response->unix_path);
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: send_stream_stream: remote error");
+    exit(1);
+  }
+  
+  /*Connect up to the remote port on the data socket  */
+  if (connect(send_socket, 
+	      (struct sockaddr *)&server,
+	      sizeof(server)) == INVALID_SOCKET){
+    perror("netperf: send_stream_stream: data socket connect failed");
+    printf(" path: %s\n",server.sun_path);
+    exit(1);
+  }
+  
+  /* Data Socket set-up is finished. If there were problems, either the */
+  /* connect would have failed, or the previous response would have */
+  /* indicated a problem. I failed to see the value of the extra */
+  /* message after the accept on the remote. If it failed, we'll see it */
+  /* here. If it didn't, we might as well start pumping data. */
+  
+  /* Set-up the test end conditions. For a stream test, they can be */
+  /* either time or byte-count based. */
+  
+  if (test_time) {
+    /* The user wanted to end the test after a period of time. */
+    times_up = 0;
+    bytes_remaining = 0;
+    start_timer(test_time);
+  }
+  else {
+    /* The tester wanted to send a number of bytes. */
+    bytes_remaining = test_bytes;
+    times_up = 1;
+  }
+  
+  /* The cpu_start routine will grab the current time and possibly */
+  /* value of the idle counter for later use in measuring cpu */
+  /* utilization and/or service demand and thruput. */
+  
+  cpu_start(local_cpu_usage);
+  
+  /* We use an "OR" to control test execution. When the test is */
+  /* controlled by time, the byte count check will always return false. */
+  /* When the test is controlled by byte count, the time test will */
+  /* always return false. When the test is finished, the whole */
+  /* expression will go false and we will stop sending data. */
+  
+#ifdef DIRTY
+  /* initialize the random number generator for putting dirty stuff */
+  /* into the send buffer. raj */
+  srand((int) getpid());
+#endif
+  
+  while ((!times_up) || (bytes_remaining > 0)) {
+    
+#ifdef DIRTY
+    /* we want to dirty some number of consecutive integers in the buffer */
+    /* we are about to send. we may also want to bring some number of */
+    /* them cleanly into the cache. The clean ones will follow any dirty */
+    /* ones into the cache. at some point, we might want to replace */
+    /* the rand() call with something from a table to reduce our call */
+    /* overhead during the test, but it is not a high priority item. */
+    message_int_ptr = (int *)(send_ring->buffer_ptr);
+    for (i = 0; i < loc_dirty_count; i++) {
+      *message_int_ptr = rand();
+      message_int_ptr++;
+    }
+    for (i = 0; i < loc_clean_count; i++) {
+      loc_dirty_count = *message_int_ptr;
+      message_int_ptr++;
+    }
+#endif /* DIRTY */
+    
+    if((len=send(send_socket,
+		 send_ring->buffer_ptr,
+		 send_size,
+		 0)) != send_size) {
+      if ((len >=0) || (errno == EINTR)) {
+	/* the test was interrupted, must be the end of test */
+	break;
+      }
+      perror("netperf: data send error");
+      printf("len was %d\n",len);
+      exit(1);
+    }
+#ifdef WANT_INTERVALS
+    for (interval_count = 0;
+	 interval_count < interval_wate;
+	 interval_count++);
+#endif
+    
+    /* now we want to move our pointer to the next position in the */
+    /* data buffer...we may also want to wrap back to the "beginning" */
+    /* of the bufferspace, so we will mod the number of messages sent */
+    /* by the send width, and use that to calculate the offset to add */
+    /* to the base pointer. */
+    nummessages++;          
+    send_ring = send_ring->next;
+    if (bytes_remaining) {
+      bytes_remaining -= send_size;
+    }
+  }
+  
+  /* The test is over. Flush the buffers to the remote end. We do a */
+  /* graceful release to insure that all data has been taken by the */
+  /* remote. */ 
+  
+  if (close(send_socket) == -1) {
+    perror("netperf: send_stream_stream: cannot close socket");
+    exit(1);
+  }
+  
+  /* this call will always give us the elapsed time for the test, and */
+  /* will also store-away the necessaries for cpu utilization */
+  
+  cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being */
+						/* measured and how */
+						/* long did we really */
+						/* run? */  
+  
+  /* Get the statistics from the remote end. The remote will have */
+  /* calculated service demand and all those interesting things. If it */
+  /* wasn't supposed to care, it will return obvious values. */
+  
+  recv_response();
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote results obtained\n");
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /* We now calculate what our thruput was for the test. In the future, */
+  /* we may want to include a calculation of the thruput measured by */
+  /* the remote, but it should be the case that for a STREAM stream test, */
+  /* that the two numbers should be *very* close... We calculate */
+  /* bytes_sent regardless of the way the test length was controlled. */
+  /* If it was time, we needed to, and if it was by bytes, the user may */
+  /* have specified a number of bytes that wasn't a multiple of the */
+  /* send_size, so we really didn't send what he asked for ;-) */
+  
+  bytes_sent	= ((double) send_size * (double) nummessages) + len;
+  thruput	= calc_thruput(bytes_sent);
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    /* We must now do a little math for service demand and cpu */
+    /* utilization for the system(s) */
+    /* Of course, some of the information might be bogus because */
+    /* there was no idle counter in the kernel(s). We need to make */
+    /* a note of this for the user's benefit...*/
+    if (local_cpu_usage) {
+      if (local_cpu_rate == 0.0) {
+	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
+	fprintf(where,"Local CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      local_cpu_utilization	= calc_cpu_util(0.0);
+      local_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      0.0,
+						      0);
+    }
+    else {
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+    }
+    
+    if (remote_cpu_usage) {
+      if (remote_cpu_rate == 0.0) {
+	fprintf(where,"DANGER   DANGER  DANGER   DANGER   DANGER  DANGER   DANGER!\n");
+	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      remote_cpu_utilization	= stream_stream_result->cpu_util;
+      remote_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      remote_cpu_utilization,
+						      stream_stream_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* We are now ready to print all the information. If the user */
+    /* has specified zero-level verbosity, we will just print the */
+    /* local service demand, or the remote service demand. If the */
+    /* user has requested verbosity level 1, he will get the basic */
+    /* "streamperf" numbers. If the user has specified a verbosity */
+    /* of greater than 1, we will display a veritable plethora of */
+    /* background information from outside of this block as it it */
+    /* not cpu_measurement specific...  */
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand);
+      }
+      break;
+    case 1:
+    case 2:
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);/* how fast did it go */
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* STREAM statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt,
+	    "Bytes",
+	    "Bytes",
+	    "Bytes",
+	    local_send_align,
+	    remote_recv_align,
+	    local_send_offset,
+	    remote_recv_offset,
+	    bytes_sent,
+	    bytes_sent / (double)nummessages,
+	    nummessages,
+	    bytes_sent / (double)stream_stream_result->recv_calls,
+	    stream_stream_result->recv_calls);
+  }
+  
+}
+
+
+/* This is the server-side routine for the stream stream test. It is */
+/* implemented as one routine. I could break things-out somewhat, but */
+/* didn't feel it was necessary. */
+
+void
+recv_stream_stream()
+{
+  
+  struct sockaddr_un myaddr_un, peeraddr_un;
+  SOCKET s_listen,s_data;
+  int 	addrlen;
+  int	len;
+  int	receive_calls = 0;
+  float	elapsed_time;
+  int   bytes_received;
+  
+  struct ring_elt *recv_ring;
+
+#ifdef DIRTY
+  char	*message_ptr;
+  int   *message_int_ptr;
+  int   dirty_count;
+  int   clean_count;
+  int   i;
+#endif
+  
+  struct	stream_stream_request_struct	*stream_stream_request;
+  struct	stream_stream_response_struct	*stream_stream_response;
+  struct	stream_stream_results_struct	*stream_stream_results;
+  
+  stream_stream_request	= 
+    (struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
+  stream_stream_response	= 
+    (struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
+  stream_stream_results	= 
+    (struct stream_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_stream_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_stream_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = STREAM_STREAM_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_stream_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_stream_stream: requested alignment of %d\n",
+	    stream_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_un,
+	sizeof(myaddr_un));
+  myaddr_un.sun_family      = AF_UNIX;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_stream_stream: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+  /* create_unix_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = stream_stream_request->send_buf_size;
+  lsr_size_req = stream_stream_request->recv_buf_size;
+
+  s_listen = create_unix_socket(AF_UNIX,
+				SOCK_STREAM);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
+  if (debug) {
+    fprintf(where,"selected a path of %s\n",myaddr_un.sun_path);
+    fflush(where);
+  }
+  if (bind(s_listen,
+	   (struct sockaddr *)&myaddr_un,
+	   sizeof(myaddr_un)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    fprintf(where,"could not bind to path\n");
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  chmod(myaddr_un.sun_path, 0666);
+
+  /* what sort of sizes did we end-up with? */
+  if (stream_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = stream_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   stream_stream_request->recv_alignment,
+				   stream_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_stream_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_un);
+  if (getsockname(s_listen, 
+		  (struct sockaddr *)&myaddr_un,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_un contains the path */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  strcpy(stream_stream_response->unix_path,myaddr_un.sun_path);
+  netperf_response.content.serv_errno   = 0;
+  
+  /* But wait, there's more. If the initiator wanted cpu measurements, */
+  /* then we must call the calibrate routine, which will return the max */
+  /* rate back to the initiator. If the CPU was not to be measured, or */
+  /* something went wrong with the calibration, we will return a -1 to */
+  /* the initiator. */
+  
+  stream_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (stream_stream_request->measure_cpu) {
+    stream_stream_response->measure_cpu = 1;
+    stream_stream_response->cpu_rate = 
+      calibrate_local_cpu(stream_stream_request->cpu_rate);
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  stream_stream_response->send_buf_size = lss_size;
+  stream_stream_response->recv_buf_size = lsr_size;
+  stream_stream_response->receive_size = recv_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_un);
+  
+  if ((s_data=accept(s_listen,
+		     (struct sockaddr *)&peeraddr_un,
+		     &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    exit(1);
+  }
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(stream_stream_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+#ifdef DIRTY
+    /* we want to dirty some number of consecutive integers in the buffer */
+    /* we are about to recv. we may also want to bring some number of */
+    /* them cleanly into the cache. The clean ones will follow any dirty */
+    /* ones into the cache. */
+
+  dirty_count = stream_stream_request->dirty_count;
+  clean_count = stream_stream_request->clean_count;
+  message_int_ptr = (int *)recv_ring->buffer_ptr;
+  for (i = 0; i < dirty_count; i++) {
+    *message_int_ptr = rand();
+    message_int_ptr++;
+  }
+  for (i = 0; i < clean_count; i++) {
+    dirty_count = *message_int_ptr;
+    message_int_ptr++;
+  }
+#endif /* DIRTY */
+  bytes_received = 0;
+
+  while ((len = recv(s_data, recv_ring->buffer_ptr, recv_size, 0)) != 0) {
+    if (len == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    bytes_received += len;
+    receive_calls++;
+
+    /* more to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+
+#ifdef DIRTY
+    message_int_ptr = (int *)(recv_ring->buffer_ptr);
+    for (i = 0; i < dirty_count; i++) {
+      *message_int_ptr = rand();
+      message_int_ptr++;
+    }
+    for (i = 0; i < clean_count; i++) {
+      dirty_count = *message_int_ptr;
+      message_int_ptr++;
+    }
+#endif /* DIRTY */
+  }
+  
+  /* The loop now exits due to zero bytes received. we will have */
+  /* counted one too many messages received, so decrement the */
+  /* receive_calls counter by one. raj 7/94 */
+  receive_calls--;
+  
+  /* perform a shutdown to signal the sender that */
+  /* we have received all the data sent. raj 4/93 */
+
+  if (shutdown(s_data,1) == SOCKET_ERROR) {
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+  
+  cpu_stop(stream_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_stream_stream: got %d bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_stream_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  stream_stream_results->bytes_received	= bytes_received;
+  stream_stream_results->elapsed_time	= elapsed_time;
+  stream_stream_results->recv_calls	= receive_calls;
+  
+  if (stream_stream_request->measure_cpu) {
+    stream_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug > 1) {
+    fprintf(where,
+	    "recv_stream_stream: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  unlink(myaddr_un.sun_path);
+}
+
+
+ /* this routine implements the sending (netperf) side of the STREAM_RR */
+ /* test. */
+
+void
+send_stream_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	sockaddr_un	server;
+  
+  struct	stream_rr_request_struct	*stream_rr_request;
+  struct	stream_rr_response_struct	*stream_rr_response;
+  struct	stream_rr_results_struct	*stream_rr_result;
+  
+  stream_rr_request = 
+    (struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
+  stream_rr_response=
+    (struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
+  stream_rr_result	=
+    (struct stream_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  server.sun_family = AF_UNIX;
+  
+  
+  if ( print_headers ) {
+    fprintf(where,"STREAM REQUEST/RESPONSE TEST\n");
+    if (local_cpu_usage || remote_cpu_usage)
+      fprintf(where,cpu_title,format_units());
+    else
+      fprintf(where,tput_title,format_units());
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_xferd	=	0.0;
+  times_up 	= 	0;
+  
+  /* set-up the data buffers with the requested alignment and offset. */
+  /* since this is a request/response test, default the send_width and */
+  /* recv_width to 1 and not two raj 7/94 */
+
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+  
+  send_ring = allocate_buffer_ring(send_width,
+				   req_size,
+				   local_send_align,
+				   local_send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   rsp_size,
+				   local_recv_align,
+				   local_recv_offset);
+				   
+  /*set up the data socket                        */
+  send_socket = create_unix_socket(AF_UNIX, 
+				   SOCK_STREAM);
+  
+  if (send_socket == INVALID_SOCKET){
+    perror("netperf: send_stream_rr: stream stream data socket");
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"send_stream_rr: send_socket obtained...\n");
+  }
+  
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 8, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type	=	DO_STREAM_RR;
+  stream_rr_request->recv_buf_size	=	rsr_size;
+  stream_rr_request->send_buf_size	=	rss_size;
+  stream_rr_request->recv_alignment=	remote_recv_align;
+  stream_rr_request->recv_offset	=	remote_recv_offset;
+  stream_rr_request->send_alignment=	remote_send_align;
+  stream_rr_request->send_offset	=	remote_send_offset;
+  stream_rr_request->request_size	=	req_size;
+  stream_rr_request->response_size	=	rsp_size;
+  stream_rr_request->measure_cpu	=	remote_cpu_usage;
+  stream_rr_request->cpu_rate	=	remote_cpu_rate;
+  if (test_time) {
+    stream_rr_request->test_length	=	test_time;
+  }
+  else {
+    stream_rr_request->test_length	=	test_trans * -1;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,"netperf: send_stream_rr: requesting STREAM rr test\n");
+  }
+  
+  send_request();
+  
+  /* The response from the remote will contain all of the relevant 	*/
+  /* socket parameters for this test type. We will put them back into 	*/
+  /* the variables here so they can be displayed if desired.  The	*/
+  /* remote will have calibrated CPU if necessary, and will have done	*/
+  /* all the needed set-up we will have calibrated the cpu locally	*/
+  /* before sending the request, and will grab the counter value right	*/
+  /* after the connect returns. The remote will grab the counter right	*/
+  /* after the accept call. This saves the hassle of extra messages	*/
+  /* being sent for the STREAM tests.					*/
+  
+  recv_response();
+  
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote listen done.\n");
+    rsr_size	=	stream_rr_response->recv_buf_size;
+    rss_size	=	stream_rr_response->send_buf_size;
+    remote_cpu_usage=	stream_rr_response->measure_cpu;
+    remote_cpu_rate = 	stream_rr_response->cpu_rate;
+    /* make sure that port numbers are in network order */
+    strcpy(server.sun_path,stream_rr_response->unix_path);
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /*Connect up to the remote port on the data socket  */
+  if (connect(send_socket, 
+	      (struct sockaddr *)&server,
+	      sizeof(server)) == INVALID_SOCKET){
+    perror("netperf: data socket connect failed");
+    
+    exit(1);
+  }
+  
+  /* Data Socket set-up is finished. If there were problems, either the */
+  /* connect would have failed, or the previous response would have */
+  /* indicated a problem. I failed to see the value of the extra */
+  /* message after the accept on the remote. If it failed, we'll see it */
+  /* here. If it didn't, we might as well start pumping data. */
+  
+  /* Set-up the test end conditions. For a request/response test, they */
+  /* can be either time or transaction based. */
+  
+  if (test_time) {
+    /* The user wanted to end the test after a period of time. */
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(test_time);
+  }
+  else {
+    /* The tester wanted to send a number of bytes. */
+    trans_remaining = test_bytes;
+    times_up = 1;
+  }
+  
+  /* The cpu_start routine will grab the current time and possibly */
+  /* value of the idle counter for later use in measuring cpu */
+  /* utilization and/or service demand and thruput. */
+  
+  cpu_start(local_cpu_usage);
+  
+  /* We use an "OR" to control test execution. When the test is */
+  /* controlled by time, the byte count check will always return false. */
+  /* When the test is controlled by byte count, the time test will */
+  /* always return false. When the test is finished, the whole */
+  /* expression will go false and we will stop sending data. I think I */
+  /* just arbitrarily decrement trans_remaining for the timed test, but */
+  /* will not do that just yet... One other question is whether or not */
+  /* the send buffer and the receive buffer should be the same buffer. */
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    /* send the request. we assume that if we use a blocking socket, */
+    /* the request will be sent at one shot. */
+    if((len=send(send_socket,
+		 send_ring->buffer_ptr,
+		 req_size,
+		 0)) != req_size) {
+      if (errno == EINTR) {
+	/* we hit the end of a */
+	/* timed test. */
+	timed_out = 1;
+	break;
+      }
+      perror("send_stream_rr: data send error");
+      exit(1);
+    }
+    send_ring = send_ring->next;
+    
+    /* receive the response */
+    rsp_bytes_left = rsp_size;
+    temp_message_ptr  = recv_ring->buffer_ptr;
+    while(rsp_bytes_left > 0) {
+      if((rsp_bytes_recvd=recv(send_socket,
+			       temp_message_ptr,
+			       rsp_bytes_left,
+			       0)) == SOCKET_ERROR) {
+	if (errno == EINTR) {
+	  /* We hit the end of a timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_stream_rr: data recv error");
+	exit(1);
+      }
+      rsp_bytes_left -= rsp_bytes_recvd;
+      temp_message_ptr  += rsp_bytes_recvd;
+    }	
+    recv_ring = recv_ring->next;
+    
+    if (timed_out) {
+      /* we may have been in a nested while loop - we need */
+      /* another call to break. */
+      break;
+    }
+    
+    nummessages++;          
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug > 3) {
+      fprintf(where,
+	      "Transaction %d completed\n",
+	      nummessages);
+      fflush(where);
+    }
+  }
+  
+  /* At this point we used to call shutdown on the data socket to be */
+  /* sure all the data was delivered, but this was not germane in a */
+  /* request/response test, and it was causing the tests to "hang" when */
+  /* they were being controlled by time. So, I have replaced this */
+  /* shutdown call with a call to close that can be found later in the */
+  /* procedure. */
+  
+  /* this call will always give us the elapsed time for the test, and */
+  /* will also store-away the necessaries for cpu utilization */
+  
+  cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being measured? */
+  /* how long did we really run? */
+  
+  /* Get the statistics from the remote end. The remote will have */
+  /* calculated service demand and all those interesting things. If it */
+  /* wasn't supposed to care, it will return obvious values. */
+  
+  recv_response();
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote results obtained\n");
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /* We now calculate what our thruput was for the test. In the future, */
+  /* we may want to include a calculation of the thruput measured by */
+  /* the remote, but it should be the case that for a STREAM stream test, */
+  /* that the two numbers should be *very* close... We calculate */
+  /* bytes_sent regardless of the way the test length was controlled. */
+  /* If it was time, we needed to, and if it was by bytes, the user may */
+  /* have specified a number of bytes that wasn't a multiple of the */
+  /* send_size, so we really didn't send what he asked for ;-) We use */
+  /* Kbytes/s as the units of thruput for a STREAM stream test, where K = */
+  /* 1024. A future enhancement *might* be to choose from a couple of */
+  /* unit selections. */ 
+  
+  bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+  thruput	= calc_thruput(bytes_xferd);
+  
+  if (local_cpu_usage || remote_cpu_usage) {
+    /* We must now do a little math for service demand and cpu */
+    /* utilization for the system(s) */
+    /* Of course, some of the information might be bogus because */
+    /* there was no idle counter in the kernel(s). We need to make */
+    /* a note of this for the user's benefit...*/
+    if (local_cpu_usage) {
+      if (local_cpu_rate == 0.0) {
+	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
+	fprintf(where,"Local CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      local_cpu_utilization = calc_cpu_util(0.0);
+      /* since calc_service demand is doing ms/Kunit we will */
+      /* multiply the number of transaction by 1024 to get */
+      /* "good" numbers */
+      local_service_demand  = calc_service_demand((double) nummessages*1024,
+						  0.0,
+						  0.0,
+						  0);
+    }
+    else {
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+    }
+    
+    if (remote_cpu_usage) {
+      if (remote_cpu_rate == 0.0) {
+	fprintf(where,"DANGER  DANGER  DANGER    DANGER  DANGER  DANGER    DANGER!\n");
+	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      remote_cpu_utilization = stream_rr_result->cpu_util;
+      /* since calc_service demand is doing ms/Kunit we will */
+      /* multiply the number of transaction by 1024 to get */
+      /* "good" numbers */
+      remote_service_demand = calc_service_demand((double) nummessages*1024,
+						  0.0,
+						  remote_cpu_utilization,
+						  stream_rr_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* We are now ready to print all the information. If the user */
+    /* has specified zero-level verbosity, we will just print the */
+    /* local service demand, or the remote service demand. If the */
+    /* user has requested verbosity level 1, he will get the basic */
+    /* "streamperf" numbers. If the user has specified a verbosity */
+    /* of greater than 1, we will display a veritable plethora of */
+    /* background information from outside of this block as it it */
+    /* not cpu_measurement specific...  */
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand);
+      }
+      break;
+    case 1:
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* STREAM statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt);
+  }
+  /* The test is over. Kill the data socket */
+  
+  if (close(send_socket) == -1) {
+    perror("send_stream_rr: cannot shutdown stream stream socket");
+  }
+  
+}
+
+void
+send_dg_stream(char remote_host[])
+{
+  /************************************************************************/
+  /*									*/
+  /*               	DG Unidirectional Send Test                    */
+  /*									*/
+  /************************************************************************/
+  char *tput_title =
+    "Socket  Message  Elapsed      Messages                \n\
+Size    Size     Time         Okay Errors   Throughput\n\
+bytes   bytes    secs            #      #   %s/sec\n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%5d   %5d    %-7.2f   %7d %6d    %7.2f\n\
+%5d            %-7.2f   %7d           %7.2f\n\n";
+  
+  
+  char *cpu_title =
+    "Socket  Message  Elapsed      Messages                   CPU     Service\n\
+Size    Size     Time         Okay Errors   Throughput   Util    Demand\n\
+bytes   bytes    secs            #      #   %s/sec   %%       us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.2f\n";
+  
+  char *cpu_fmt_1 =
+    "%5d   %5d    %-7.2f   %7d %6d    %7.1f      %-6.2f  %-6.3f\n\
+%5d            %-7.2f   %7d           %7.1f      %-6.2f  %-6.3f\n\n";
+  
+  int	messages_recvd;
+  float	elapsed_time, 
+  local_cpu_utilization, 
+  remote_cpu_utilization;
+  
+  float	local_service_demand, remote_service_demand;
+  double	local_thruput, remote_thruput;
+  double	bytes_sent;
+  double	bytes_recvd;
+  
+  
+  int	len;
+  struct ring_elt *send_ring;
+  int	failed_sends;
+  int	failed_cows;
+  int 	messages_sent;
+  SOCKET data_socket;
+  
+  
+#ifdef WANT_INTERVALS
+  int	interval_count;
+#endif /* WANT_INTERVALS */
+#ifdef DIRTY
+  int	*message_int_ptr;
+  int	i;
+#endif /* DIRTY */
+  
+  struct	sockaddr_un	server;
+  
+  struct	dg_stream_request_struct	*dg_stream_request;
+  struct	dg_stream_response_struct	*dg_stream_response;
+  struct	dg_stream_results_struct	*dg_stream_results;
+  
+  dg_stream_request	= (struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
+  dg_stream_response	= (struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
+  dg_stream_results	= (struct dg_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  server.sun_family = AF_UNIX;
+  
+  if ( print_headers ) {
+    printf("DG UNIDIRECTIONAL SEND TEST\n");
+    if (local_cpu_usage || remote_cpu_usage)
+      printf(cpu_title,format_units());
+    else
+      printf(tput_title,format_units());
+  }	
+  
+  failed_sends	= 0;
+  failed_cows	= 0;
+  messages_sent	= 0;
+  times_up	= 0;
+  
+  /*set up the data socket			*/
+  data_socket = create_unix_socket(AF_UNIX,
+				   SOCK_DGRAM);
+  
+  if (data_socket == INVALID_SOCKET){
+    perror("dg_send: data socket");
+    exit(1);
+  }
+  
+  /* now, we want to see if we need to set the send_size */
+  if (send_size == 0) {
+    if (lss_size > 0) {
+      send_size = (lss_size < UNIX_LENGTH_MAX ? lss_size : UNIX_LENGTH_MAX);
+    }
+    else {
+      send_size = 4096;
+    }
+  }
+  
+  
+  /* set-up the data buffer with the requested alignment and offset, */
+  /* most of the numbers here are just a hack to pick something nice */
+  /* and big in an attempt to never try to send a buffer a second time */
+  /* before it leaves the node...unless the user set the width */
+  /* explicitly. */
+  if (send_width == 0) send_width = 32;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   send_size,
+				   local_send_align,
+				   local_send_offset);
+
+  /* At this point, we want to do things like disable DG checksumming */
+  /* and measure the cpu rate and all that so we are ready to go */
+  /* immediately after the test response message is delivered. */
+  
+  /* if the user supplied a cpu rate, this call will complete rather */
+  /* quickly, otherwise, the cpu rate will be retured to us for */
+  /* possible display. The Library will keep it's own copy of this data */
+  /* for use elsewhere. We will only display it. (Does that make it */
+  /* "opaque" to us?) */
+  
+  if (local_cpu_usage)
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  
+  /* Tell the remote end to set up the data connection. The server */
+  /* sends back the port number and alters the socket parameters there. */
+  /* Of course this is a datagram service so no connection is actually */
+  /* set up, the server just sets up the socket and binds it. */
+  
+  netperf_request.content.request_type = DO_DG_STREAM;
+  dg_stream_request->recv_buf_size	= rsr_size;
+  dg_stream_request->message_size	= send_size;
+  dg_stream_request->recv_alignment	= remote_recv_align;
+  dg_stream_request->recv_offset	= remote_recv_offset;
+  dg_stream_request->measure_cpu	= remote_cpu_usage;
+  dg_stream_request->cpu_rate		= remote_cpu_rate;
+  dg_stream_request->test_length	= test_time;
+  
+  send_request();
+  
+  recv_response();
+  
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"send_dg_stream: remote data connection done.\n");
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("send_dg_stream: error on remote");
+    exit(1);
+  }
+  
+  /* Place the port number returned by the remote into the sockaddr */
+  /* structure so our sends can be sent to the correct place. Also get */
+  /* some of the returned socket buffer information for user display. */
+  
+  /* make sure that port numbers are in the proper order */
+  strcpy(server.sun_path,dg_stream_response->unix_path);
+  rsr_size	= dg_stream_response->recv_buf_size;
+  rss_size	= dg_stream_response->send_buf_size;
+  remote_cpu_rate	= dg_stream_response->cpu_rate;
+  
+  /* We "connect" up to the remote post to allow is to use the send */
+  /* call instead of the sendto call. Presumeably, this is a little */
+  /* simpler, and a little more efficient. I think that it also means */
+  /* that we can be informed of certain things, but am not sure yet... */
+  
+  if (connect(data_socket,
+	      (struct sockaddr *)&server,
+	      sizeof(server)) == INVALID_SOCKET){
+    perror("send_dg_stream: data socket connect failed");
+    exit(1);
+  }
+  
+  /* set up the timer to call us after test_time	*/
+  start_timer(test_time);
+  
+  /* Get the start count for the idle counter and the start time */
+  
+  cpu_start(local_cpu_usage);
+  
+#ifdef WANT_INTERVALS
+  interval_count = interval_burst;
+#endif
+  
+  /* Send datagrams like there was no tomorrow. at somepoint it might */
+  /* be nice to set this up so that a quantity of bytes could be sent, */
+  /* but we still need some sort of end of test trigger on the receive */
+  /* side. that could be a select with a one second timeout, but then */
+  /* if there is a test where none of the data arrives for awile and */
+  /* then starts again, we would end the test too soon. something to */
+  /* think about... */
+  while (!times_up) {
+
+#ifdef DIRTY
+    /* we want to dirty some number of consecutive integers in the buffer */
+    /* we are about to send. we may also want to bring some number of */
+    /* them cleanly into the cache. The clean ones will follow any dirty */
+    /* ones into the cache. */
+    message_int_ptr = (int *)(send_ring->buffer_ptr);
+    for (i = 0; i < loc_dirty_count; i++) {
+      *message_int_ptr = 4;
+      message_int_ptr++;
+    }
+    for (i = 0; i < loc_clean_count; i++) {
+      loc_dirty_count = *message_int_ptr;
+      message_int_ptr++;
+    }
+#endif /* DIRTY */
+
+    if ((len=send(data_socket,
+		  send_ring->buffer_ptr,
+		  send_size,
+		  0))  != send_size) {
+      if ((len >= 0) || (errno == EINTR))
+	break;
+      if (errno == ENOBUFS) {
+	failed_sends++;
+	continue;
+      }
+      perror("dg_send: data send error");
+      exit(1);
+    }
+    messages_sent++;          
+    
+    /* now we want to move our pointer to the next position in the */
+    /* data buffer... */
+
+    send_ring = send_ring->next;
+    
+    
+#ifdef WANT_INTERVALS
+    /* in this case, the interval count is the count-down couter */
+    /* to decide to sleep for a little bit */
+    if ((interval_burst) && (--interval_count == 0)) {
+      /* call the sleep routine for some milliseconds, if our */
+      /* timer popped while we were in there, we want to */
+      /* break out of the loop. */
+      if (msec_sleep(interval_wate)) {
+	break;
+      }
+      interval_count = interval_burst;
+    }
+    
+#endif
+    
+  }
+  
+  /* This is a timed test, so the remote will be returning to us after */
+  /* a time. We should not need to send any "strange" messages to tell */
+  /* the remote that the test is completed, unless we decide to add a */
+  /* number of messages to the test. */
+  
+  /* the test is over, so get stats and stuff */
+  cpu_stop(local_cpu_usage,	
+	   &elapsed_time);
+  
+  /* Get the statistics from the remote end	*/
+  recv_response();
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"send_dg_stream: remote results obtained\n");
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("send_dg_stream: error on remote");
+    exit(1);
+  }
+  
+  bytes_sent	= send_size * messages_sent;
+  local_thruput	= calc_thruput(bytes_sent);
+  
+  messages_recvd	= dg_stream_results->messages_recvd;
+  bytes_recvd	= send_size * messages_recvd;
+  
+  /* we asume that the remote ran for as long as we did */
+  
+  remote_thruput	= calc_thruput(bytes_recvd);
+  
+  /* print the results for this socket and message size */
+  
+  if (local_cpu_usage || remote_cpu_usage) {
+    /* We must now do a little math for service demand and cpu */
+    /* utilization for the system(s) We pass zeros for the local */
+    /* cpu utilization and elapsed time to tell the routine to use */
+    /* the libraries own values for those. */
+    if (local_cpu_usage) {
+      if (local_cpu_rate == 0.0) {
+	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
+	fprintf(where,"Local CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      
+      local_cpu_utilization	= calc_cpu_util(0.0);
+      local_service_demand	= calc_service_demand(bytes_sent,
+						      0.0,
+						      0.0,
+						      0);
+    }
+    else {
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+    }
+    
+    /* The local calculations could use variables being kept by */
+    /* the local netlib routines. The remote calcuations need to */
+    /* have a few things passed to them. */
+    if (remote_cpu_usage) {
+      if (remote_cpu_rate == 0.0) {
+	fprintf(where,"DANGER   DANGER  DANGER   DANGER  DANGER   DANGER   DANGER!\n");
+	fprintf(where,"REMOTE CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      
+      remote_cpu_utilization	= dg_stream_results->cpu_util;
+      remote_service_demand	= calc_service_demand(bytes_recvd,
+						      0.0,
+						      remote_cpu_utilization,
+						      dg_stream_results->num_cpus);
+    }
+    else {
+      remote_cpu_utilization	= -1.0;
+      remote_service_demand	= -1.0;
+    }
+    
+    /* We are now ready to print all the information. If the user */
+    /* has specified zero-level verbosity, we will just print the */
+    /* local service demand, or the remote service demand. If the */
+    /* user has requested verbosity level 1, he will get the basic */
+    /* "streamperf" numbers. If the user has specified a verbosity */
+    /* of greater than 1, we will display a veritable plethora of */
+    /* background information from outside of this block as it it */
+    /* not cpu_measurement specific...  */
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand);
+      }
+      break;
+    case 1:
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput, 		/* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      local_service_demand,	/* local service demand */
+	      rsr_size,
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput,
+	      remote_cpu_utilization,	/* remote cpu */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      local_thruput);
+      break;
+    case 1:
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput,
+	      rsr_size, 		/* remote recvbuf size */
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput
+	      );
+      break;
+    }
+  }
+}
+
+
+ /* this routine implements the receive side (netserver) of the */
+ /* DG_STREAM performance test. */
+
+void
+recv_dg_stream()
+{
+  struct ring_elt *recv_ring;
+
+  struct sockaddr_un myaddr_un;
+  SOCKET s_data;
+  int	len = 0;
+  int	bytes_received = 0;
+  float	elapsed_time;
+  
+  int	message_size;
+  int	messages_recvd = 0;
+  
+  struct	dg_stream_request_struct	*dg_stream_request;
+  struct	dg_stream_response_struct	*dg_stream_response;
+  struct	dg_stream_results_struct	*dg_stream_results;
+  
+  dg_stream_request  = 
+    (struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
+  dg_stream_response = 
+    (struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
+  dg_stream_results  = 
+    (struct dg_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_dg_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_dg_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = DG_STREAM_RESPONSE;
+  
+  if (debug > 2) {
+    fprintf(where,"recv_dg_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_dg_stream: requested alignment of %d\n",
+	    dg_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   dg_stream_request->message_size,
+				   dg_stream_request->recv_alignment,
+				   dg_stream_request->recv_offset);
+
+  if (debug > 1) {
+    fprintf(where,"recv_dg_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_un,
+	sizeof(myaddr_un));
+  myaddr_un.sun_family      = AF_UNIX;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_dg_stream: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_unix_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lsr_size = dg_stream_request->recv_buf_size;
+    
+  s_data = create_unix_socket(AF_UNIX,
+			      SOCK_DGRAM);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
+  if (bind(s_data,
+	   (struct sockaddr *)&myaddr_un,
+	   sizeof(myaddr_un)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+
+  chmod(myaddr_un.sun_path, 0666);
+
+  dg_stream_response->test_length = dg_stream_request->test_length;
+  
+  /* Now myaddr_un contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  strcpy(dg_stream_response->unix_path,myaddr_un.sun_path);
+  netperf_response.content.serv_errno   = 0;
+  
+  /* But wait, there's more. If the initiator wanted cpu measurements, */
+  /* then we must call the calibrate routine, which will return the max */
+  /* rate back to the initiator. If the CPU was not to be measured, or */
+  /* something went wrong with the calibration, we will return a -1 to */
+  /* the initiator. */
+  
+  dg_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (dg_stream_request->measure_cpu) {
+    /* We will pass the rate into the calibration routine. If the */
+    /* user did not specify one, it will be 0.0, and we will do a */
+    /* "real" calibration. Otherwise, all it will really do is */
+    /* store it away... */
+    dg_stream_response->measure_cpu = 1;
+    dg_stream_response->cpu_rate = 
+      calibrate_local_cpu(dg_stream_request->cpu_rate);
+  }
+  
+  message_size	= dg_stream_request->message_size;
+  test_time	= dg_stream_request->test_length;
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  dg_stream_response->send_buf_size = lss_size;
+  dg_stream_response->recv_buf_size = lsr_size;
+
+  send_response();
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(dg_stream_request->measure_cpu);
+  
+  /* The loop will exit when the timer pops, or if we happen to recv a */
+  /* message of less than send_size bytes... */
+  
+  times_up = 0;
+  start_timer(test_time + PAD_TIME);
+  
+  if (debug) {
+    fprintf(where,"recv_dg_stream: about to enter inner sanctum.\n");
+    fflush(where);
+  }
+  
+  while (!times_up) {
+    if ((len = recv(s_data, 
+		    recv_ring->buffer_ptr,
+		    message_size, 
+		    0)) != message_size) {
+      if ((len == SOCKET_ERROR) && (errno != EINTR)) {
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      break;
+    }
+    messages_recvd++;
+    recv_ring = recv_ring->next;
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_dg_stream: got %d messages.\n",messages_recvd);
+    fflush(where);
+  }
+  
+  
+  /* The loop now exits due timer or < send_size bytes received. */
+  
+  cpu_stop(dg_stream_request->measure_cpu,&elapsed_time);
+  
+  if (times_up) {
+    /* we ended on a timer, subtract the PAD_TIME */
+    elapsed_time -= (float)PAD_TIME;
+  }
+  else {
+    stop_timer();
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_dg_stream: test ended in %f seconds.\n",elapsed_time);
+    fflush(where);
+  }
+  
+  
+  /* We will count the "off" message that got us out of the loop */
+  bytes_received = (messages_recvd * message_size) + len;
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_dg_stream: got %d bytes\n",
+	    bytes_received);
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type		= DG_STREAM_RESULTS;
+  dg_stream_results->bytes_received	= bytes_received;
+  dg_stream_results->messages_recvd	= messages_recvd;
+  dg_stream_results->elapsed_time	= elapsed_time;
+  if (dg_stream_request->measure_cpu) {
+    dg_stream_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  else {
+    dg_stream_results->cpu_util	= -1.0;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,
+	    "recv_dg_stream: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+
+void
+send_dg_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  float			elapsed_time;
+  
+  /* we add MAXALIGNMENT and MAXOFFSET to insure that there is enough */
+  /* space for a maximally aligned, maximally sized message. At some */
+  /* point, we may want to actually make this even larger and cycle */
+  /* through the thing one piece at a time.*/
+  
+  int	len;
+  char	*send_message_ptr;
+  char	*recv_message_ptr;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET send_socket;
+  int	trans_remaining;
+  int	bytes_xferd;
+  
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+#ifdef WANT_INTERVALS
+  /* timing stuff */
+#define	MAX_KEPT_TIMES	1024
+  int	time_index = 0;
+  int	unused_buckets;
+  int	kept_times[MAX_KEPT_TIMES];
+  int	sleep_usecs;
+  unsigned	int	total_times=0;
+  struct	timezone	dummy_zone;
+  struct	timeval		send_time;
+  struct	timeval		recv_time;
+  struct	timeval		sleep_timeval;
+#endif
+  
+  struct	sockaddr_un	server, myaddr_un;
+  
+  struct	dg_rr_request_struct	*dg_rr_request;
+  struct	dg_rr_response_struct	*dg_rr_response;
+  struct	dg_rr_results_struct	*dg_rr_result;
+  
+  dg_rr_request	= 
+    (struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
+  dg_rr_response=
+    (struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
+  dg_rr_result	=
+    (struct dg_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  /* we want to zero out the times, so we can detect unused entries. */
+#ifdef WANT_INTERVALS
+  time_index = 0;
+  while (time_index < MAX_KEPT_TIMES) {
+    kept_times[time_index] = 0;
+    time_index += 1;
+  }
+  time_index = 0;
+#endif
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  server.sun_family = AF_UNIX;
+
+  bzero((char *)&myaddr_un,
+	sizeof(myaddr_un));
+  myaddr_un.sun_family = AF_UNIX;
+
+  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
+  
+  if ( print_headers ) {
+    fprintf(where,"DG REQUEST/RESPONSE TEST\n");
+    if (local_cpu_usage || remote_cpu_usage)
+      fprintf(where,cpu_title,format_units());
+    else
+      fprintf(where,tput_title,format_units());
+  }
+  
+  /* initialize a few counters */
+  
+  nummessages	=	0;
+  bytes_xferd	=	0;
+  times_up 	= 	0;
+  
+  /* set-up the data buffer with the requested alignment and offset */
+  temp_message_ptr = (char *)malloc(DATABUFFERLEN);
+  if (temp_message_ptr == NULL) {
+    printf("malloc(%d) failed!\n", DATABUFFERLEN);
+    exit(1);
+  }
+  send_message_ptr = (char *)(( (long)temp_message_ptr + 
+			(long) local_send_align - 1) &	
+			~((long) local_send_align - 1));
+  send_message_ptr = send_message_ptr + local_send_offset;
+  temp_message_ptr = (char *)malloc(DATABUFFERLEN);
+  if (temp_message_ptr == NULL) {
+    printf("malloc(%d) failed!\n", DATABUFFERLEN);
+    exit(1);
+  }
+  recv_message_ptr = (char *)(( (long)temp_message_ptr + 
+			(long) local_recv_align - 1) &	
+			~((long) local_recv_align - 1));
+  recv_message_ptr = recv_message_ptr + local_recv_offset;
+  
+  /*set up the data socket                        */
+  send_socket = create_unix_socket(AF_UNIX, 
+				   SOCK_DGRAM);
+  
+  if (send_socket == INVALID_SOCKET){
+    perror("netperf: send_dg_rr: dg rr data socket");
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"send_dg_rr: send_socket obtained...\n");
+  }
+  
+	
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back. If */
+  /* there is no idle counter in the kernel idle loop, the */
+  /* local_cpu_rate will be set to -1. */
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 8, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type	=	DO_DG_RR;
+  dg_rr_request->recv_buf_size	=	rsr_size;
+  dg_rr_request->send_buf_size	=	rss_size;
+  dg_rr_request->recv_alignment	=	remote_recv_align;
+  dg_rr_request->recv_offset	=	remote_recv_offset;
+  dg_rr_request->send_alignment	=	remote_send_align;
+  dg_rr_request->send_offset	=	remote_send_offset;
+  dg_rr_request->request_size	=	req_size;
+  dg_rr_request->response_size	=	rsp_size;
+  dg_rr_request->measure_cpu	=	remote_cpu_usage;
+  dg_rr_request->cpu_rate	=	remote_cpu_rate;
+  if (test_time) {
+    dg_rr_request->test_length	=	test_time;
+  }
+  else {
+    dg_rr_request->test_length	=	test_trans * -1;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,"netperf: send_dg_rr: requesting DG request/response test\n");
+  }
+  
+  send_request();
+  
+  /* The response from the remote will contain all of the relevant 	*/
+  /* socket parameters for this test type. We will put them back into 	*/
+  /* the variables here so they can be displayed if desired.  The	*/
+  /* remote will have calibrated CPU if necessary, and will have done	*/
+  /* all the needed set-up we will have calibrated the cpu locally	*/
+  /* before sending the request, and will grab the counter value right	*/
+  /* after the connect returns. The remote will grab the counter right	*/
+  /* after the accept call. This saves the hassle of extra messages	*/
+  /* being sent for the DG tests.					*/
+  
+  recv_response();
+  
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote listen done.\n");
+    rsr_size	=	dg_rr_response->recv_buf_size;
+    rss_size	=	dg_rr_response->send_buf_size;
+    remote_cpu_usage=	dg_rr_response->measure_cpu;
+    remote_cpu_rate = 	dg_rr_response->cpu_rate;
+    /* port numbers in proper order */
+    strcpy(server.sun_path,dg_rr_response->unix_path);
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /* Connect up to the remote port on the data socket. This will set */
+  /* the default destination address on this socket. we need to bind */
+  /* out socket so that the remote gets something from a recvfrom  */
+  if (bind(send_socket,
+	   (struct sockaddr *)&myaddr_un,
+	   sizeof(myaddr_un)) == SOCKET_ERROR) {
+    perror("netperf: send_dg_rr");
+    unlink(myaddr_un.sun_path);
+    close(send_socket);
+    exit(1);
+  }
+  
+  if (connect(send_socket, 
+	      (struct sockaddr *)&server,
+	      sizeof(server)) == INVALID_SOCKET ) {
+    perror("netperf: data socket connect failed");
+    exit(1);
+  }
+  
+  /* Data Socket set-up is finished. If there were problems, either the */
+  /* connect would have failed, or the previous response would have */
+  /* indicated a problem. I failed to see the value of the extra */
+  /* message after the accept on the remote. If it failed, we'll see it */
+  /* here. If it didn't, we might as well start pumping data. */
+  
+  /* Set-up the test end conditions. For a request/response test, they */
+  /* can be either time or transaction based. */
+  
+  if (test_time) {
+    /* The user wanted to end the test after a period of time. */
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(test_time);
+  }
+  else {
+    /* The tester wanted to send a number of bytes. */
+    trans_remaining = test_bytes;
+    times_up = 1;
+  }
+  
+  /* The cpu_start routine will grab the current time and possibly */
+  /* value of the idle counter for later use in measuring cpu */
+  /* utilization and/or service demand and thruput. */
+  
+  cpu_start(local_cpu_usage);
+  
+  /* We use an "OR" to control test execution. When the test is */
+  /* controlled by time, the byte count check will always return false. */
+  /* When the test is controlled by byte count, the time test will */
+  /* always return false. When the test is finished, the whole */
+  /* expression will go false and we will stop sending data. I think I */
+  /* just arbitrarily decrement trans_remaining for the timed test, but */
+  /* will not do that just yet... One other question is whether or not */
+  /* the send buffer and the receive buffer should be the same buffer. */
+  while ((!times_up) || (trans_remaining > 0)) {
+    /* send the request */
+#ifdef WANT_INTERVALS
+    gettimeofday(&send_time,&dummy_zone);
+#endif
+    if((len=send(send_socket,
+		 send_message_ptr,
+		 req_size,
+		 0)) != req_size) {
+      if (errno == EINTR) {
+	/* We likely hit */
+	/* test-end time. */
+	break;
+      }
+      perror("send_dg_rr: data send error");
+      exit(1);
+    }
+    
+    /* receive the response. with DG we will get it all, or nothing */
+    
+    if((rsp_bytes_recvd=recv(send_socket,
+			     recv_message_ptr,
+			     rsp_size,
+			     0)) != rsp_size) {
+      if (errno == EINTR) {
+	/* Again, we have likely hit test-end time */
+	break;
+      }
+      perror("send_dg_rr: data recv error");
+      exit(1);
+    }
+#ifdef WANT_INTERVALS
+    gettimeofday(&recv_time,&dummy_zone);
+    
+    /* now we do some arithmatic on the two timevals */
+    if (recv_time.tv_usec < send_time.tv_usec) {
+      /* we wrapped around a second */
+      recv_time.tv_usec += 1000000;
+      recv_time.tv_sec  -= 1;
+    }
+    
+    /* and store it away */
+    kept_times[time_index] = (recv_time.tv_sec - send_time.tv_sec) * 1000000;
+    kept_times[time_index] += (recv_time.tv_usec - send_time.tv_usec);
+    
+    /* at this point, we may wish to sleep for some period of */
+    /* time, so we see how long that last transaction just took, */
+    /* and sleep for the difference of that and the interval. We */
+    /* will not sleep if the time would be less than a */
+    /* millisecond.  */
+    if (interval_usecs > 0) {
+      sleep_usecs = interval_usecs - kept_times[time_index];
+      if (sleep_usecs > 1000) {
+	/* we sleep */
+	sleep_timeval.tv_sec = sleep_usecs / 1000000;
+	sleep_timeval.tv_usec = sleep_usecs % 1000000;
+	select(0,
+	       0,
+	       0,
+	       0,
+	       &sleep_timeval);
+      }
+    }
+    
+    /* now up the time index */
+    time_index = (time_index +1)%MAX_KEPT_TIMES;
+#endif
+    nummessages++;          
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug > 3) {
+      fprintf(where,"Transaction %d completed\n",nummessages);
+      fflush(where);
+    }
+    
+  }
+  
+  /* The test is over. Flush the buffers to the remote end. We do a */
+  /* graceful release to insure that all data has been taken by the */
+  /* remote. Of course, since this was a request/response test, there */
+  /* should be no data outstanding on the socket ;-) */ 
+  
+  if (shutdown(send_socket,1) == SOCKET_ERROR) {
+    perror("netperf: cannot shutdown dg stream socket");
+    
+    exit(1);
+  }
+  
+  /* this call will always give us the elapsed time for the test, and */
+  /* will also store-away the necessaries for cpu utilization */
+  
+  cpu_stop(local_cpu_usage,&elapsed_time);	/* was cpu being measured? */
+  /* how long did we really run? */
+  
+  /* Get the statistics from the remote end. The remote will have */
+  /* calculated service demand and all those interesting things. If it */
+  /* wasn't supposed to care, it will return obvious values. */
+  
+  recv_response();
+  if (!netperf_response.content.serv_errno) {
+    if (debug)
+      fprintf(where,"remote results obtained\n");
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /* We now calculate what our thruput was for the test. In the future, */
+  /* we may want to include a calculation of the thruput measured by */
+  /* the remote, but it should be the case that for a DG stream test, */
+  /* that the two numbers should be *very* close... We calculate */
+  /* bytes_sent regardless of the way the test length was controlled. */
+  /* If it was time, we needed to, and if it was by bytes, the user may */
+  /* have specified a number of bytes that wasn't a multiple of the */
+  /* send_size, so we really didn't send what he asked for ;-) We use */
+  
+  bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+  thruput		= calc_thruput(bytes_xferd);
+  
+  if (local_cpu_usage || remote_cpu_usage) {
+    /* We must now do a little math for service demand and cpu */
+    /* utilization for the system(s) */
+    /* Of course, some of the information might be bogus because */
+    /* there was no idle counter in the kernel(s). We need to make */
+    /* a note of this for the user's benefit...*/
+    if (local_cpu_usage) {
+      if (local_cpu_rate == 0.0) {
+	fprintf(where,"WARNING WARNING WARNING  WARNING WARNING WARNING  WARNING!\n");
+	fprintf(where,"Local CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      local_cpu_utilization = calc_cpu_util(0.0);
+      /* since calc_service demand is doing ms/Kunit we will */
+      /* multiply the number of transaction by 1024 to get */
+      /* "good" numbers */
+      local_service_demand  = calc_service_demand((double) nummessages*1024,
+						  0.0,
+						  0.0,
+						  0);
+    }
+    else {
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+    }
+    
+    if (remote_cpu_usage) {
+      if (remote_cpu_rate == 0.0) {
+	fprintf(where,"DANGER  DANGER  DANGER    DANGER  DANGER  DANGER    DANGER!\n");
+	fprintf(where,"Remote CPU usage numbers based on process information only!\n");
+	fflush(where);
+      }
+      remote_cpu_utilization = dg_rr_result->cpu_util;
+      /* since calc_service demand is doing ms/Kunit we will */
+      /* multiply the number of transaction by 1024 to get */
+      /* "good" numbers */
+      remote_service_demand  = calc_service_demand((double) nummessages*1024,
+						   0.0,
+						   remote_cpu_utilization,
+						   dg_rr_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* We are now ready to print all the information. If the user */
+    /* has specified zero-level verbosity, we will just print the */
+    /* local service demand, or the remote service demand. If the */
+    /* user has requested verbosity level 1, he will get the basic */
+    /* "streamperf" numbers. If the user has specified a verbosity */
+    /* of greater than 1, we will display a veritable plethora of */
+    /* background information from outside of this block as it it */
+    /* not cpu_measurement specific...  */
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand);
+      }
+      break;
+    case 1:
+    case 2:
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* DG statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+#ifdef WANT_INTERVALS
+    kept_times[MAX_KEPT_TIMES] = 0;
+    time_index = 0;
+    while (time_index < MAX_KEPT_TIMES) {
+      if (kept_times[time_index] > 0) {
+	total_times += kept_times[time_index];
+      }
+      else
+	unused_buckets++;
+      time_index += 1;
+    }
+    total_times /= (MAX_KEPT_TIMES-unused_buckets);
+    fprintf(where,
+	    "Average response time %d usecs\n",
+	    total_times);
+#endif
+  }
+  unlink(myaddr_un.sun_path);
+}
+
+ /* this routine implements the receive side (netserver) of a DG_RR */
+ /* test. */
+void
+recv_dg_rr()
+{
+  
+  struct ring_elt *recv_ring;
+  struct ring_elt *send_ring;
+
+  struct	sockaddr_un        myaddr_un,
+  peeraddr_un;
+  SOCKET s_data;
+  int 	addrlen;
+  int	trans_received = 0;
+  int	trans_remaining;
+  float	elapsed_time;
+  
+  struct	dg_rr_request_struct	*dg_rr_request;
+  struct	dg_rr_response_struct	*dg_rr_response;
+  struct	dg_rr_results_struct	*dg_rr_results;
+  
+  dg_rr_request  = 
+    (struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
+  dg_rr_response = 
+    (struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
+  dg_rr_results  = 
+    (struct dg_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_dg_rr: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_dg_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = DG_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_dg_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variables to be at the desired */
+  /* alignments with the desired offsets. */
+  
+  if (debug) {
+    fprintf(where,"recv_dg_rr: requested recv alignment of %d offset %d\n",
+	    dg_rr_request->recv_alignment,
+	    dg_rr_request->recv_offset);
+    fprintf(where,"recv_dg_rr: requested send alignment of %d offset %d\n",
+	    dg_rr_request->send_alignment,
+	    dg_rr_request->send_offset);
+    fflush(where);
+  }
+
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   dg_rr_request->request_size,
+				   dg_rr_request->recv_alignment,
+				   dg_rr_request->recv_offset);
+
+  send_ring = allocate_buffer_ring(send_width,
+				   dg_rr_request->response_size,
+				   dg_rr_request->send_alignment,
+				   dg_rr_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_dg_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_un,
+	sizeof(myaddr_un));
+  myaddr_un.sun_family      = AF_UNIX;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_dg_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+
+  /* create_unix_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = dg_rr_request->send_buf_size;
+  lsr_size_req = dg_rr_request->recv_buf_size;
+
+  s_data = create_unix_socket(AF_UNIX,
+			      SOCK_DGRAM);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
+  if (bind(s_data,
+	   (struct sockaddr *)&myaddr_un,
+	   sizeof(myaddr_un)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    unlink(myaddr_un.sun_path);
+    close(s_data);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_un contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  strcpy(dg_rr_response->unix_path,myaddr_un.sun_path);
+  netperf_response.content.serv_errno   = 0;
+  
+  /* But wait, there's more. If the initiator wanted cpu measurements, */
+  /* then we must call the calibrate routine, which will return the max */
+  /* rate back to the initiator. If the CPU was not to be measured, or */
+  /* something went wrong with the calibration, we will return a 0.0 to */
+  /* the initiator. */
+  
+  dg_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (dg_rr_request->measure_cpu) {
+    dg_rr_response->measure_cpu = 1;
+    dg_rr_response->cpu_rate = calibrate_local_cpu(dg_rr_request->cpu_rate);
+  }
+   
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  dg_rr_response->send_buf_size = lss_size;
+  dg_rr_response->recv_buf_size = lsr_size;
+ 
+  send_response();
+  
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(dg_rr_request->measure_cpu);
+  
+  if (dg_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(dg_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = dg_rr_request->test_length * -1;
+  }
+  
+  addrlen = sizeof(peeraddr_un);
+  bzero((char *)&peeraddr_un, addrlen);
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    
+    /* receive the request from the other side */
+    fprintf(where,"socket %d ptr %p size %d\n",
+	    s_data,
+	    recv_ring->buffer_ptr,
+	    dg_rr_request->request_size);
+    fflush(where);
+    if (recvfrom(s_data,
+		 recv_ring->buffer_ptr,
+		 dg_rr_request->request_size,
+		 0,
+		 (struct sockaddr *)&peeraddr_un,
+		 &addrlen) != dg_rr_request->request_size) {
+      if (errno == EINTR) {
+	/* we must have hit the end of test time. */
+	break;
+      }
+      netperf_response.content.serv_errno = errno;
+      fprintf(where,"error on recvfrom errno %d\n",errno);
+      fflush(where);
+      send_response();
+      unlink(myaddr_un.sun_path);
+      exit(1);
+    }
+    recv_ring = recv_ring->next;
+
+    /* Now, send the response to the remote */
+    if (sendto(s_data,
+	       send_ring->buffer_ptr,
+	       dg_rr_request->response_size,
+	       0,
+	       (struct sockaddr *)&peeraddr_un,
+	       addrlen) != dg_rr_request->response_size) {
+      if (errno == EINTR) {
+	/* we have hit end of test time. */
+	break;
+      }
+      netperf_response.content.serv_errno = errno;
+      fprintf(where,"error on recvfrom errno %d\n",errno);
+      fflush(where);
+      unlink(myaddr_un.sun_path);
+      send_response();
+      exit(1);
+    }
+    send_ring = send_ring->next;
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_dg_rr: Transaction %d complete.\n",
+	      trans_received);
+      fflush(where);
+    }
+    
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(dg_rr_request->measure_cpu,&elapsed_time);
+  
+  if (times_up) {
+    /* we ended the test by time, which was at least 2 seconds */
+    /* longer than we wanted to run. so, we want to subtract */
+    /* PAD_TIME from the elapsed_time. */
+    elapsed_time -= PAD_TIME;
+  }
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_dg_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  dg_rr_results->bytes_received	= (trans_received * 
+					   (dg_rr_request->request_size + 
+					    dg_rr_request->response_size));
+  dg_rr_results->trans_received	= trans_received;
+  dg_rr_results->elapsed_time	= elapsed_time;
+  if (dg_rr_request->measure_cpu) {
+    dg_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_dg_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  unlink(myaddr_un.sun_path);
+  
+}
+ /* this routine implements the receive (netserver) side of a STREAM_RR */
+ /* test */
+
+void
+recv_stream_rr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct	sockaddr_un        myaddr_un,
+  peeraddr_un;
+  SOCKET s_listen,s_data;
+  int 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received = 0;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	stream_rr_request_struct	*stream_rr_request;
+  struct	stream_rr_response_struct	*stream_rr_response;
+  struct	stream_rr_results_struct	*stream_rr_results;
+  
+  stream_rr_request = 
+    (struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
+  stream_rr_response =
+    (struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
+  stream_rr_results =
+    (struct stream_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_stream_rr: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_stream_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = STREAM_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_stream_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_stream_rr: requested recv alignment of %d offset %d\n",
+	    stream_rr_request->recv_alignment,
+	    stream_rr_request->recv_offset);
+    fprintf(where,"recv_stream_rr: requested send alignment of %d offset %d\n",
+	    stream_rr_request->send_alignment,
+	    stream_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   stream_rr_request->response_size,
+				   stream_rr_request->send_alignment,
+				   stream_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   stream_rr_request->request_size,
+				   stream_rr_request->recv_alignment,
+				   stream_rr_request->recv_offset);
+
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_un,
+	sizeof(myaddr_un));
+  myaddr_un.sun_family      = AF_UNIX;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_stream_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_unix_socket expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size_req = stream_rr_request->send_buf_size;
+  lsr_size_req = stream_rr_request->recv_buf_size;
+  
+  s_listen = create_unix_socket(AF_UNIX,
+				SOCK_STREAM);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
+  if (bind(s_listen,
+	   (struct sockaddr *)&myaddr_un,
+	   sizeof(myaddr_un)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    unlink(myaddr_un.sun_path);
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Now myaddr_un contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  strcpy(stream_rr_response->unix_path,myaddr_un.sun_path);
+  netperf_response.content.serv_errno   = 0;
+  
+  /* But wait, there's more. If the initiator wanted cpu measurements, */
+  /* then we must call the calibrate routine, which will return the max */
+  /* rate back to the initiator. If the CPU was not to be measured, or */
+  /* something went wrong with the calibration, we will return a 0.0 to */
+  /* the initiator. */
+  
+  stream_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (stream_rr_request->measure_cpu) {
+    stream_rr_response->measure_cpu = 1;
+    stream_rr_response->cpu_rate = calibrate_local_cpu(stream_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  stream_rr_response->send_buf_size = lss_size;
+  stream_rr_response->recv_buf_size = lsr_size;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_un);
+  
+  if ((s_data = accept(s_listen,
+		       (struct sockaddr *)&peeraddr_un,
+		       &addrlen)) == INVALID_SOCKET) {
+    /* Let's just punt. The remote will be given some information */
+    close(s_listen);
+    
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_stream_rr: accept completes on the data connection.\n");
+    fflush(where);
+  }
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(stream_rr_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (stream_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(stream_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = stream_rr_request->test_length * -1;
+  }
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining	= stream_rr_request->request_size;
+    
+    /* receive the request from the other side */
+    if (debug) {
+      fprintf(where,"about to receive for trans %d\n",trans_received);
+      fprintf(where,"temp_message_ptr is %p\n",temp_message_ptr);
+      fflush(where);
+    }
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	if (errno == EINTR) {
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	}
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+      if (debug) {
+	fprintf(where,"just received for trans %d\n",trans_received);
+	fflush(where);
+      }
+    }
+
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      fprintf(where,"yo5\n");
+      fflush(where);						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if (debug) {
+      fprintf(where,"about to send for trans %d\n",trans_received);
+      fflush(where);
+    }
+    if((bytes_sent=send(s_data,
+			send_ring->buffer_ptr,
+			stream_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (errno == EINTR) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 997;
+      send_response();
+      exit(1);
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_stream_rr: Transaction %d complete\n",
+	      trans_received);
+      fflush(where);
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(stream_rr_request->measure_cpu,&elapsed_time);
+  
+  if (timed_out) {
+    /* we ended the test by time, which was at least 2 seconds */
+    /* longer than we wanted to run. so, we want to subtract */
+    /* PAD_TIME from the elapsed_time. */
+    elapsed_time -= PAD_TIME;
+  }
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_stream_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  stream_rr_results->bytes_received	= (trans_received * 
+					   (stream_rr_request->request_size + 
+					    stream_rr_request->response_size));
+  stream_rr_results->trans_received	= trans_received;
+  stream_rr_results->elapsed_time	= elapsed_time;
+  if (stream_rr_request->measure_cpu) {
+    stream_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_stream_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  unlink(myaddr_un.sun_path);
+}
+
+void
+print_unix_usage()
+{
+
+  fwrite(unix_usage, sizeof(char), strlen(unix_usage), stdout);
+  exit(1);
+
+}
+void
+scan_unix_args(int argc, char *argv[])
+{
+#define UNIX_ARGS "hm:M:p:r:s:S:"
+  extern char	*optarg;	  /* pointer to option string	*/
+  
+  int		c;
+  
+  char	
+    arg1[BUFSIZ],  /* argument holders		*/
+    arg2[BUFSIZ];
+  
+  init_test_vars();
+
+  if (no_control) {
+    fprintf(where,
+	    "The UNIX tests do not know how to run with no control connection\n");
+    exit(-1);
+  }
+
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form "first," (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, UNIX_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case 'h':
+      print_unix_usage();
+      exit(1);
+    case 'p':
+      /* set the path prefix (directory) that should be used for the */
+      /* pipes. at some point, there should be some error checking. */
+      strcpy(path_prefix,optarg);
+      break;
+    case 's':
+      /* set local socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	lss_size_req = atoi(arg1);
+      if (arg2[0])
+	lsr_size_req = atoi(arg2);
+      break;
+    case 'S':
+      /* set remote socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	rss_size = atoi(arg1);
+      if (arg2[0])
+	rsr_size = 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 'm':
+      /* set the send size */
+      send_size = atoi(optarg);
+      break;
+    case 'M':
+      /* set the recv size */
+      recv_size = atoi(optarg);
+      break;
+    };
+  }
+}
+#endif /* WANT_UNIX */ 
diff --git a/nettest_unix.h b/nettest_unix.h
new file mode 100644
index 0000000..8eb393b
--- /dev/null
+++ b/nettest_unix.h
@@ -0,0 +1,198 @@
+/*
+        Copyright (C) 1993-2004 Hewlett-Packard Company
+*/
+
+ /* This file contains the test-specific definitions for netperf's */
+ /* DLPI tests */
+
+struct	stream_stream_request_struct {
+  int	recv_buf_size;
+  int	send_buf_size;
+  int	receive_size;   /* how many bytes do we want to */
+                        /* receive at one time? */
+  int	recv_alignment; /* what is the alignment of the */
+                        /* receive buffer? */
+  int	recv_offset;    /* and at what offset from that */
+                        /* alignment? */
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int	measure_cpu;	/* does the client want server cpu */
+                        /* utilization measured? */
+  float	cpu_rate;	/* do we know how fast the cpu is */
+                        /* already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct	stream_stream_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	receive_size;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct stream_stream_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   num_cpus;
+};
+
+struct	stream_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct	stream_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  float	cpu_rate;		/* could we measure	*/
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path to the dlpi device */
+};
+
+struct stream_rr_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  int	trans_received;	/* not ignored  */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   num_cpus;
+};
+
+struct	dg_stream_request_struct {
+  int	recv_buf_size;
+  int	message_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	measure_cpu;
+  float	cpu_rate;
+  int	test_length;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive copies? */
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct	dg_stream_response_struct {
+  int	recv_buf_size;
+  int	send_buf_size;
+  int	measure_cpu;
+  int	test_length;
+  float	cpu_rate;
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct	dg_stream_results_struct {
+  int	messages_recvd;
+  int	bytes_received;
+  float	elapsed_time;
+  float	cpu_util;
+  int   num_cpus;
+};
+
+
+struct	dg_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct	dg_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+  int   path_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  unix_path[32]; /* the path */
+};
+
+struct dg_rr_results_struct {
+  int	bytes_received;	/* ignored initially */
+  int	recv_calls;	/* ignored initially */
+  int	trans_received;	/* not ignored  */
+  float	elapsed_time;	/* how long the test ran */
+  float	cpu_util;	/* -1 if not measured */
+  float	serv_dem;	/* -1 if not measured */
+  int   num_cpus;
+};
+
+extern void scan_unix_args(int argc, char *argv[]);
+
+extern void send_stream_stream(char remote_host[]);
+extern void send_stream_rr(char remote_host[]);
+extern void send_dg_stream(char remote_host[]);
+extern void send_dg_rr(char remote_host[]);
+
+extern void recv_stream_stream();
+extern void recv_stream_rr();
+extern void recv_dg_stream();
+extern void recv_dg_rr();
diff --git a/nettest_xti.c b/nettest_xti.c
new file mode 100644
index 0000000..9d27f25
--- /dev/null
+++ b/nettest_xti.c
@@ -0,0 +1,6026 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WANT_XTI
+#ifndef lint
+char	nettest_xti_id[]="\
+@(#)nettest_xti.c (c) Copyright 1995-2007 Hewlett-Packard Co. Version 2.4.3";
+#else
+#define DIRTY
+#define WANT_HISTOGRAM
+#define WANT_INTERVALS
+#endif /* lint */
+/****************************************************************/
+/*								*/
+/*	nettest_xti.c						*/
+/*								*/
+/*      the XTI args parsing routine...                         */
+/*                                                              */
+/*      scan_xti_args()                                         */
+/*                                                              */
+/*	the actual test routines...				*/
+/*								*/
+/*	send_xti_tcp_stream()	perform a tcp stream test	*/
+/*	recv_xti_tcp_stream()					*/
+/*	send_xti_tcp_rr()	perform a tcp request/response	*/
+/*	recv_xti_tcp_rr()					*/
+/*      send_xti_tcp_conn_rr()  an RR test including connect    */
+/*      recv_xti_tcp_conn_rr()                                  */
+/*	send_xti_udp_stream()	perform a udp stream test	*/
+/*	recv_xti_udp_stream()					*/
+/*	send_xti_udp_rr()	perform a udp request/response	*/
+/*	recv_xti_udp_rr()					*/
+/*								*/
+/****************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif 
+
+#include <sys/types.h>
+#include <fcntl.h>
+#ifndef WIN32
+#include <sys/ipc.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <errno.h>
+#include <signal.h>
+#else /* WIN32 */
+#include <process.h>
+#include <winsock2.h>
+#include <windows.h>
+#endif /* WIN32 */
+#include <stdio.h>
+#include <time.h>
+#include <malloc.h>
+ /* xti.h should be included *after* in.h because there are name */
+ /* conflicts!( Silly standards people... raj 2/95 fortuenately, the */
+ /* confilcts are on IP_TOP and IP_TTL, whcih netperf does not yet use */
+#include <xti.h>
+
+#include "netlib.h"
+#include "netsh.h"
+#include "nettest_xti.h"
+
+#ifdef WANT_HISTOGRAM
+#ifdef __sgi
+#include <sys/time.h>
+#endif /* __sgi */
+#include "hist.h"
+#endif /* WANT_HISTOGRAM */
+
+
+
+ /* these variables are specific to the XTI sockets tests. declare */
+ /* them static to make them global only to this file. */
+
+static int	
+  rss_size,		/* remote socket send buffer size	*/
+  rsr_size,		/* remote socket recv buffer size	*/
+  lss_size,		/* local  socket send buffer size 	*/
+  lsr_size,		/* local  socket recv buffer size 	*/
+  req_size = 1,		/* request size                   	*/
+  rsp_size = 1,		/* response size			*/
+  send_size,		/* how big are individual sends		*/
+  recv_size;		/* how big are individual receives	*/
+
+static  int   confidence_iteration;
+static  char  local_cpu_method;
+static  char  remote_cpu_method;
+
+ /* different options for the xti				*/
+
+static int
+  loc_nodelay,		/* don't/do use NODELAY	locally		*/
+  rem_nodelay,		/* don't/do use NODELAY remotely	*/
+  loc_sndavoid,		/* avoid send copies locally		*/
+  loc_rcvavoid,		/* avoid recv copies locally		*/
+  rem_sndavoid,		/* avoid send copies remotely		*/
+  rem_rcvavoid;		/* avoid recv_copies remotely		*/
+
+static struct t_info info_struct;
+
+#ifdef WANT_HISTOGRAM
+#ifdef HAVE_GETHRTIME
+hrtime_t time_one;
+hrtime_t time_two;
+#else
+static struct timeval time_one;
+static struct timeval time_two;
+#endif /* HAVE_GETHRTIME */
+static HIST time_hist;
+#endif /* WANT_HISTOGRAM */
+
+static char loc_xti_device[32] = "/dev/tcp";
+static char rem_xti_device[32] = "/dev/tcp";
+
+static int  xti_flags = 0;
+
+char xti_usage[] = "\n\
+Usage: netperf [global options] -- [test options] \n\
+\n\
+TCP/UDP XTI API Test Options:\n\
+    -D [L][,R]        Set XTI_TCP_NODELAY locally and/or remotely (XTI_TCP_*)\n\
+    -h                Display this text\n\
+    -m bytes          Set the send size (XTI_TCP_STREAM, XTI_UDP_STREAM)\n\
+    -M bytes          Set the recv size (XTI_TCP_STREAM, XTI_UDP_STREAM)\n\
+    -r bytes          Set request size (XTI_TCP_RR, XTI_UDP_RR)\n\
+    -R bytes          Set response size (XTI_TCP_RR, XTI_UDP_RR)\n\
+    -s send[,recv]    Set local socket send/recv buffer sizes\n\
+    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
+    -X dev[,dev]      Set the local/remote XTI device file name\n\
+\n\
+For those options taking two parms, at least one must be specified;\n\
+specifying one value without a comma will set both parms to that\n\
+value, specifying a value with a leading comma will set just the second\n\
+parm, a value with a trailing comma will set just the first. To set\n\
+each parm to unique values, specify both and separate them with a\n\
+comma.\n"; 
+     
+
+ /* This routine is intended to retrieve interesting aspects of tcp */
+ /* for the data connection. at first, it attempts to retrieve the */
+ /* maximum segment size. later, it might be modified to retrieve */
+ /* other information, but it must be information that can be */
+ /* retrieved quickly as it is called during the timing of the test. */
+ /* for that reason, a second routine may be created that can be */
+ /* called outside of the timing loop */
+void
+get_xti_info(socket, info_struct)
+     int socket;
+     struct t_info *info_struct;
+{
+
+}
+
+
+ /* This routine will create a data (listen) socket with the apropriate */
+ /* options set and return it to the caller. this replaces all the */
+ /* duplicate code in each of the test routines and should help make */
+ /* things a little easier to understand. since this routine can be */
+ /* called by either the netperf or netserver programs, all output */
+ /* should be directed towards "where." family is generally AF_INET, */
+ /* and type will be either SOCK_STREAM or SOCK_DGRAM */
+SOCKET
+create_xti_endpoint(char *name)
+{
+
+  SOCKET temp_socket;
+
+  struct t_optmgmt *opt_req;  /* we request an option */
+  struct t_optmgmt *opt_ret;  /* it tells us what we got */
+
+  /* we use this to pass-in BSD-like socket options through t_optmgmt. */
+  /* it ends up being about as clear as mud. raj 2/95 */
+  struct sock_option {
+    struct t_opthdr myopthdr;
+    long value;
+  } *sock_option;
+
+  if (debug) {
+    fprintf(where,"create_xti_endpoint: attempting to open %s\n",
+	    name);
+    fflush(where);
+  }
+
+  /*set up the data socket                        */
+  temp_socket = t_open(name,O_RDWR,NULL);
+  
+  if (temp_socket == INVALID_SOCKET){
+    fprintf(where,
+	    "netperf: create_xti_endpoint: t_open %s: errno %d t_errno %d\n",
+	    name,
+	    errno,
+	    t_errno);
+    fflush(where);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,"create_xti_endpoint: socket %d obtained...\n",temp_socket);
+    fflush(where);
+  }
+  
+  /* allocate what we need for option mgmt */
+  if ((opt_req = (struct t_optmgmt *)t_alloc(temp_socket,T_OPTMGMT,T_ALL)) == 
+      NULL) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: t_alloc: opt_req errno %d\n",
+	    errno);
+    fflush(where);
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,
+	    "create_xti_endpoint: opt_req->opt.buf %x maxlen %d len %d\n",
+	    opt_req->opt.buf,
+	    opt_req->opt.maxlen,
+	    opt_req->opt.len);
+    
+    fflush(where);
+  }
+
+  if ((opt_ret = (struct t_optmgmt *) t_alloc(temp_socket,T_OPTMGMT,T_ALL)) ==
+      NULL) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: t_alloc: opt_ret errno %d\n",
+	    errno);
+    fflush(where);
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,
+	    "create_xti_endpoint: opt_ret->opt.buf %x maxlen %d len %d\n",
+	    opt_ret->opt.buf,
+	    opt_ret->opt.maxlen,
+	    opt_ret->opt.len);
+    fflush(where);
+  }
+
+  /* Modify the local socket size. The reason we alter the send buffer */
+  /* size here rather than when the connection is made is to take care */
+  /* of decreases in buffer size. Decreasing the window size after */
+  /* connection establishment is a 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 XTI_SNDBUF
+  if (lss_size > 0) {
+    /* we want to "negotiate" the option */
+    opt_req->flags = T_NEGOTIATE;
+  }
+  else {
+    /* we want to accept the default, and know what it is. I assume */
+    /* that when nothing has been changed, that T_CURRENT will return */
+    /* the same as T_DEFAULT raj 3/95 */
+    opt_req->flags = T_CURRENT;
+  }
+
+  /* the first part is for the netbuf that holds the option we want */
+  /* to negotiate or check */
+  /* the buffer of the netbuf points at the socket options structure */
+  
+  /* we assume that the t_alloc call allocated a buffer that started */
+  /* on a proper alignment */
+  sock_option = (struct sock_option *)opt_req->opt.buf;
+  
+  /* and next, set the fields in the sock_option structure */
+  sock_option->myopthdr.level = XTI_GENERIC;
+  sock_option->myopthdr.name  = XTI_SNDBUF;
+  sock_option->myopthdr.len   = sizeof(struct t_opthdr) + sizeof(long);
+  sock_option->value        = lss_size;
+  
+  opt_req->opt.len          = sizeof(struct t_opthdr) + sizeof(long);
+  
+  /* now, set-up the stuff to return the value in the end */
+  /* we assume that the t_alloc call allocated a buffer that started */
+  /* on a proper alignment */
+  sock_option = (struct sock_option *)opt_ret->opt.buf;
+  
+  /* finally, call t_optmgmt. clear as mud. */
+  if (t_optmgmt(temp_socket,opt_req,opt_ret) == -1) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: XTI_SNDBUF option: t_errno %d\n",
+	    t_errno);
+    fflush(where);
+    exit(1);
+  }
+
+  if (sock_option->myopthdr.status == T_SUCCESS) {
+    lss_size = sock_option->value;
+  }
+  else {
+    fprintf(where,"create_xti_endpoint: XTI_SNDBUF option status 0x%.4x",
+	    sock_option->myopthdr.status);
+    fprintf(where," value %d\n",
+	    sock_option->value);
+    fflush(where);
+    lss_size = -1;
+  }
+
+  if (lsr_size > 0) {
+    /* we want to "negotiate" the option */
+    opt_req->flags = T_NEGOTIATE;
+  }
+  else {
+    /* we want to accept the default, and know what it is. I assume */
+    /* that when nothing has been changed, that T_CURRENT will return */
+    /* the same as T_DEFAULT raj 3/95 */
+    opt_req->flags = T_CURRENT;
+  }
+  
+  /* the first part is for the netbuf that holds the option we want */
+  /* to negotiate or check */
+  /* the buffer of the netbuf points at the socket options structure */
+  
+  /* we assume that the t_alloc call allocated a buffer that started */
+  /* on a proper alignment */
+  sock_option = (struct sock_option *)opt_req->opt.buf;
+  
+  /* and next, set the fields in the sock_option structure */
+  sock_option->myopthdr.level = XTI_GENERIC;
+  sock_option->myopthdr.name  = XTI_RCVBUF;
+  sock_option->myopthdr.len   = sizeof(struct t_opthdr) + sizeof(long);
+  sock_option->value        = lsr_size;
+  
+  opt_req->opt.len          = sizeof(struct t_opthdr) + sizeof(long);
+  
+  /* now, set-up the stuff to return the value in the end */
+  /* we assume that the t_alloc call allocated a buffer that started */
+  /* on a proper alignment */
+  sock_option = (struct sock_option *)opt_ret->opt.buf;
+  
+  /* finally, call t_optmgmt. clear as mud. */
+  if (t_optmgmt(temp_socket,opt_req,opt_ret) == -1) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: XTI_RCVBUF option: t_errno %d\n",
+	    t_errno);
+    fflush(where);
+    exit(1);
+  }
+  lsr_size = sock_option->value;
+
+  /* this needs code */
+
+  if (debug) {
+    fprintf(where,"netperf: create_xti_endpoint: socket sizes determined...\n");
+    fprintf(where,"                       send: %d recv: %d\n",
+	    lss_size,lsr_size);
+    fflush(where);
+  }
+  
+#else /* XTI_SNDBUF */
+  
+  lss_size = -1;
+  lsr_size = -1;
+  
+#endif /* XTI_SNDBUF */
+
+  /* now, we may wish to enable the copy avoidance features on the */
+  /* local system. of course, this may not be possible... */
+  
+  if (loc_rcvavoid) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: Could not enable receive copy avoidance");
+    fflush(where);
+    loc_rcvavoid = 0;
+  }
+
+  if (loc_sndavoid) {
+    fprintf(where,
+	    "netperf: create_xti_endpoint: Could not enable send copy avoidance");
+    fflush(where);
+    loc_sndavoid = 0;
+  }
+  
+  /* Now, we will see about setting the TCP_NODELAY flag on the local */
+  /* socket. We will only do this for those systems that actually */
+  /* support the option. If it fails, note the fact, but keep going. */
+  /* If the user tries to enable TCP_NODELAY on a UDP socket, this */
+  /* will cause an error to be displayed */
+  
+#ifdef TCP_NODELAY
+  if ((strcmp(test_name,"XTI_TCP_STREAM") == 0) ||
+      (strcmp(test_name,"XTI_TCP_RR") == 0) ||
+      (strcmp(test_name,"XTI_TCP_CRR") == 0)) {
+    if (loc_nodelay) {
+      /* we want to "negotiate" the option */
+      opt_req->flags = T_NEGOTIATE;
+    }
+    else {
+      /* we want to accept the default, and know what it is. I assume */
+      /* that when nothing has been changed, that T_CURRENT will return */
+      /* the same as T_DEFAULT raj 3/95 */
+      opt_req->flags = T_CURRENT;
+    }
+    
+    /* the first part is for the netbuf that holds the option we want */
+    /* to negotiate or check the buffer of the netbuf points at the */
+    /* socket options structure */ 
+    
+    /* we assume that the t_alloc call allocated a buffer that started */
+    /* on a proper alignment */
+    sock_option = (struct sock_option *)opt_req->opt.buf;
+    
+    /* and next, set the fields in the sock_option structure */
+    sock_option->myopthdr.level = INET_TCP;
+    sock_option->myopthdr.name  = TCP_NODELAY;
+    sock_option->myopthdr.len   = sizeof(struct t_opthdr) + sizeof(long);
+    sock_option->value          = T_YES;
+    
+    opt_req->opt.len          = sizeof(struct t_opthdr) + sizeof(long);
+    
+    /* now, set-up the stuff to return the value in the end */
+    /* we assume that the t_alloc call allocated a buffer that started */
+    /* on a proper alignment */
+    sock_option = (struct sock_option *)opt_ret->opt.buf;
+    
+    /* finally, call t_optmgmt. clear as mud. */
+    if (t_optmgmt(temp_socket,opt_req,opt_ret) == -1) {
+      fprintf(where,
+	      "create_xti_endpoint: TCP_NODELAY option: errno %d t_errno %d\n",
+	      errno,
+	      t_errno);
+      fflush(where);
+      exit(1);
+    }
+    loc_nodelay = sock_option->value;
+  }
+#else /* TCP_NODELAY */
+  
+  loc_nodelay = 0;
+  
+#endif /* TCP_NODELAY */
+
+  return(temp_socket);
+
+}
+
+
+/* This routine implements the TCP unidirectional data transfer test */
+/* (a.k.a. stream) for the xti interface. It receives its */
+/* parameters via global variables from the shell and writes its */
+/* output to the standard output. */
+
+
+void 
+send_xti_tcp_stream(char remote_host[])
+{
+  
+  char *tput_title = "\
+Recv   Send    Send                          \n\
+Socket Socket  Message  Elapsed              \n\
+Size   Size    Size     Time     Throughput  \n\
+bytes  bytes   bytes    secs.    %s/sec  \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 =
+    "%6d %6d %6d    %-6.2f   %7.2f   \n";
+  
+  char *cpu_title = "\
+Recv   Send    Send                          Utilization       Service Demand\n\
+Socket Socket  Message  Elapsed              Send     Recv     Send    Recv\n\
+Size   Size    Size     Time     Throughput  local    remote   local   remote\n\
+bytes  bytes   bytes    secs.    %-8.8s/s  %% %c      %% %c      us/KB   us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+
+  char *cpu_fmt_1 =
+    "%6d %6d %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";
+
+  char *ksink_fmt2 = "\n\
+Maximum\n\
+Segment\n\
+Size (bytes)\n\
+%6d\n";
+  
+  
+  float			elapsed_time;
+  
+#ifdef WANT_INTERVALS
+  int interval_count;
+  sigset_t signal_set;
+#endif
+  
+  /* what we want is to have a buffer space that is at least one */
+  /* send-size greater than our send window. this will insure that we */
+  /* are never trying to re-use a buffer that may still be in the hands */
+  /* of the transport. This buffer will be malloc'd after we have found */
+  /* the size of the local senc socket buffer. We will want to deal */
+  /* with alignment and offset concerns as well. */
+  
+  int	*message_int_ptr;
+
+  struct ring_elt *send_ring;
+  
+  int len;
+  unsigned int nummessages;
+  SOCKET send_socket;
+  int bytes_remaining;
+  int tcp_mss = -1;  /* possibly uninitialized on printf far below */
+
+  /* with links like fddi, one can send > 32 bits worth of bytes */
+  /* during a test... ;-) at some point, this should probably become a */
+  /* 64bit integral type, but those are not entirely common yet */
+
+  double	bytes_sent;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+
+  double	thruput;
+  
+  /* some addressing information */
+  struct	hostent	        *hp;
+  struct	sockaddr_in	server;
+  unsigned      int             addr;
+
+  struct t_call server_call;
+  
+  struct	xti_tcp_stream_request_struct	*xti_tcp_stream_request;
+  struct	xti_tcp_stream_response_struct	*xti_tcp_stream_response;
+  struct	xti_tcp_stream_results_struct	*xti_tcp_stream_result;
+  
+  xti_tcp_stream_request  = 
+    (struct xti_tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_stream_response =
+    (struct xti_tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_stream_result   = 
+    (struct xti_tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  /* it would seem that while HP-UX will allow an IP address (as a */
+  /* string) in a call to gethostbyname, other, less enlightened */
+  /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
+  /* order changed to check for IP address first. raj 7/96 */
+
+  if ((addr = inet_addr(remote_host)) == SOCKET_ERROR) {
+    /* it was not an IP address, try it as a name */
+    if ((hp = gethostbyname(remote_host)) == NULL) {
+      /* we have no idea what it is */
+      fprintf(where,
+	      "establish_control: could not resolve the destination %s\n",
+	      remote_host);
+      fflush(where);
+      exit(1);
+    }
+    else {
+      /* it was a valid remote_host */
+      bcopy(hp->h_addr,
+	    (char *)&server.sin_addr,
+	    hp->h_length);
+      server.sin_family = hp->h_addrtype;
+    }
+  }
+  else {
+    /* it was a valid IP address */
+    server.sin_addr.s_addr = addr;
+    server.sin_family = AF_INET;
+  }    
+  
+  if ( print_headers ) {
+    /* we want to have some additional, interesting information in */
+    /* the headers. we know some of it here, but not all, so we will */
+    /* only print the test title here and will print the results */
+    /* titles after the test is finished */
+    fprintf(where,"XTI TCP STREAM TEST");
+    fprintf(where," to %s", remote_host);
+    if (iteration_max > 1) {
+      fprintf(where,
+	      " : +/-%3.1f%% @ %2d%% conf.",
+	      interval/0.02,
+	      confidence_level);
+      }
+    if (loc_nodelay || rem_nodelay) {
+      fprintf(where," : nodelay");
+    }
+    if (loc_sndavoid || 
+	loc_rcvavoid ||
+	rem_sndavoid ||
+	rem_rcvavoid) {
+      fprintf(where," : copy avoidance");
+    }
+#ifdef WANT_HISTOGRAM
+    fprintf(where," : histogram");
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS
+    fprintf(where," : interval");
+#endif /* WANT_INTERVALS */
+#ifdef DIRTY 
+    fprintf(where," : dirty data");
+#endif /* DIRTY */
+    fprintf(where,"\n");
+  }
+
+  send_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    
+    nummessages    =	0;
+    bytes_sent     =	0.0;
+    times_up       = 	0;
+    
+    /*set up the data socket                        */
+    send_socket = create_xti_endpoint(loc_xti_device);
+    
+    if (send_socket == INVALID_SOCKET) {
+      perror("netperf: send_xti_tcp_stream: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_xti_tcp_stream: send_socket obtained...\n");
+    }
+    
+    /* it would seem that with XTI, there is no implicit bind on a */
+    /* connect, so we have to make a call to t_bind. this is not */
+    /* terribly convenient, but I suppose that "standard is better */
+    /* than better" :) raj 2/95 */
+
+    if (t_bind(send_socket, NULL, NULL) == SOCKET_ERROR) {
+      t_error("send_xti_tcp_stream: t_bind");
+      exit(1);
+    }
+      
+    /* at this point, we have either retrieved the socket buffer sizes, */
+    /* or have tried to set them, so now, we may want to set the send */
+    /* size based on that (because the user either did not use a -m */
+    /* option, or used one with an argument of 0). If the socket buffer */
+    /* size is not available, we will set the send size to 4KB - no */
+    /* particular reason, just arbitrary... */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer ring with the requested alignment and offset. */
+    /* note also that we have allocated a quantity */
+    /* of memory that is at least one send-size greater than our socket */
+    /* buffer size. We want to be sure that there are at least two */
+    /* buffers allocated - this can be a bit of a problem when the */
+    /* send_size is bigger than the socket size, so we must check... the */
+    /* user may have wanted to explicitly set the "width" of our send */
+    /* buffers, we should respect that wish... */
+
+    if (send_width == 0) {
+      send_width = (lss_size/send_size) + 1;
+      if (send_width == 1) send_width++;
+    }
+    
+    if (send_ring == NULL) {
+      /* only allocate the send ring once. this is a networking test, */
+      /* not a memory allocation test. this way, we do not need a */
+      /* deallocate_buffer_ring() routine, and I don't feel like */
+      /* writing one anyway :) raj 11/94 */
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    /* If the user has requested cpu utilization measurements, we must */
+    /* calibrate the cpu(s). We will perform this task within the tests */
+    /* themselves. If the user has specified the cpu rate, then */
+    /* calibrate_local_cpu will return rather quickly as it will have */
+    /* nothing to do. If local_cpu_rate is zero, then we will go through */
+    /* all the "normal" calibration stuff and return the rate back. */
+    
+    if (local_cpu_usage) {
+      local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+    }
+    
+    /* Tell the remote end to do a listen. The server alters the socket */
+    /* paramters on the other side at this point, hence the reason for */
+    /* all the values being passed in the setup message. If the user did */
+    /* not specify any of the parameters, they will be passed as 0, which */
+    /* will indicate to the remote that no changes beyond the system's */
+    /* default should be used. Alignment is the exception, it will */
+    /* default to 1, which will be no alignment alterations. */
+    
+    netperf_request.content.request_type          = DO_XTI_TCP_STREAM;
+    xti_tcp_stream_request->send_buf_size  = rss_size;
+    xti_tcp_stream_request->recv_buf_size  = rsr_size;
+    xti_tcp_stream_request->receive_size   = recv_size;
+    xti_tcp_stream_request->no_delay       = rem_nodelay;
+    xti_tcp_stream_request->recv_alignment = remote_recv_align;
+    xti_tcp_stream_request->recv_offset    = remote_recv_offset;
+    xti_tcp_stream_request->measure_cpu    = remote_cpu_usage;
+    xti_tcp_stream_request->cpu_rate       = remote_cpu_rate;
+    if (test_time) {
+      xti_tcp_stream_request->test_length  = test_time;
+    }
+    else {
+      xti_tcp_stream_request->test_length  = test_bytes;
+    }
+    xti_tcp_stream_request->so_rcvavoid    = rem_rcvavoid;
+    xti_tcp_stream_request->so_sndavoid    = rem_sndavoid;
+
+    strcpy(xti_tcp_stream_request->xti_device, rem_xti_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 *) xti_tcp_stream_request->xti_device;
+      lastword = initword + ((strlen(rem_xti_device) + 3) / 4);
+      
+      for (charword = initword;
+	   charword < lastword;
+	   charword++) {
+	
+	*charword = ntohl(*charword);
+      }
+    }
+#endif /* __alpha */
+    
+#ifdef DIRTY
+    xti_tcp_stream_request->dirty_count         = rem_dirty_count;
+    xti_tcp_stream_request->clean_count         = rem_clean_count;
+#endif /* DIRTY */
+    
+    
+    if (debug > 1) {
+      fprintf(where,
+              "netperf: send_xti_tcp_stream: 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");
+      rsr_size         = xti_tcp_stream_response->recv_buf_size;
+      rss_size         = xti_tcp_stream_response->send_buf_size;
+      rem_nodelay      = xti_tcp_stream_response->no_delay;
+      remote_cpu_usage = xti_tcp_stream_response->measure_cpu;
+      remote_cpu_rate  = xti_tcp_stream_response->cpu_rate;
+
+      /* we have to make sure that the server port number is in */
+      /* network order */
+      server.sin_port   = (short)xti_tcp_stream_response->data_port_number;
+      server.sin_port   = htons(server.sin_port); 
+      rem_rcvavoid      = xti_tcp_stream_response->so_rcvavoid;
+      rem_sndavoid      = xti_tcp_stream_response->so_sndavoid;
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      perror("netperf: remote error");
+      
+      exit(1);
+    }
+    
+    /*Connect up to the remote port on the data socket  */
+    memset (&server_call, 0, sizeof(server_call));
+    server_call.addr.maxlen = sizeof(struct sockaddr_in);
+    server_call.addr.len    = sizeof(struct sockaddr_in);
+    server_call.addr.buf    = (char *)&server;
+
+    if (t_connect(send_socket, 
+		  &server_call,
+		  NULL) == INVALID_SOCKET){
+      t_error("netperf: send_xti_tcp_stream: data socket connect failed");
+      printf(" port: %d\n",ntohs(server.sin_port));
+      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;
+      /* in previous revisions, we had the same code repeated throught */
+      /* all the test suites. this was unnecessary, and meant more */
+      /* work for me when I wanted to switch to POSIX signals, so I */
+      /* have abstracted this out into a routine in netlib.c. if you */
+      /* are experiencing signal problems, you might want to look */
+      /* there. raj 11/94 */
+      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);
+    
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+              "send_xti_tcp_stream: unable to get sigmask errno %d\n",
+              errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+
+    /* before we start, initialize a few variables */
+
+    /* 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. */
+    
+    while ((!times_up) || (bytes_remaining > 0)) {
+      
+#ifdef DIRTY
+      /* we want to dirty some number of consecutive integers in the buffer */
+      /* we are about to send. we may also want to bring some number of */
+      /* them cleanly into the cache. The clean ones will follow any dirty */
+      /* ones into the cache. at some point, we might want to replace */
+      /* the rand() call with something from a table to reduce our call */
+      /* overhead during the test, but it is not a high priority item. */
+      access_buffer(send_ring->buffer_ptr,
+		    send_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      /* timestamp just before we go into send and then again just after */
+      /* we come out raj 8/94 */
+      HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+      
+      if((len=t_snd(send_socket,
+		    send_ring->buffer_ptr,
+		    send_size,
+		    0)) != send_size) {
+        if ((len >=0) || (errno == EINTR)) {
+          /* the test was interrupted, must be the end of test */
+          break;
+        }
+        fprintf(where,
+		"send_xti_tcp_stream: t_snd: errno %d t_errno %d t_look 0x%.4x\n",
+		errno,
+		t_errno,
+		t_look(send_socket));
+	fflush(where);
+        exit(1);
+      }
+
+#ifdef WANT_HISTOGRAM
+      /* timestamp the exit from the send call and update the histogram */
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */      
+
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+        units_this_tick += send_size;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+        /* out */
+        if (debug) {
+          fprintf(where,"about to suspend\n");
+          fflush(where);
+        }
+        if (sigsuspend(&signal_set) == EFAULT) {
+          fprintf(where,
+                  "send_xti_tcp_stream: fault with signal set!\n");
+          fflush(where);
+          exit(1);
+        }
+        interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...we may also want to wrap back to the "beginning" */
+      /* of the bufferspace, so we will mod the number of messages sent */
+      /* by the send width, and use that to calculate the offset to add */
+      /* to the base pointer. */
+      nummessages++;          
+      send_ring = send_ring->next;
+      if (bytes_remaining) {
+        bytes_remaining -= send_size;
+      }
+    }
+
+    /* The test is over. Flush the buffers to the remote end. We do a */
+    /* graceful release to insure that all data has been taken by the */
+    /* remote. */ 
+
+    /* but first, if the verbosity is greater than 1, find-out what */
+    /* the TCP maximum segment_size was (if possible) */
+    if (verbosity > 1) {
+      tcp_mss = -1;
+      get_xti_info(send_socket,info_struct);
+    }
+    
+    if (t_sndrel(send_socket) == -1) {
+      t_error("netperf: cannot shutdown tcp stream socket");
+      exit(1);
+    }
+    
+    /* hang a t_rcvrel() off the socket to block until the remote has */
+    /* brought all the data up into the application. it will do a */
+    /* t_sedrel to cause a FIN to be sent our way. We will assume that */
+    /* any exit from the t_rcvrel() call is good... raj 2/95 */
+    
+    if (debug > 1) {
+      fprintf(where,"about to hang a receive for graceful release.\n");
+      fflush(where);
+    }
+
+    t_rcvrel(send_socket);
+    
+    /* this call will always give us the elapsed time for the test, and */
+    /* will also store-away the necessaries for cpu utilization */
+    
+    cpu_stop(local_cpu_usage,&elapsed_time);    /* was cpu being */
+                                                /* measured and how */
+                                                /* long did we really */
+                                                /* run? */
+    
+    /* Get the statistics from the remote end. The remote will have */
+    /* calculated service demand and all those interesting things. If it */
+    /* wasn't supposed to care, it will return obvious values. */
+    
+    recv_response();
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+        fprintf(where,"remote results obtained\n");
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      perror("netperf: remote error");
+      
+      exit(1);
+    }
+    
+    /* We now calculate what our thruput was for the test. In the future, */
+    /* we may want to include a calculation of the thruput measured by */
+    /* the remote, but it should be the case that for a 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  = xti_tcp_stream_result->bytes_received;
+
+    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) {
+        
+        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) {
+        
+        remote_cpu_utilization  = xti_tcp_stream_result->cpu_util;
+        remote_service_demand   = calc_service_demand(bytes_sent,
+                                                      0.0,
+                                                      remote_cpu_utilization,
+						      xti_tcp_stream_result->num_cpus);
+      }
+      else {
+        remote_cpu_utilization = -1.0;
+        remote_service_demand  = -1.0;
+      }
+    }    
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization  = -1.0;
+      local_service_demand   = -1.0;
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+                         elapsed_time,
+                         thruput,
+                         local_cpu_utilization,
+                         remote_cpu_utilization,
+                         local_service_demand,
+                         remote_service_demand);
+    
+    
+    confidence_iteration++;
+  }
+
+  /* at this point, we have finished making all the runs that we */
+  /* will be making. so, we should extract what the calcuated values */
+  /* are for all the confidence stuff. we could make the values */
+  /* global, but that seemed a little messy, and it did not seem worth */
+  /* all the mucking with header files. so, we create a routine much */
+  /* like calcualte_confidence, which just returns the mean values. */
+  /* raj 11/94 */
+
+  retrieve_confident_values(&elapsed_time,
+                            &thruput,
+                            &local_cpu_utilization,
+                            &remote_cpu_utilization,
+                            &local_service_demand,
+                            &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(xti_tcp_stream_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+        fprintf(where,
+                cpu_fmt_0,
+                local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      rsr_size,		        /* remote recvbuf size */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      thruput, 		        /* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      rsr_size, 		/* remote recvbuf size */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);/* how fast did it go */
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+   
+    /* this stuff needs to be worked-out in the presence of confidence */
+    /* intervals and multiple iterations of the test... raj 11/94 */
+ 
+    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)xti_tcp_stream_result->recv_calls,
+	    xti_tcp_stream_result->recv_calls);
+    fprintf(where,
+	    ksink_fmt2,
+	    tcp_mss);
+    fflush(where);
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\n\nHistogram of time spent in send() call.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+  
+}
+
+
+/* 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. */
+
+void 
+recv_xti_tcp_stream()
+{
+  
+  struct sockaddr_in myaddr_in, peeraddr_in;
+  struct t_bind      bind_req, bind_resp;
+  struct t_call      call_req;
+
+  SOCKET       s_listen,s_data;
+  int           addrlen;
+  int	        len;
+  unsigned int	receive_calls;
+  float	        elapsed_time;
+  double        bytes_received;
+  
+  struct ring_elt *recv_ring;
+
+  int   *message_int_ptr;
+  int   i;
+  
+  struct xti_tcp_stream_request_struct	*xti_tcp_stream_request;
+  struct xti_tcp_stream_response_struct	*xti_tcp_stream_response;
+  struct xti_tcp_stream_results_struct	*xti_tcp_stream_results;
+  
+  xti_tcp_stream_request	= 
+    (struct xti_tcp_stream_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_stream_response	= 
+    (struct xti_tcp_stream_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_stream_results	= 
+    (struct xti_tcp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_xti_tcp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = XTI_TCP_STREAM_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_stream: requested alignment of %d\n",
+	    xti_tcp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = 0;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_stream: grabbing a socket...\n");
+    fflush(where);
+  }
+  
+  /* create_xti_endpoint expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size = xti_tcp_stream_request->send_buf_size;
+  lsr_size = xti_tcp_stream_request->recv_buf_size;
+  loc_nodelay = xti_tcp_stream_request->no_delay;
+  loc_rcvavoid = xti_tcp_stream_request->so_rcvavoid;
+  loc_sndavoid = xti_tcp_stream_request->so_sndavoid;
+
+#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 *) xti_tcp_stream_request->xti_device;
+    lastword = initword + ((xti_tcp_stream_request->dev_name_len + 3) / 4);
+    
+    for (charword = initword;
+	 charword < lastword;
+	 charword++) {
+      
+      *charword = htonl(*charword);
+    }
+  }
+  
+#endif /* __alpha */
+
+  s_listen = create_xti_endpoint(xti_tcp_stream_request->xti_device);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  bind_req.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_req.addr.len    = sizeof(struct sockaddr_in);
+  bind_req.addr.buf    = (char *)&myaddr_in;
+  bind_req.qlen        = 1;
+
+  bind_resp.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_resp.addr.len    = sizeof(struct sockaddr_in);
+  bind_resp.addr.buf    = (char *)&myaddr_in;
+  bind_resp.qlen        = 1;
+
+  if (t_bind(s_listen,
+	     &bind_req,
+	     &bind_resp) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = t_errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_bind complete port %d\n",
+	    ntohs(myaddr_in.sin_port));
+    fflush(where);
+  }
+  
+  /* what sort of sizes did we end-up with? */
+  if (xti_tcp_stream_request->receive_size == 0) {
+    if (lsr_size > 0) {
+      recv_size = lsr_size;
+    }
+    else {
+      recv_size = 4096;
+    }
+  }
+  else {
+    recv_size = xti_tcp_stream_request->receive_size;
+  }
+  
+  /* we want to set-up our recv_ring in a manner analagous to what we */
+  /* do on the sending side. this is more for the sake of symmetry */
+  /* than for the needs of say copy avoidance, but it might also be */
+  /* more realistic - this way one could conceivably go with a */
+  /* double-buffering scheme when taking the data an putting it into */
+  /* the filesystem or something like that. raj 7/94 */
+
+  if (recv_width == 0) {
+    recv_width = (lsr_size/recv_size) + 1;
+    if (recv_width == 1) recv_width++;
+  }
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   recv_size,
+				   xti_tcp_stream_request->recv_alignment,
+				   xti_tcp_stream_request->recv_offset);
+
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_stream: recv alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  xti_tcp_stream_response->data_port_number = 
+    (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  xti_tcp_stream_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (xti_tcp_stream_request->measure_cpu) {
+    xti_tcp_stream_response->measure_cpu = 1;
+    xti_tcp_stream_response->cpu_rate = 
+      calibrate_local_cpu(xti_tcp_stream_request->cpu_rate);
+  }
+  else {
+    xti_tcp_stream_response->measure_cpu = 0;
+  }
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  xti_tcp_stream_response->send_buf_size = lss_size;
+  xti_tcp_stream_response->recv_buf_size = lsr_size;
+  xti_tcp_stream_response->no_delay = loc_nodelay;
+  xti_tcp_stream_response->so_rcvavoid = loc_rcvavoid;
+  xti_tcp_stream_response->so_sndavoid = loc_sndavoid;
+  xti_tcp_stream_response->receive_size = recv_size;
+
+  send_response();
+  
+  /* Now, let's set-up the socket to listen for connections. for xti, */
+  /* the t_listen call is blocking by default - this is different */
+  /* semantics from BSD - probably has to do with being able to reject */
+  /* a call before an accept */
+  call_req.addr.maxlen = sizeof(struct sockaddr_in);
+  call_req.addr.len    = sizeof(struct sockaddr_in);
+  call_req.addr.buf    = (char *)&peeraddr_in;
+  call_req.opt.maxlen  = 0;
+  call_req.opt.len     = 0;
+  call_req.opt.buf     = NULL;
+  call_req.udata.maxlen= 0;
+  call_req.udata.len   = 0;
+  call_req.udata.buf   = 0;
+
+  if (t_listen(s_listen, &call_req) == -1) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_listen: errno %d t_errno %d\n",
+	    errno,
+	    t_errno);
+    fflush(where);
+    netperf_response.content.serv_errno = t_errno;
+    close(s_listen);
+    send_response();
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_listen complete t_look 0x%.4x\n",
+	    t_look(s_listen));
+    fflush(where);
+  }
+  
+  /* now just rubber stamp the thing. we want to use the same fd? so */
+  /* we will just equate s_data with s_listen. this seems a little */
+  /* hokey to me, but then I'm a BSD biggot still. raj 2/95 */
+  s_data = s_listen;
+  if (t_accept(s_listen,
+	       s_data,
+	       &call_req) == -1) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_accept: errno %d t_errno %d\n",
+	    errno,
+	    t_errno);
+    fflush(where);
+    close(s_listen);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_accept complete t_look 0x%.4x\n",
+	    t_look(s_data));
+    fprintf(where,
+	    "                     remote is %s port %d\n",
+	    inet_ntoa(*(struct in_addr *)&peeraddr_in.sin_addr),
+	    ntohs(peeraddr_in.sin_port));
+    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(xti_tcp_stream_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a t_sndrel, which will */
+  /* return T_LOOK error from the t_recv */
+  
+#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. */
+
+  access_buffer(recv_ring->buffer_ptr,
+		recv_size,
+		xti_tcp_stream_request->dirty_count,
+		xti_tcp_stream_request->clean_count);
+
+#endif /* DIRTY */
+
+  bytes_received = 0;
+  receive_calls  = 0;
+
+  while ((len = t_rcv(s_data,
+		      recv_ring->buffer_ptr,
+		      recv_size,
+		      &xti_flags)) != -1) {
+    bytes_received += len;
+    receive_calls++;
+    
+    /* more to the next buffer in the recv_ring */
+    recv_ring = recv_ring->next;
+    
+#ifdef DIRTY
+
+  access_buffer(recv_ring->buffer_ptr,
+		recv_size,
+		xti_tcp_stream_request->dirty_count,
+		xti_tcp_stream_request->clean_count);
+
+#endif /* DIRTY */
+  }
+  
+  if (t_look(s_data) == T_ORDREL) {
+    /* this is a normal exit path */
+    if (debug) {
+      fprintf(where,
+	      "recv_xti_tcp_stream: t_rcv T_ORDREL indicated\n");
+      fflush(where);
+    }
+  }
+  else {
+    /* something went wrong */
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_rcv: errno %d t_errno %d len %d",
+	    errno,
+	    t_errno,
+	    len);
+    fprintf(where,
+	    " t_look 0x%.4x",
+	    t_look(s_data));
+    fflush(where);
+    netperf_response.content.serv_errno = t_errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* receive the release and let the initiator know that we have */
+  /* received all the data. raj 3/95 */
+
+  if (t_rcvrel(s_data) == -1) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }    
+
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_rcvrel complete\n");
+    fflush(where);
+  }
+
+  if (t_sndrel(s_data) == -1) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: t_sndrel complete\n");
+    fflush(where);
+  }
+
+  cpu_stop(xti_tcp_stream_request->measure_cpu,&elapsed_time);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: got %g bytes\n",
+	    bytes_received);
+    fprintf(where,
+	    "recv_xti_tcp_stream: got %d recvs\n",
+	    receive_calls);
+    fflush(where);
+  }
+  
+  xti_tcp_stream_results->bytes_received	= bytes_received;
+  xti_tcp_stream_results->elapsed_time	= elapsed_time;
+  xti_tcp_stream_results->recv_calls	= receive_calls;
+  
+  if (xti_tcp_stream_request->measure_cpu) {
+    xti_tcp_stream_results->cpu_util	= calc_cpu_util(0.0);
+  };
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_stream: test complete, sending results.\n");
+    fprintf(where,
+	    "                 bytes_received %g receive_calls %d\n",
+	    bytes_received,
+	    receive_calls);
+    fprintf(where,
+	    "                 len %d\n",
+	    len);
+    fflush(where);
+  }
+  
+  xti_tcp_stream_results->cpu_method = cpu_method;
+  send_response();
+
+  /* we are now done with the socket */
+  t_close(s_data);
+
+}
+
+
+ /* this routine implements the sending (netperf) side of the XTI_TCP_RR */
+ /* test. */
+
+void 
+send_xti_tcp_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f  %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	hostent	        *hp;
+  struct	sockaddr_in	server;
+  unsigned      int             addr;
+  
+  struct t_call server_call;
+
+  struct	xti_tcp_rr_request_struct	*xti_tcp_rr_request;
+  struct	xti_tcp_rr_response_struct	*xti_tcp_rr_response;
+  struct	xti_tcp_rr_results_struct	*xti_tcp_rr_result;
+  
+#ifdef WANT_INTERVALS
+  int	interval_count;
+  sigset_t signal_set;
+#endif /* WANT_INTERVALS */
+
+  xti_tcp_rr_request = 
+    (struct xti_tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_rr_response=
+    (struct xti_tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_rr_result	=
+    (struct xti_tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+
+  bzero((char *)&server,
+	sizeof(server));
+  
+  /* it would seem that while HP-UX will allow an IP address (as a */
+  /* string) in a call to gethostbyname, other, less enlightened */
+  /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
+  /* order changed to check for IP address first. raj 7/96 */
+
+  if ((addr = inet_addr(remote_host)) == SOCKET_ERROR) {
+    /* it was not an IP address, try it as a name */
+    if ((hp = gethostbyname(remote_host)) == NULL) {
+      /* we have no idea what it is */
+      fprintf(where,
+	      "establish_control: could not resolve the destination %s\n",
+	      remote_host);
+      fflush(where);
+      exit(1);
+    }
+    else {
+      /* it was a valid remote_host */
+      bcopy(hp->h_addr,
+	    (char *)&server.sin_addr,
+	    hp->h_length);
+      server.sin_family = hp->h_addrtype;
+    }
+  }
+  else {
+    /* it was a valid IP address */
+    server.sin_addr.s_addr = addr;
+    server.sin_family = AF_INET;
+  }    
+  
+  if ( print_headers ) {
+    fprintf(where,"XTI TCP REQUEST/RESPONSE TEST");
+    fprintf(where," to %s", remote_host);
+    if (iteration_max > 1) {
+      fprintf(where,
+	      " : +/-%3.1f%% @ %2d%% conf.",
+	      interval/0.02,
+	      confidence_level);
+      }
+    if (loc_nodelay || rem_nodelay) {
+      fprintf(where," : nodelay");
+    }
+    if (loc_sndavoid || 
+	loc_rcvavoid ||
+	rem_sndavoid ||
+	rem_rcvavoid) {
+      fprintf(where," : copy avoidance");
+    }
+#ifdef WANT_HISTOGRAM
+    fprintf(where," : histogram");
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS
+    fprintf(where," : interval");
+#endif /* WANT_INTERVALS */
+#ifdef DIRTY 
+    fprintf(where," : dirty data");
+#endif /* DIRTY */
+    fprintf(where,"\n");
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring = NULL;
+  recv_ring = NULL;
+  confidence_iteration = 1;
+  init_stat();
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    timed_out       = 0;
+    trans_remaining = 0;
+
+    /* set-up the data buffers with the requested alignment and offset. */
+    /* since this is a request/response test, default the send_width and */
+    /* recv_width to 1 and not two raj 7/94 */
+
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+  
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+    /*set up the data socket                        */
+    send_socket = create_xti_endpoint(loc_xti_device);
+  
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_xti_tcp_rr: tcp stream data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_xti_tcp_rr: send_socket obtained...\n");
+    }
+
+    /* it would seem that with XTI, there is no implicit bind on a */
+    /* connect, so we have to make a call to t_bind. this is not */
+    /* terribly convenient, but I suppose that "standard is better */
+    /* than better" :) raj 2/95 */
+
+    if (t_bind(send_socket, NULL, NULL) == SOCKET_ERROR) {
+      t_error("send_xti_tcp_stream: t_bind");
+      exit(1);
+    }
+  
+    /* 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_XTI_TCP_RR;
+    xti_tcp_rr_request->recv_buf_size	=	rsr_size;
+    xti_tcp_rr_request->send_buf_size	=	rss_size;
+    xti_tcp_rr_request->recv_alignment  =	remote_recv_align;
+    xti_tcp_rr_request->recv_offset	=	remote_recv_offset;
+    xti_tcp_rr_request->send_alignment  =	remote_send_align;
+    xti_tcp_rr_request->send_offset	=	remote_send_offset;
+    xti_tcp_rr_request->request_size	=	req_size;
+    xti_tcp_rr_request->response_size	=	rsp_size;
+    xti_tcp_rr_request->no_delay	=	rem_nodelay;
+    xti_tcp_rr_request->measure_cpu	=	remote_cpu_usage;
+    xti_tcp_rr_request->cpu_rate	=	remote_cpu_rate;
+    xti_tcp_rr_request->so_rcvavoid	=	rem_rcvavoid;
+    xti_tcp_rr_request->so_sndavoid	=	rem_sndavoid;
+    if (test_time) {
+      xti_tcp_rr_request->test_length	=	test_time;
+    }
+    else {
+      xti_tcp_rr_request->test_length	=	test_trans * -1;
+    }
+
+    strcpy(xti_tcp_rr_request->xti_device, rem_xti_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 *) xti_tcp_rr_request->xti_device;
+      lastword = initword + ((strlen(rem_xti_device) + 3) / 4);
+      
+      for (charword = initword;
+	   charword < lastword;
+	   charword++) {
+	
+	*charword = ntohl(*charword);
+      }
+    }
+#endif /* __alpha */
+    
+    if (debug > 1) {
+      fprintf(where,"netperf: send_xti_tcp_rr: requesting TCP rr test\n");
+    }
+    
+    send_request();
+    
+    /* The response from the remote will contain all of the relevant 	*/
+    /* socket parameters for this test type. We will put them back into */
+    /* the variables here so they can be displayed if desired.  The	*/
+    /* remote will have calibrated CPU if necessary, and will have done	*/
+    /* all the needed set-up we will have calibrated the cpu locally	*/
+    /* before sending the request, and will grab the counter value right*/
+    /* after the connect returns. The remote will grab the counter right*/
+    /* after the accept call. This saves the hassle of extra messages	*/
+    /* being sent for the TCP tests.					*/
+  
+    recv_response();
+  
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size          = xti_tcp_rr_response->recv_buf_size;
+      rss_size          = xti_tcp_rr_response->send_buf_size;
+      rem_nodelay       = xti_tcp_rr_response->no_delay;
+      remote_cpu_usage  = xti_tcp_rr_response->measure_cpu;
+      remote_cpu_rate   = xti_tcp_rr_response->cpu_rate;
+      /* make sure that port numbers are in network order */
+      server.sin_port   = (short)xti_tcp_rr_response->data_port_number;
+      server.sin_port   = htons(server.sin_port);
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      perror("netperf: remote error");
+      
+      exit(1);
+    }
+    
+    /*Connect up to the remote port on the data socket  */
+    memset (&server_call, 0, sizeof(server_call));
+    server_call.addr.maxlen = sizeof(struct sockaddr_in);
+    server_call.addr.len    = sizeof(struct sockaddr_in);
+    server_call.addr.buf    = (char *)&server;
+
+    if (t_connect(send_socket, 
+		  &server_call,
+		  NULL) == INVALID_SOCKET){
+      t_error("netperf: send_xti_tcp_rr: data socket connect failed");
+      printf(" port: %d\n",ntohs(server.sin_port));
+      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);
+
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_xti_tcp_rr: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+    
+    /* We use an "OR" to control test execution. When the test is */
+    /* controlled by time, the byte count check will always return false. */
+    /* When the test is controlled by byte count, the time test will */
+    /* always return false. When the test is finished, the whole */
+    /* expression will go false and we will stop sending data. I think I */
+    /* just arbitrarily decrement trans_remaining for the timed test, but */
+    /* will not do that just yet... One other question is whether or not */
+    /* the send buffer and the receive buffer should be the same buffer. */
+
+    while ((!times_up) || (trans_remaining > 0)) {
+      /* send the request. we assume that if we use a blocking socket, */
+      /* the request will be sent at one shot. */
+      
+#ifdef WANT_HISTOGRAM
+      /* timestamp just before our call to send, and then again just */
+      /* after the receive raj 8/94 */
+      HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+      
+      if((len=t_snd(send_socket,
+		    send_ring->buffer_ptr,
+		    req_size,
+		    0)) != req_size) {
+	if ((errno == EINTR) || (errno == 0)) {
+	  /* we hit the end of a */
+	  /* timed test. */
+	  timed_out = 1;
+	  break;
+	}
+        fprintf(where,
+		"send_xti_tcp_rr: t_snd: errno %d t_errno %d t_look 0x%.4x\n",
+		errno,
+		t_errno,
+		t_look(send_socket));
+	fflush(where);
+        exit(1);
+      }
+      send_ring = send_ring->next;
+      
+      /* receive the response */
+      rsp_bytes_left = rsp_size;
+      temp_message_ptr  = recv_ring->buffer_ptr;
+      while(rsp_bytes_left > 0) {
+	if((rsp_bytes_recvd=t_rcv(send_socket,
+				  temp_message_ptr,
+				  rsp_bytes_left,
+				  &xti_flags)) == SOCKET_ERROR) {
+	  if (errno == EINTR) {
+	    /* We hit the end of a timed test. */
+	    timed_out = 1;
+	    break;
+	  }
+	  fprintf(where,
+		  "send_xti_tcp_rr: t_rcv: errno %d t_errno %d t_look 0x%x\n",
+		  errno,
+		  t_errno,
+		  t_look(send_socket));
+	  fflush(where);
+	  exit(1);
+	}
+	rsp_bytes_left -= rsp_bytes_recvd;
+	temp_message_ptr  += rsp_bytes_recvd;
+      }	
+      recv_ring = recv_ring->next;
+      
+      if (timed_out) {
+	/* we may have been in a nested while loop - we need */
+	/* another call to break. */
+	break;
+      }
+      
+#ifdef WANT_HISTOGRAM
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += 1;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_xti_udp_rr: fault with signal set!\n");
+	  fflush(where);
+	  exit(1);
+	}
+	interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  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. */
+  
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages/elapsed_time;
+  
+    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) {
+	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) {
+	remote_cpu_utilization = xti_tcp_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,
+						    xti_tcp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = -1.0;
+	remote_service_demand  = -1.0;
+      }
+      
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+
+    /* we are now done with the socket, so close it */
+    t_close(send_socket);
+
+  }
+
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* 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...  */
+
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(xti_tcp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      thruput,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      thruput);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+  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,
+	    local_send_align,
+	    remote_recv_offset,
+	    local_send_offset,
+	    remote_recv_offset);
+
+#ifdef WANT_HISTOGRAM
+    fprintf(where,"\nHistogram of request/response times\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+
+  }
+  
+}
+
+void
+send_xti_udp_stream(char remote_host[])
+{
+  /**********************************************************************/
+  /*									*/
+  /*               	UDP Unidirectional Send Test                    */
+  /*									*/
+  /**********************************************************************/
+  char *tput_title = "\
+Socket  Message  Elapsed      Messages                \n\
+Size    Size     Time         Okay Errors   Throughput\n\
+bytes   bytes    secs            #      #   %s/sec\n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1 = "\
+%6d  %6d   %-7.2f   %7d %6d    %7.2f\n\
+%6d           %-7.2f   %7d           %7.2f\n\n";
+  
+  
+  char *cpu_title = "\
+Socket  Message  Elapsed      Messages                   CPU      Service\n\
+Size    Size     Time         Okay Errors   Throughput   Util     Demand\n\
+bytes   bytes    secs            #      #   %s/sec %% %c%c     us/KB\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.2f %c\n";
+  
+  char *cpu_fmt_1 = "\
+%6d  %6d   %-7.2f   %7d %6d    %7.1f     %-6.2f   %-6.3f\n\
+%6d           %-7.2f   %7d           %7.1f     %-6.2f   %-6.3f\n\n";
+  
+  unsigned int	messages_recvd;
+  unsigned int 	messages_sent;
+  unsigned int	failed_sends;
+
+  float	elapsed_time,  
+        recv_elapsed,
+        local_cpu_utilization,
+        remote_cpu_utilization;
+  
+  float	 local_service_demand, remote_service_demand;
+  double local_thruput, remote_thruput;
+  double bytes_sent;
+  double bytes_recvd;
+  
+  
+  int	len;
+  int	*message_int_ptr;
+  struct ring_elt *send_ring;
+  SOCKET data_socket;
+  
+  unsigned int sum_messages_sent;
+  unsigned int sum_messages_recvd;
+  unsigned int sum_failed_sends;
+  double sum_local_thruput;
+
+#ifdef WANT_INTERVALS
+  int	interval_count;
+  sigset_t signal_set;
+#endif /* WANT_INTERVALS */
+  
+  struct   hostent     *hp;
+  struct   sockaddr_in server;
+  unsigned int         addr;
+  
+  struct t_unitdata unitdata;
+   
+  struct xti_udp_stream_request_struct	*xti_udp_stream_request;
+  struct xti_udp_stream_response_struct	*xti_udp_stream_response;
+  struct xti_udp_stream_results_struct	*xti_udp_stream_results;
+  
+  xti_udp_stream_request  = 
+    (struct xti_udp_stream_request_struct *)netperf_request.content.test_specific_data;
+  xti_udp_stream_response = 
+    (struct xti_udp_stream_response_struct *)netperf_response.content.test_specific_data;
+  xti_udp_stream_results  = 
+    (struct xti_udp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif /* WANT_HISTOGRAM */
+
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  /* it would seem that while HP-UX will allow an IP address (as a */
+  /* string) in a call to gethostbyname, other, less enlightened */
+  /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
+  /* order changed to check for IP address first. raj 7/96 */
+
+  if ((addr = inet_addr(remote_host)) == SOCKET_ERROR) {
+    /* it was not an IP address, try it as a name */
+    if ((hp = gethostbyname(remote_host)) == NULL) {
+      /* we have no idea what it is */
+      fprintf(where,
+	      "establish_control: could not resolve the destination %s\n",
+	      remote_host);
+      fflush(where);
+      exit(1);
+    }
+    else {
+      /* it was a valid remote_host */
+      bcopy(hp->h_addr,
+	    (char *)&server.sin_addr,
+	    hp->h_length);
+      server.sin_family = hp->h_addrtype;
+    }
+  }
+  else {
+    /* it was a valid IP address */
+    server.sin_addr.s_addr = addr;
+    server.sin_family = AF_INET;
+  }    
+  
+  if ( print_headers ) {
+    fprintf(where,"UDP UNIDIRECTIONAL SEND TEST");
+    fprintf(where," to %s", remote_host);
+    if (iteration_max > 1) {
+      fprintf(where,
+	      " : +/-%3.1f%% @ %2d%% conf.",
+	      interval/0.02,
+	      confidence_level);
+      }
+    if (loc_sndavoid || 
+	loc_rcvavoid ||
+	rem_sndavoid ||
+	rem_rcvavoid) {
+      fprintf(where," : copy avoidance");
+    }
+#ifdef WANT_HISTOGRAM
+    fprintf(where," : histogram");
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS
+    fprintf(where," : interval");
+#endif /* WANT_INTERVALS */
+#ifdef DIRTY 
+    fprintf(where," : dirty data");
+#endif /* DIRTY */
+    fprintf(where,"\n");
+  }	
+  
+  send_ring            = NULL;
+  confidence_iteration = 1;
+  init_stat();
+  sum_messages_sent    = 0;
+  sum_messages_recvd   = 0;
+  sum_failed_sends     = 0;
+  sum_local_thruput    = 0.0;
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+    
+    /* initialize a few counters. we have to remember that we might be */
+    /* going through the loop more than once. */
+    messages_sent  = 0;
+    messages_recvd = 0;
+    failed_sends   = 0;
+    times_up       = 0;
+    
+    /*set up the data socket			*/
+    data_socket = create_xti_endpoint(loc_xti_device);
+    
+    if (data_socket == INVALID_SOCKET) {
+      perror("send_xti_udp_stream: create_xti_endpoint");
+      exit(1);
+    }
+
+    if (t_bind(data_socket, NULL, NULL) == SOCKET_ERROR) {
+      t_error("send_xti_udp_stream: t_bind");
+      exit(1);
+    }
+
+    /* now, we want to see if we need to set the send_size */
+    if (send_size == 0) {
+      if (lss_size > 0) {
+	send_size = lss_size;
+      }
+      else {
+	send_size = 4096;
+      }
+    }
+    
+    /* set-up the data buffer with the requested alignment and offset, */
+    /* most of the numbers here are just a hack to pick something nice */
+    /* and big in an attempt to never try to send a buffer a second time */
+    /* before it leaves the node...unless the user set the width */
+    /* explicitly. */
+    if (send_width == 0) send_width = 32;
+    
+    if (send_ring == NULL ) {
+      send_ring = allocate_buffer_ring(send_width,
+				       send_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+    
+    
+    /* 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_XTI_UDP_STREAM;
+    xti_udp_stream_request->recv_buf_size  = rsr_size;
+    xti_udp_stream_request->message_size   = send_size;
+    xti_udp_stream_request->recv_alignment = remote_recv_align;
+    xti_udp_stream_request->recv_offset    = remote_recv_offset;
+    xti_udp_stream_request->measure_cpu    = remote_cpu_usage;
+    xti_udp_stream_request->cpu_rate       = remote_cpu_rate;
+    xti_udp_stream_request->test_length    = test_time;
+    xti_udp_stream_request->so_rcvavoid    = rem_rcvavoid;
+    xti_udp_stream_request->so_sndavoid    = rem_sndavoid;
+    
+    strcpy(xti_udp_stream_request->xti_device, rem_xti_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 *) xti_udp_stream_request->xti_device;
+      lastword = initword + ((strlen(rem_xti_device) + 3) / 4);
+      
+      for (charword = initword;
+	   charword < lastword;
+	   charword++) {
+	
+	*charword = ntohl(*charword);
+      }
+    }
+#endif /* __alpha */
+
+    send_request();
+    
+    recv_response();
+    
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"send_xti_udp_stream: remote data connection done.\n");
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      perror("send_xti_udp_stream: error on remote");
+      exit(1);
+    }
+    
+    /* Place the port number returned by the remote into the sockaddr */
+    /* structure so our sends can be sent to the correct place. Also get */
+    /* some of the returned socket buffer information for user display. */
+    
+    /* make sure that port numbers are in the proper order */
+    server.sin_port = (short)xti_udp_stream_response->data_port_number;
+    server.sin_port = htons(server.sin_port);
+    rsr_size        = xti_udp_stream_response->recv_buf_size;
+    rss_size        = xti_udp_stream_response->send_buf_size;
+    remote_cpu_rate = xti_udp_stream_response->cpu_rate;
+    
+    /* it would seem that XTI does not allow the expedient of */
+    /* "connecting" a UDP end-point the way BSD does. so, we will do */
+    /* everything with t_sndudata and t_rcvudata. Our "virtual" */
+    /* connect here will be to assign the destination portion of the */
+    /* t_unitdata struct here, where we would have otherwise called */
+    /* t_connect() raj 3/95 */
+    
+    memset (&unitdata, 0, sizeof(unitdata));
+    unitdata.addr.maxlen = sizeof(struct sockaddr_in);
+    unitdata.addr.len    = sizeof(struct sockaddr_in);
+    unitdata.addr.buf    = (char *)&server;
+
+    /* we don't use any options, so might as well set that part here */
+    /* too */
+
+    unitdata.opt.maxlen = 0;
+    unitdata.opt.len    = 0;
+    unitdata.opt.buf    = NULL;
+
+    /* we need to initialize the send buffer for the first time as */
+    /* well since we move to the next pointer after the send call. */
+
+    unitdata.udata.maxlen = send_size;
+    unitdata.udata.len    = send_size;
+    unitdata.udata.buf    = send_ring->buffer_ptr;
+
+    /* set up the timer to call us after test_time. one of these days, */
+    /* it might be nice to figure-out a nice reliable way to have the */
+    /* test controlled by a byte count as well, but since UDP is not */
+    /* reliable, that could prove difficult. so, in the meantime, we */
+    /* only allow a XTI_UDP_STREAM test to be a timed test. */
+    
+    if (test_time) {
+      times_up = 0;
+      start_timer(test_time);
+    }
+    else {
+      fprintf(where,"Sorry, XTI_UDP_STREAM tests must be timed.\n");
+      fflush(where);
+      exit(1);
+    }
+    
+    /* Get the start count for the idle counter and the start time */
+    
+    cpu_start(local_cpu_usage);
+    
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_xti_udp_stream: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+    
+    /* Send datagrams like there was no tomorrow. at somepoint it might */
+    /* be nice to set this up so that a quantity of bytes could be sent, */
+    /* but we still need some sort of end of test trigger on the receive */
+    /* side. that could be a select with a one second timeout, but then */
+    /* if there is a test where none of the data arrives for awile and */
+    /* then starts again, we would end the test too soon. something to */
+    /* think about... */
+    while (!times_up) {
+      
+#ifdef DIRTY
+      /* we want to dirty some number of consecutive integers in the buffer */
+      /* we are about to send. we may also want to bring some number of */
+      /* them cleanly into the cache. The clean ones will follow any dirty */
+      /* ones into the cache. */
+
+      access_buffer(send_ring->buffer_ptr,
+		    send_size,
+		    loc_dirty_count,
+		    loc_clean_count);
+
+#endif /* DIRTY */
+      
+#ifdef WANT_HISTOGRAM
+      HIST_timestamp(&time_one);
+#endif /* WANT_HISTOGRAM */
+      
+      if ((t_sndudata(data_socket,
+		      &unitdata))  != 0) {
+	if (errno == EINTR)
+	  break;
+	if (errno == ENOBUFS) {
+	  failed_sends++;
+	  continue;
+	}
+	perror("xti_udp_send: data send error");
+	t_error("xti_udp_send: data send error");
+	exit(1);
+      }
+      messages_sent++;          
+      
+      /* now we want to move our pointer to the next position in the */
+      /* data buffer...and update the unitdata structure */
+      
+      send_ring          = send_ring->next;
+      unitdata.udata.buf = send_ring->buffer_ptr;
+      
+#ifdef WANT_HISTOGRAM
+      /* get the second timestamp */
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += send_size;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_xti_udp_stream: fault with signal set!\n");
+	  fflush(where);
+	  exit(1);
+	}
+	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_xti_udp_stream: remote results obtained\n");
+    }
+    else {
+      Set_errno(netperf_response.content.serv_errno);
+      perror("send_xti_udp_stream: error on remote");
+      exit(1);
+    }
+    
+    bytes_sent    = (double) send_size * (double) messages_sent;
+    local_thruput = calc_thruput(bytes_sent);
+    
+    messages_recvd = xti_udp_stream_results->messages_recvd;
+    bytes_recvd    = (double) send_size * (double) messages_recvd;
+    
+    /* we asume that the remote ran for as long as we did */
+    
+    remote_thruput = calc_thruput(bytes_recvd);
+    
+    /* print the results for this socket and message size */
+    
+    if (local_cpu_usage || remote_cpu_usage) {
+      /* We must now do a little math for service demand and cpu */
+      /* utilization for the system(s) We pass zeros for the local */
+      /* cpu utilization and elapsed time to tell the routine to use */
+      /* the libraries own values for those. */
+      if (local_cpu_usage) {
+	local_cpu_utilization	= calc_cpu_util(0.0);
+	/* shouldn't this really be based on bytes_recvd, since that is */
+	/* the effective throughput of the test? I think that it should, */
+	/* so will make the change raj 11/94 */
+	local_service_demand	= calc_service_demand(bytes_recvd,
+						      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) {
+	remote_cpu_utilization	= xti_udp_stream_results->cpu_util;
+	remote_service_demand	= calc_service_demand(bytes_recvd,
+						      0.0,
+						      remote_cpu_utilization,
+						      xti_udp_stream_results->num_cpus);
+      }
+      else {
+	remote_cpu_utilization	= -1.0;
+	remote_service_demand	= -1.0;
+      }
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization  = -1.0;
+      local_service_demand   = -1.0;
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 remote_thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    /* since the routine calculate_confidence is rather generic, and */
+    /* we have a few other parms of interest, we will do a little work */
+    /* here to caclulate their average. */
+    sum_messages_sent  += messages_sent;
+    sum_messages_recvd += messages_recvd;
+    sum_failed_sends   += failed_sends;
+    sum_local_thruput  += local_thruput;
+    
+    confidence_iteration++;
+
+    /* this datapoint is done, so we don't need the socket any longer */
+    close(data_socket);
+
+  }
+
+  /* we should reach this point once the test is finished */
+
+  retrieve_confident_values(&elapsed_time,
+			    &remote_thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+
+  /* some of the interesting values aren't covered by the generic */
+  /* confidence routine */
+  messages_sent    = sum_messages_sent / (confidence_iteration -1);
+  messages_recvd   = sum_messages_recvd / (confidence_iteration -1);
+  failed_sends     = sum_failed_sends / (confidence_iteration -1);
+  local_thruput    = sum_local_thruput / (confidence_iteration -1);
+
+  /* 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...  */
+    
+  
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(xti_udp_stream_results->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		local_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		format_units(),
+		local_cpu_method,
+		remote_cpu_method);
+      }
+
+      fprintf(where,
+	      cpu_fmt_1,		/* the format string */
+	      lss_size,		        /* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time,		/* how long was the test */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput, 		/* what was the xfer rate */
+	      local_cpu_utilization,	/* local cpu */
+	      local_service_demand,	/* local service demand */
+	      rsr_size,
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput,
+	      remote_cpu_utilization,	/* remote cpu */
+	      remote_service_demand);	/* remote service demand */
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      local_thruput);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+      fprintf(where,
+	      tput_fmt_1,		/* the format string */
+	      lss_size, 		/* local sendbuf size */
+	      send_size,		/* how large were the sends */
+	      elapsed_time, 		/* how long did it take */
+	      messages_sent,
+	      failed_sends,
+	      local_thruput,
+	      rsr_size, 		/* remote recvbuf size */
+	      elapsed_time,
+	      messages_recvd,
+	      remote_thruput);
+      break;
+    }
+  }
+
+  fflush(where);
+#ifdef WANT_HISTOGRAM
+  if (verbosity > 1) {
+    fprintf(where,"\nHistogram of time spent in send() call\n");
+    fflush(where);
+    HIST_report(time_hist);
+  }
+#endif /* WANT_HISTOGRAM */
+
+}
+
+
+ /* this routine implements the receive side (netserver) of the */
+ /* XTI_UDP_STREAM performance test. */
+
+void
+recv_xti_udp_stream()
+{
+  struct ring_elt *recv_ring;
+
+  struct t_bind bind_req, bind_resp;
+  struct t_unitdata unitdata;
+  int	            flags = 0;
+
+  struct sockaddr_in myaddr_in;
+  struct sockaddr_in fromaddr_in;
+
+  SOCKET s_data;
+  int 	addrlen;
+  unsigned int	bytes_received = 0;
+  float	elapsed_time;
+  
+  unsigned int	message_size;
+  unsigned int	messages_recvd = 0;
+  
+  struct xti_udp_stream_request_struct	*xti_udp_stream_request;
+  struct xti_udp_stream_response_struct	*xti_udp_stream_response;
+  struct xti_udp_stream_results_struct	*xti_udp_stream_results;
+  
+  xti_udp_stream_request  = 
+    (struct xti_udp_stream_request_struct *)netperf_request.content.test_specific_data;
+  xti_udp_stream_response = 
+    (struct xti_udp_stream_response_struct *)netperf_response.content.test_specific_data;
+  xti_udp_stream_results  = 
+    (struct xti_udp_stream_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_xti_udp_stream: entered...\n");
+    fflush(where);
+  }
+  
+  /* We want to set-up the listen socket with all the desired */
+  /* parameters and then let the initiator know that all is ready. If */
+  /* socket size defaults are to be used, then the initiator will have */
+  /* sent us 0's. If the socket sizes cannot be changed, then we will */
+  /* send-back what they are. If that information cannot be determined, */
+  /* then we send-back -1's for the sizes. If things go wrong for any */
+  /* reason, we will drop back ten yards and punt. */
+  
+  /* If anything goes wrong, we want the remote to know about it. It */
+  /* would be best if the error that the remote reports to the user is */
+  /* the actual error we encountered, rather than some bogus unexpected */
+  /* response type message. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_xti_udp_stream: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = XTI_UDP_STREAM_RESPONSE;
+  
+  if (debug > 2) {
+    fprintf(where,"recv_xti_udp_stream: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variable to be at the desired */
+  /* alignment with the desired offset. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_xti_udp_stream: requested alignment of %d\n",
+	    xti_udp_stream_request->recv_alignment);
+    fflush(where);
+  }
+
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   xti_udp_stream_request->message_size,
+				   xti_udp_stream_request->recv_alignment,
+				   xti_udp_stream_request->recv_offset);
+
+  if (debug > 1) {
+    fprintf(where,"recv_xti_udp_stream: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = 0;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug > 1) {
+    fprintf(where,"recv_xti_udp_stream: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_xti_endpoint expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lsr_size = xti_udp_stream_request->recv_buf_size;
+  loc_rcvavoid = xti_udp_stream_request->so_rcvavoid;
+  loc_sndavoid = xti_udp_stream_request->so_sndavoid;
+
+#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 *) xti_udp_stream_request->xti_device;
+    lastword = initword + ((xti_udp_stream_request->dev_name_len + 3) / 4);
+    
+    for (charword = initword;
+	 charword < lastword;
+	 charword++) {
+      
+      *charword = htonl(*charword);
+    }
+  }
+  
+#endif /* __alpha */
+    
+  s_data = create_xti_endpoint(xti_udp_stream_request->xti_device);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+
+  bind_req.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_req.addr.len    = sizeof(struct sockaddr_in);
+  bind_req.addr.buf    = (char *)&myaddr_in;
+  bind_req.qlen        = 1;
+
+  bind_resp.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_resp.addr.len    = sizeof(struct sockaddr_in);
+  bind_resp.addr.buf    = (char *)&myaddr_in;
+  bind_resp.qlen        = 1;
+
+  if (t_bind(s_data,
+	     &bind_req,
+	     &bind_resp) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = t_errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  xti_udp_stream_response->test_length = 
+    xti_udp_stream_request->test_length;
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  xti_udp_stream_response->data_port_number = 
+    (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  xti_udp_stream_response->cpu_rate    = 0.0; /* assume no cpu */
+  xti_udp_stream_response->measure_cpu = 0;
+  if (xti_udp_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... */
+    xti_udp_stream_response->measure_cpu = 1;
+    xti_udp_stream_response->cpu_rate = 
+      calibrate_local_cpu(xti_udp_stream_request->cpu_rate);
+  }
+  
+  message_size	= xti_udp_stream_request->message_size;
+  test_time	= xti_udp_stream_request->test_length;
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  xti_udp_stream_response->send_buf_size = lss_size;
+  xti_udp_stream_response->recv_buf_size = lsr_size;
+  xti_udp_stream_response->so_rcvavoid = loc_rcvavoid;
+  xti_udp_stream_response->so_sndavoid = loc_sndavoid;
+
+  /* since we are going to call t_rcvudata() instead of t_rcv() we */
+  /* need to init the unitdata structure raj 3/95 */
+
+  unitdata.addr.maxlen = sizeof(fromaddr_in);
+  unitdata.addr.len    = sizeof(fromaddr_in);
+  unitdata.addr.buf    = (char *)&fromaddr_in;
+
+  unitdata.opt.maxlen = 0;
+  unitdata.opt.len    = 0;
+  unitdata.opt.buf    = NULL;
+
+  unitdata.udata.maxlen = xti_udp_stream_request->message_size;
+  unitdata.udata.len    = xti_udp_stream_request->message_size;
+  unitdata.udata.buf    = recv_ring->buffer_ptr;
+
+  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(xti_udp_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_xti_udp_stream: about to enter inner sanctum.\n");
+    fflush(where);
+  }
+  
+  while (!times_up) {
+#ifdef RAJ_DEBUG
+    if (debug) {
+      fprintf(where,"t_rcvudata, errno %d, t_errno %d",
+	      errno,
+	      t_errno);
+      fprintf(where," after %d messages\n",messages_recvd);
+      fprintf(where,"addrmax %d addrlen %d addrbuf %x\n",
+	      unitdata.addr.maxlen,
+	      unitdata.addr.len,
+	      unitdata.addr.buf);
+      fprintf(where,"optmax %d optlen %d optbuf %x\n",
+	      unitdata.opt.maxlen,
+	      unitdata.opt.len,
+	      unitdata.opt.buf);
+      fprintf(where,"udatamax %d udatalen %d udatabuf %x\n",
+	      unitdata.udata.maxlen,
+	      unitdata.udata.len,
+	      unitdata.udata.buf);
+      fflush(where);
+    }
+#endif /* RAJ_DEBUG */
+    if (t_rcvudata(s_data, 
+		   &unitdata,
+		   &flags) != 0) {
+      if (errno == TNODATA) {
+	continue;
+      }
+      if (errno != EINTR) {
+	netperf_response.content.serv_errno = t_errno;
+	send_response();
+	exit(1);
+      }
+      break;
+    }
+    messages_recvd++;
+    recv_ring = recv_ring->next;
+    unitdata.udata.buf = recv_ring->buffer_ptr;
+  }
+  
+  if (debug) {
+    fprintf(where,"recv_xti_udp_stream: got %d messages.\n",messages_recvd);
+    fflush(where);
+  }
+  
+  
+  /* The loop now exits due timer or < send_size bytes received. */
+  
+  cpu_stop(xti_udp_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_xti_udp_stream: test ended in %f seconds.\n",elapsed_time);
+    fflush(where);
+  }
+  
+  bytes_received = (messages_recvd * message_size);
+  
+  /* send the results to the sender			*/
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_udp_stream: got %d bytes\n",
+	    bytes_received);
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type	= XTI_UDP_STREAM_RESULTS;
+  xti_udp_stream_results->bytes_received	= bytes_received;
+  xti_udp_stream_results->messages_recvd	= messages_recvd;
+  xti_udp_stream_results->elapsed_time	= elapsed_time;
+  xti_udp_stream_results->cpu_method        = cpu_method;
+  if (xti_udp_stream_request->measure_cpu) {
+    xti_udp_stream_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  else {
+    xti_udp_stream_results->cpu_util	= -1.0;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,
+	    "recv_xti_udp_stream: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+
+void send_xti_udp_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f %c\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;
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct t_bind bind_req, bind_resp;
+  struct t_unitdata unitdata;
+  struct t_unitdata send_unitdata;
+  struct t_unitdata recv_unitdata;
+  int	            flags = 0;
+
+  int	len;
+  int	nummessages;
+  SOCKET send_socket;
+  int	trans_remaining;
+  int	bytes_xferd;
+  
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double thruput;
+  
+  struct	hostent	        *hp;
+  struct	sockaddr_in	server, myaddr_in;
+  unsigned      int             addr;
+  int	                        addrlen;
+  
+  struct	xti_udp_rr_request_struct	*xti_udp_rr_request;
+  struct	xti_udp_rr_response_struct	*xti_udp_rr_response;
+  struct	xti_udp_rr_results_struct	*xti_udp_rr_result;
+
+#ifdef WANT_INTERVALS
+  int	interval_count;
+  sigset_t signal_set;
+#endif /* WANT_INTERVALS */
+  
+  xti_udp_rr_request  =
+    (struct xti_udp_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_udp_rr_response =
+    (struct xti_udp_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_udp_rr_result	 =
+    (struct xti_udp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+#ifdef WANT_HISTOGRAM
+  time_hist = HIST_new();
+#endif
+  
+  /* since we are now disconnected from the code that established the */
+  /* control socket, and since we want to be able to use different */
+  /* protocols and such, we are passed the name of the remote host and */
+  /* must turn that into the test specific addressing information. */
+  
+  bzero((char *)&server,
+	sizeof(server));
+  
+  /* it would seem that while HP-UX will allow an IP address (as a */
+  /* string) in a call to gethostbyname, other, less enlightened */
+  /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
+  /* order changed to check for IP address first. raj 7/96 */
+
+  if ((addr = inet_addr(remote_host)) == SOCKET_ERROR) {
+    /* it was not an IP address, try it as a name */
+    if ((hp = gethostbyname(remote_host)) == NULL) {
+      /* we have no idea what it is */
+      fprintf(where,
+	      "establish_control: could not resolve the destination %s\n",
+	      remote_host);
+      fflush(where);
+      exit(1);
+    }
+    else {
+      /* it was a valid remote_host */
+      bcopy(hp->h_addr,
+	    (char *)&server.sin_addr,
+	    hp->h_length);
+      server.sin_family = hp->h_addrtype;
+    }
+  }
+  else {
+    /* it was a valid IP address */
+    server.sin_addr.s_addr = addr;
+    server.sin_family = AF_INET;
+  }    
+  
+  if ( print_headers ) {
+    fprintf(where,"XTI UDP REQUEST/RESPONSE TEST");
+        fprintf(where," to %s", remote_host);
+    if (iteration_max > 1) {
+      fprintf(where,
+	      " : +/-%3.1f%% @ %2d%% conf.",
+	      interval/0.02,
+	      confidence_level);
+      }
+    if (loc_sndavoid || 
+	loc_rcvavoid ||
+	rem_sndavoid ||
+	rem_rcvavoid) {
+      fprintf(where," : copy avoidance");
+    }
+#ifdef WANT_HISTOGRAM
+    fprintf(where," : histogram");
+#endif /* WANT_HISTOGRAM */
+#ifdef WANT_INTERVALS
+    fprintf(where," : interval");
+#endif /* WANT_INTERVALS */
+#ifdef DIRTY 
+    fprintf(where," : dirty data");
+#endif /* DIRTY */
+    fprintf(where,"\n");
+  }
+  
+  /* initialize a few counters */
+  
+  send_ring     = NULL;
+  recv_ring     = NULL;
+  nummessages	= 0;
+  bytes_xferd	= 0;
+  times_up 	= 0;
+  confidence_iteration = 1;
+  init_stat();
+
+
+  /* we have a great-big while loop which controls the number of times */
+  /* we run a particular test. this is for the calculation of a */
+  /* confidence interval (I really should have stayed awake during */
+  /* probstats :). If the user did not request confidence measurement */
+  /* (no confidence is the default) then we will only go though the */
+  /* loop once. the confidence stuff originates from the folks at IBM */
+
+  while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
+	 (confidence_iteration <= iteration_min)) {
+    
+    nummessages     = 0;
+    bytes_xferd     = 0.0;
+    times_up        = 0;
+    trans_remaining = 0;
+    
+    /* set-up the data buffers with the requested alignment and offset */
+    
+    if (send_width == 0) send_width = 1;
+    if (recv_width == 0) recv_width = 1;
+    
+    if (send_ring == NULL) {
+      send_ring = allocate_buffer_ring(send_width,
+				       req_size,
+				       local_send_align,
+				       local_send_offset);
+    }
+    
+    if (recv_ring == NULL) {
+      recv_ring = allocate_buffer_ring(recv_width,
+				       rsp_size,
+				       local_recv_align,
+				       local_recv_offset);
+    }
+    
+  /* since we are going to call t_rcvudata() instead of t_rcv() we */
+  /* need to init the unitdata structure raj 8/95 */
+
+    memset (&recv_unitdata, 0, sizeof(recv_unitdata));
+    recv_unitdata.addr.maxlen = sizeof(struct sockaddr_in);
+    recv_unitdata.addr.len    = sizeof(struct sockaddr_in);
+    recv_unitdata.addr.buf    = (char *)&server;
+    
+    recv_unitdata.opt.maxlen = 0;
+    recv_unitdata.opt.len    = 0;
+    recv_unitdata.opt.buf    = NULL;
+    
+    recv_unitdata.udata.maxlen = rsp_size;
+    recv_unitdata.udata.len    = rsp_size;
+    recv_unitdata.udata.buf    = recv_ring->buffer_ptr;
+    
+    /* since we are going to call t_sndudata() instead of t_snd() we */
+    /* need to init the unitdata structure raj 8/95 */
+    
+    memset (&send_unitdata, 0, sizeof(send_unitdata));
+    send_unitdata.addr.maxlen = sizeof(struct sockaddr_in);
+    send_unitdata.addr.len    = sizeof(struct sockaddr_in);
+    send_unitdata.addr.buf    = (char *)&server;
+    
+    send_unitdata.opt.maxlen = 0;
+    send_unitdata.opt.len    = 0;
+    send_unitdata.opt.buf    = NULL;
+    
+    send_unitdata.udata.maxlen = req_size;
+    send_unitdata.udata.len    = req_size;
+    send_unitdata.udata.buf    = send_ring->buffer_ptr;
+
+    /*set up the data socket                        */
+    send_socket = create_xti_endpoint(loc_xti_device);
+    
+    if (send_socket == INVALID_SOCKET){
+      perror("netperf: send_xti_udp_rr: udp rr data socket");
+      exit(1);
+    }
+    
+    if (debug) {
+      fprintf(where,"send_xti_udp_rr: send_socket obtained...\n");
+    }
+    
+    /* it would seem that with XTI, there is no implicit bind  */
+    /* so we have to make a call to t_bind. this is not */
+    /* terribly convenient, but I suppose that "standard is better */
+    /* than better" :) raj 2/95 */
+
+    if (t_bind(send_socket, NULL, NULL) == SOCKET_ERROR) {
+      t_error("send_xti_tcp_stream: t_bind");
+      exit(1);
+    }
+
+    /* 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_XTI_UDP_RR;
+    xti_udp_rr_request->recv_buf_size	= rsr_size;
+    xti_udp_rr_request->send_buf_size	= rss_size;
+    xti_udp_rr_request->recv_alignment  = remote_recv_align;
+    xti_udp_rr_request->recv_offset	= remote_recv_offset;
+    xti_udp_rr_request->send_alignment  = remote_send_align;
+    xti_udp_rr_request->send_offset	= remote_send_offset;
+    xti_udp_rr_request->request_size	= req_size;
+    xti_udp_rr_request->response_size	= rsp_size;
+    xti_udp_rr_request->measure_cpu	= remote_cpu_usage;
+    xti_udp_rr_request->cpu_rate	= remote_cpu_rate;
+    xti_udp_rr_request->so_rcvavoid	= rem_rcvavoid;
+    xti_udp_rr_request->so_sndavoid	= rem_sndavoid;
+    if (test_time) {
+      xti_udp_rr_request->test_length	= test_time;
+    }
+    else {
+      xti_udp_rr_request->test_length	= test_trans * -1;
+    }
+    
+    strcpy(xti_udp_rr_request->xti_device, rem_xti_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 *) xti_udp_rr_request->xti_device;
+      lastword = initword + ((strlen(rem_xti_device) + 3) / 4);
+      
+      for (charword = initword;
+	   charword < lastword;
+	   charword++) {
+	
+	*charword = ntohl(*charword);
+      }
+    }
+#endif /* __alpha */
+
+    if (debug > 1) {
+      fprintf(where,"netperf: send_xti_udp_rr: requesting UDP r/r 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 UDP tests.					*/
+    
+    recv_response();
+    
+    if (!netperf_response.content.serv_errno) {
+      if (debug)
+	fprintf(where,"remote listen done.\n");
+      rsr_size	       =	xti_udp_rr_response->recv_buf_size;
+      rss_size	       =	xti_udp_rr_response->send_buf_size;
+      remote_cpu_usage =	xti_udp_rr_response->measure_cpu;
+      remote_cpu_rate  = 	xti_udp_rr_response->cpu_rate;
+      /* port numbers in proper order */
+      server.sin_port  =	(short)xti_udp_rr_response->data_port_number;
+      server.sin_port  = 	htons(server.sin_port);
+    }
+    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);
+
+#ifdef WANT_INTERVALS
+    if ((interval_burst) || (demo_mode)) {
+      /* zero means that we never pause, so we never should need the */
+      /* interval timer, unless we are in demo_mode */
+      start_itimer(interval_wate);
+    }
+    interval_count = interval_burst;
+    /* get the signal set for the call to sigsuspend */
+    if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
+      fprintf(where,
+	      "send_xti_udp_rr: unable to get sigmask errno %d\n",
+	      errno);
+      fflush(where);
+      exit(1);
+    }
+#endif /* WANT_INTERVALS */
+    
+    /* 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_HISTOGRAM
+      HIST_timestamp(&time_one);
+#endif
+      if((t_sndudata(send_socket,
+		     &send_unitdata)) != 0) {
+	if (errno == EINTR) {
+	  /* We likely hit */
+	  /* test-end time. */
+	  break;
+	}
+        fprintf(where,
+		"send_xti_udp_rr: t_sndudata: errno %d t_errno %d t_look 0x%.4x\n",
+		errno,
+		t_errno,
+		t_look(send_socket));
+	fflush(where);
+	exit(1);
+      }
+      send_ring = send_ring->next;
+      
+      /* receive the response. with UDP we will get it all, or nothing */
+      
+      if((t_rcvudata(send_socket,
+		     &recv_unitdata,
+		     &flags)) != 0) {
+	if (errno == TNODATA) {
+	  continue;
+	}
+	if (errno == EINTR) {
+	  /* Again, we have likely hit test-end time */
+	  break;
+	}
+	fprintf(where,
+		"send_xti_udp_rr: t_rcvudata: errno %d t_errno %d t_look 0x%x\n",
+		errno,
+		t_errno,
+		t_look(send_socket));
+	fprintf(where,
+		"recv_unitdata.udata.buf %x\n",recv_unitdata.udata.buf);
+	fprintf(where,
+		"recv_unitdata.udata.maxlen %x\n",recv_unitdata.udata.maxlen);
+	fprintf(where,
+		"recv_unitdata.udata.len %x\n",recv_unitdata.udata.len);
+	fprintf(where,
+		"recv_unitdata.addr.buf %x\n",recv_unitdata.addr.buf);
+	fprintf(where,
+		"recv_unitdata.addr.maxlen %x\n",recv_unitdata.addr.maxlen);
+	fprintf(where,
+		"recv_unitdata.addr.len %x\n",recv_unitdata.addr.len);
+	fflush(where);
+	exit(1);
+      }
+      recv_ring = recv_ring->next;
+      
+#ifdef WANT_HISTOGRAM
+      HIST_timestamp(&time_two);
+      HIST_add(time_hist,delta_micro(&time_one,&time_two));
+      
+      /* 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.  */
+#endif
+#ifdef WANT_INTERVALS      
+      if (demo_mode) {
+	units_this_tick += 1;
+      }
+      /* 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 sigsuspend and wait for the interval timer to get us */
+	/* out */
+	if (debug) {
+	  fprintf(where,"about to suspend\n");
+	  fflush(where);
+	}
+	if (sigsuspend(&signal_set) == EFAULT) {
+	  fprintf(where,
+		  "send_xti_udp_rr: fault with signal set!\n");
+	  fflush(where);
+	  exit(1);
+	}
+	interval_count = interval_burst;
+      }
+#endif /* WANT_INTERVALS */
+      
+      nummessages++;          
+      if (trans_remaining) {
+	trans_remaining--;
+      }
+      
+      if (debug > 3) {
+	if ((nummessages % 100) == 0) {
+	  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 rr test, that the two numbers should be *very* close... */
+    /* We calculate bytes_sent regardless of the way the test length */
+    /* was controlled.  */
+    
+    bytes_xferd	= (req_size * nummessages) + (rsp_size * nummessages);
+    thruput	= nummessages / elapsed_time;
+    
+    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 by placing a code for the metod used in the */
+      /* test banner */
+
+      if (local_cpu_usage) {
+	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) {
+	remote_cpu_utilization = xti_udp_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,
+						     xti_udp_rr_result->num_cpus);
+      }
+      else {
+	remote_cpu_utilization = -1.0;
+	remote_service_demand  = -1.0;
+      }
+    }
+    else {
+      /* we were not measuring cpu, for the confidence stuff, we */
+      /* should make it -1.0 */
+      local_cpu_utilization	= -1.0;
+      local_service_demand	= -1.0;
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* at this point, we want to calculate the confidence information. */
+    /* if debugging is on, calculate_confidence will print-out the */
+    /* parameters we pass it */
+    
+    calculate_confidence(confidence_iteration,
+			 elapsed_time,
+			 thruput,
+			 local_cpu_utilization,
+			 remote_cpu_utilization,
+			 local_service_demand,
+			 remote_service_demand);
+    
+    
+    confidence_iteration++;
+    
+    /* we are done with the socket */
+    t_close(send_socket);
+  }
+
+  /* at this point, we have made all the iterations we are going to */
+  /* make. */
+  retrieve_confident_values(&elapsed_time,
+			    &thruput,
+			    &local_cpu_utilization,
+			    &remote_cpu_utilization,
+			    &local_service_demand,
+			    &remote_service_demand);
+  
+  /* 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...  */
+  
+  if (confidence < 0) {
+    /* we did not hit confidence, but were we asked to look for it? */
+    if (iteration_max > 1) {
+      display_confidence();
+    }
+  }
+  
+  if (local_cpu_usage || remote_cpu_usage) {
+    local_cpu_method = format_cpu_method(cpu_method);
+    remote_cpu_method = format_cpu_method(xti_udp_rr_result->cpu_method);
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand,
+		local_cpu_method);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand,
+		remote_cpu_method);
+      }
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,
+		cpu_title,
+		local_cpu_method,
+		remote_cpu_method);
+      }
+    
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+    case 2:
+      if (print_headers) {
+	fprintf(where,tput_title,format_units());
+      }
+    
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  fflush(where);
+
+  /* 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. */
+  
+  /* how to handle the verbose information in the presence of */
+  /* confidence intervals is yet to be determined... raj 11/94 */
+
+  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_HISTOGRAM
+    fprintf(where,"\nHistogram of request/reponse times.\n");
+    fflush(where);
+    HIST_report(time_hist);
+#endif /* WANT_HISTOGRAM */
+  }
+}
+
+ /* this routine implements the receive side (netserver) of a XTI_UDP_RR */
+ /* test. */
+void 
+  recv_xti_udp_rr()
+{
+  
+  struct ring_elt *recv_ring;
+  struct ring_elt *send_ring;
+
+  struct t_bind bind_req, bind_resp;
+  struct t_unitdata send_unitdata;
+  struct t_unitdata recv_unitdata;
+  int	            flags = 0;
+
+  struct sockaddr_in myaddr_in, peeraddr_in;
+  SOCKET s_data;
+  int 	addrlen;
+  int	trans_received;
+  int	trans_remaining;
+  float	elapsed_time;
+  
+  struct	xti_udp_rr_request_struct	*xti_udp_rr_request;
+  struct	xti_udp_rr_response_struct	*xti_udp_rr_response;
+  struct	xti_udp_rr_results_struct	*xti_udp_rr_results;
+  
+  
+  /* a little variable initialization */
+  memset (&myaddr_in, 0, sizeof(struct sockaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = 0;
+  memset (&peeraddr_in, 0, sizeof(struct sockaddr_in));
+
+  /* and some not so paranoid :) */
+  xti_udp_rr_request  = 
+    (struct xti_udp_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_udp_rr_response = 
+    (struct xti_udp_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_udp_rr_results  = 
+    (struct xti_udp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_xti_udp_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_xti_udp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = XTI_UDP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_xti_udp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* We now alter the message_ptr variables to be at the desired */
+  /* alignments with the desired offsets. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_udp_rr: requested recv alignment of %d offset %d\n",
+	    xti_udp_rr_request->recv_alignment,
+	    xti_udp_rr_request->recv_offset);
+    fprintf(where,"recv_xti_udp_rr: requested send alignment of %d offset %d\n",
+	    xti_udp_rr_request->send_alignment,
+	    xti_udp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   xti_udp_rr_request->request_size,
+				   xti_udp_rr_request->recv_alignment,
+				   xti_udp_rr_request->recv_offset);
+
+  send_ring = allocate_buffer_ring(send_width,
+				   xti_udp_rr_request->response_size,
+				   xti_udp_rr_request->send_alignment,
+				   xti_udp_rr_request->send_offset);
+
+  if (debug) {
+    fprintf(where,"recv_xti_udp_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* create_xti_endpoint expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size = xti_udp_rr_request->send_buf_size;
+  lsr_size = xti_udp_rr_request->recv_buf_size;
+  loc_rcvavoid = xti_udp_rr_request->so_rcvavoid;
+  loc_sndavoid = xti_udp_rr_request->so_sndavoid;
+
+#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 *) xti_udp_rr_request->xti_device;
+    lastword = initword + ((xti_udp_rr_request->dev_name_len + 3) / 4);
+    
+    for (charword = initword;
+	 charword < lastword;
+	 charword++) {
+      
+      *charword = htonl(*charword);
+    }
+  }
+  
+#endif /* __alpha */
+    
+  s_data = create_xti_endpoint(xti_udp_rr_request->xti_device);
+  
+  if (s_data == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,"recv_xti_udp_rr: endpoint created...\n");
+    fflush(where);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+
+  bind_req.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_req.addr.len    = sizeof(struct sockaddr_in);
+  bind_req.addr.buf    = (char *)&myaddr_in;
+  bind_req.qlen        = 1;
+
+  bind_resp.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_resp.addr.len    = sizeof(struct sockaddr_in);
+  bind_resp.addr.buf    = (char *)&myaddr_in;
+  bind_resp.qlen        = 1;
+
+  if (t_bind(s_data,
+	     &bind_req,
+	     &bind_resp) == SOCKET_ERROR) {
+    if (debug) {
+      fprintf(where,
+	      "recv_xti_udp_rr: t_bind failed, t_errno %d errno %d\n",
+	      t_errno,
+	      errno);
+      fflush(where);
+    }
+
+    netperf_response.content.serv_errno = t_errno;
+    send_response();
+    
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_udp_rr: endpoint bound to port %d...\n",
+	    ntohs(myaddr_in.sin_port));
+    fflush(where);
+  }
+
+  xti_udp_rr_response->test_length = 
+    xti_udp_rr_request->test_length;
+
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  xti_udp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  netperf_response.content.serv_errno   = 0;
+  
+  fprintf(where,"recv port number %d\n",myaddr_in.sin_port);
+  fflush(where);
+  
+  /* 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. */
+  
+  xti_udp_rr_response->cpu_rate    = 0.0; 	/* assume no cpu */
+  xti_udp_rr_response->measure_cpu = 0;
+  if (xti_udp_rr_request->measure_cpu) {
+    xti_udp_rr_response->measure_cpu = 1;
+    xti_udp_rr_response->cpu_rate = 
+      calibrate_local_cpu(xti_udp_rr_request->cpu_rate);
+  }
+   
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  xti_udp_rr_response->send_buf_size = lss_size;
+  xti_udp_rr_response->recv_buf_size = lsr_size;
+  xti_udp_rr_response->so_rcvavoid   = loc_rcvavoid;
+  xti_udp_rr_response->so_sndavoid   = loc_sndavoid;
+ 
+  /* since we are going to call t_rcvudata() instead of t_rcv() we */
+  /* need to init the unitdata structure raj 3/95 */
+
+  memset (&recv_unitdata, 0, sizeof(recv_unitdata));
+  recv_unitdata.addr.maxlen = sizeof(struct sockaddr_in);
+  recv_unitdata.addr.len    = sizeof(struct sockaddr_in);
+  recv_unitdata.addr.buf    = (char *)&peeraddr_in;
+
+  recv_unitdata.opt.maxlen = 0;
+  recv_unitdata.opt.len    = 0;
+  recv_unitdata.opt.buf    = NULL;
+
+  recv_unitdata.udata.maxlen = xti_udp_rr_request->request_size;
+  recv_unitdata.udata.len    = xti_udp_rr_request->request_size;
+  recv_unitdata.udata.buf    = recv_ring->buffer_ptr;
+
+  /* since we are going to call t_sndudata() instead of t_snd() we */
+  /* need to init the unitdata structure raj 8/95 */
+
+  memset (&send_unitdata, 0, sizeof(send_unitdata));
+  send_unitdata.addr.maxlen = sizeof(struct sockaddr_in);
+  send_unitdata.addr.len    = sizeof(struct sockaddr_in);
+  send_unitdata.addr.buf    = (char *)&peeraddr_in;
+
+  send_unitdata.opt.maxlen = 0;
+  send_unitdata.opt.len    = 0;
+  send_unitdata.opt.buf    = NULL;
+
+  send_unitdata.udata.maxlen = xti_udp_rr_request->response_size;
+  send_unitdata.udata.len    = xti_udp_rr_request->response_size;
+  send_unitdata.udata.buf    = send_ring->buffer_ptr;
+
+  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(xti_udp_rr_request->measure_cpu);
+  
+  if (xti_udp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(xti_udp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = xti_udp_rr_request->test_length * -1;
+  }
+  
+  addrlen = sizeof(peeraddr_in);
+  bzero((char *)&peeraddr_in, addrlen);
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+    
+    /* receive the request from the other side */
+    if (t_rcvudata(s_data,
+		   &recv_unitdata,
+		   &flags) != 0) {
+      if (errno == TNODATA) {
+	continue;
+      }
+      if (errno == EINTR) {
+	/* we must have hit the end of test time. */
+	break;
+      }
+      if (debug) {
+	fprintf(where,
+		"recv_xti_udp_rr: t_rcvudata failed, t_errno %d errno %d\n",
+		t_errno,
+		errno);
+	fflush(where);
+      }
+      netperf_response.content.serv_errno = t_errno;
+      send_response();
+      exit(1);
+    }
+    recv_ring = recv_ring->next;
+    recv_unitdata.udata.buf = recv_ring->buffer_ptr;
+
+    /* Now, send the response to the remote */
+    if (t_sndudata(s_data,
+		   &send_unitdata) != 0) {
+      if (errno == EINTR) {
+	/* we have hit end of test time. */
+	break;
+      }
+      if (debug) {
+	fprintf(where,
+		"recv_xti_udp_rr: t_sndudata failed, t_errno %d errno %d\n",
+		t_errno,
+		errno);
+	fflush(where);
+      }
+      netperf_response.content.serv_errno = errno;
+      send_response();
+      exit(1);
+    }
+    send_ring = send_ring->next;
+    send_unitdata.udata.buf = send_ring->buffer_ptr;
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_xti_udp_rr: Transaction %d complete.\n",
+	      trans_received);
+      fflush(where);
+    }
+    
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(xti_udp_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_xti_udp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  xti_udp_rr_results->bytes_received = (trans_received * 
+				    (xti_udp_rr_request->request_size + 
+				     xti_udp_rr_request->response_size));
+  xti_udp_rr_results->trans_received = trans_received;
+  xti_udp_rr_results->elapsed_time	 = elapsed_time;
+  xti_udp_rr_results->cpu_method     = cpu_method;
+  if (xti_udp_rr_request->measure_cpu) {
+    xti_udp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_udp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+
+  /* we are done with the socket now */
+  close(s_data);
+
+}
+
+ /* this routine implements the receive (netserver) side of a XTI_TCP_RR */
+ /* test */
+void 
+recv_xti_tcp_rr()
+{
+  
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+
+  struct sockaddr_in  myaddr_in,  peeraddr_in;
+  struct t_bind bind_req, bind_resp;
+  struct t_call call_req;
+
+  SOCKET s_listen,s_data;
+  int 	addrlen;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	xti_tcp_rr_request_struct	*xti_tcp_rr_request;
+  struct	xti_tcp_rr_response_struct	*xti_tcp_rr_response;
+  struct	xti_tcp_rr_results_struct	*xti_tcp_rr_results;
+  
+  xti_tcp_rr_request = 
+    (struct xti_tcp_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_rr_response =
+    (struct xti_tcp_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_rr_results =
+    (struct xti_tcp_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_xti_tcp_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_xti_tcp_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = XTI_TCP_RR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_rr: the response type is set...\n");
+    fflush(where);
+  }
+  
+  /* allocate the recv and send rings with the requested alignments */
+  /* and offsets. raj 7/94 */
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_rr: requested recv alignment of %d offset %d\n",
+	    xti_tcp_rr_request->recv_alignment,
+	    xti_tcp_rr_request->recv_offset);
+    fprintf(where,"recv_xti_tcp_rr: requested send alignment of %d offset %d\n",
+	    xti_tcp_rr_request->send_alignment,
+	    xti_tcp_rr_request->send_offset);
+    fflush(where);
+  }
+
+  /* at some point, these need to come to us from the remote system */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   xti_tcp_rr_request->response_size,
+				   xti_tcp_rr_request->send_alignment,
+				   xti_tcp_rr_request->send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   xti_tcp_rr_request->request_size,
+				   xti_tcp_rr_request->recv_alignment,
+				   xti_tcp_rr_request->recv_offset);
+
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = 0;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_xti_endpoint expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size = xti_tcp_rr_request->send_buf_size;
+  lsr_size = xti_tcp_rr_request->recv_buf_size;
+  loc_nodelay = xti_tcp_rr_request->no_delay;
+  loc_rcvavoid = xti_tcp_rr_request->so_rcvavoid;
+  loc_sndavoid = xti_tcp_rr_request->so_sndavoid;
+  
+#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 *) xti_tcp_rr_request->xti_device;
+    lastword = initword + ((xti_tcp_rr_request->dev_name_len + 3) / 4);
+    
+    for (charword = initword;
+	 charword < lastword;
+	 charword++) {
+      
+      *charword = htonl(*charword);
+    }
+  }
+  
+#endif /* __alpha */
+
+  s_listen = create_xti_endpoint(xti_tcp_rr_request->xti_device);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    
+    exit(1);
+  }
+  
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+
+  bind_req.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_req.addr.len    = sizeof(struct sockaddr_in);
+  bind_req.addr.buf    = (char *)&myaddr_in;
+  bind_req.qlen        = 1;
+
+  bind_resp.addr.maxlen = sizeof(struct sockaddr_in);
+  bind_resp.addr.len    = sizeof(struct sockaddr_in);
+  bind_resp.addr.buf    = (char *)&myaddr_in;
+  bind_resp.qlen        = 1;
+
+  if (t_bind(s_listen,
+	     &bind_req,
+	     &bind_resp) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = t_errno;
+    close(s_listen);
+    send_response();
+    
+    exit(1);
+  }
+
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: t_bind complete port %d\n",
+	    ntohs(myaddr_in.sin_port));
+    fflush(where);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  xti_tcp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  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. */
+  
+  xti_tcp_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  xti_tcp_rr_response->measure_cpu = 0;
+
+  if (xti_tcp_rr_request->measure_cpu) {
+    xti_tcp_rr_response->measure_cpu = 1;
+    xti_tcp_rr_response->cpu_rate = calibrate_local_cpu(xti_tcp_rr_request->cpu_rate);
+  }
+  
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  xti_tcp_rr_response->send_buf_size = lss_size;
+  xti_tcp_rr_response->recv_buf_size = lsr_size;
+  xti_tcp_rr_response->no_delay = loc_nodelay;
+  xti_tcp_rr_response->so_rcvavoid = loc_rcvavoid;
+  xti_tcp_rr_response->so_sndavoid = loc_sndavoid;
+  xti_tcp_rr_response->test_length = xti_tcp_rr_request->test_length;
+  send_response();
+  
+  /* Now, let's set-up the socket to listen for connections. for xti, */
+  /* the t_listen call is blocking by default - this is different */
+  /* semantics from BSD - probably has to do with being able to reject */
+  /* a call before an accept */
+  call_req.addr.maxlen = sizeof(struct sockaddr_in);
+  call_req.addr.len    = sizeof(struct sockaddr_in);
+  call_req.addr.buf    = (char *)&peeraddr_in;
+  call_req.opt.maxlen  = 0;
+  call_req.opt.len     = 0;
+  call_req.opt.buf     = NULL;
+  call_req.udata.maxlen= 0;
+  call_req.udata.len   = 0;
+  call_req.udata.buf   = 0;
+
+  if (t_listen(s_listen, &call_req) == -1) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: t_listen: errno %d t_errno %d\n",
+	    errno,
+	    t_errno);
+    fflush(where);
+    netperf_response.content.serv_errno = t_errno;
+    close(s_listen);
+    send_response();
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: t_listen complete t_look 0x%.4x\n",
+	    t_look(s_listen));
+    fflush(where);
+  }
+  
+  /* now just rubber stamp the thing. we want to use the same fd? so */
+  /* we will just equate s_data with s_listen. this seems a little */
+  /* hokey to me, but then I'm a BSD biggot still. raj 2/95 */
+  s_data = s_listen;
+  if (t_accept(s_listen,
+	       s_data,
+	       &call_req) == -1) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: t_accept: errno %d t_errno %d\n",
+	    errno,
+	    t_errno);
+    fflush(where);
+    close(s_listen);
+    exit(1);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: t_accept complete t_look 0x%.4x",
+	    t_look(s_data));
+    fprintf(where,
+	    " remote is %s port %d\n",
+	    inet_ntoa(*(struct in_addr *)&peeraddr_in.sin_addr),
+	    ntohs(peeraddr_in.sin_port));
+    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(xti_tcp_rr_request->measure_cpu);
+  
+  if (xti_tcp_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(xti_tcp_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = xti_tcp_rr_request->test_length * -1;
+  }
+
+  trans_received = 0;
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+    temp_message_ptr = recv_ring->buffer_ptr;
+    request_bytes_remaining	= xti_tcp_rr_request->request_size;
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=t_rcv(s_data,
+				    temp_message_ptr,
+				    request_bytes_remaining,
+				    &xti_flags)) == SOCKET_ERROR) {
+	if (errno == EINTR) {
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	}
+	fprintf(where,
+		"recv_xti_tcp_rr: t_rcv: errno %d t_errno %d len %d",
+		errno,
+		t_errno,
+		request_bytes_recvd);
+	fprintf(where,
+		" t_look 0x%x",
+		t_look(s_data));
+	fflush(where);
+	netperf_response.content.serv_errno = t_errno;
+	send_response();
+	exit(1);
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      if (debug) {
+	fprintf(where,"yo5\n");
+	fflush(where);
+      }						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=t_snd(s_data,
+			 send_ring->buffer_ptr,
+			 xti_tcp_rr_request->response_size,
+			 0)) == -1) {
+      if (errno == EINTR) {
+	/* the test timer has popped */
+	timed_out = 1;
+	if (debug) {
+	  fprintf(where,"yo6\n");
+	  fflush(where);						
+	}
+	break;
+      }
+      fprintf(where,
+	      "recv_xti_tcp_rr: t_rcv: errno %d t_errno %d len %d",
+	      errno,
+	      t_errno,
+	      bytes_sent);
+      fprintf(where,
+	      " t_look 0x%x",
+	      t_look(s_data));
+      fflush(where);
+      netperf_response.content.serv_errno = t_errno;
+      send_response();
+      exit(1);
+    }
+    
+    send_ring = send_ring->next;
+
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(xti_tcp_rr_request->measure_cpu,&elapsed_time);
+  
+  stop_timer(); /* this is probably unnecessary, but it shouldn't hurt */
+
+  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_xti_tcp_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  xti_tcp_rr_results->bytes_received = (trans_received * 
+					(xti_tcp_rr_request->request_size + 
+					 xti_tcp_rr_request->response_size));
+  xti_tcp_rr_results->trans_received = trans_received;
+  xti_tcp_rr_results->elapsed_time   = elapsed_time;
+  xti_tcp_rr_results->cpu_method     = cpu_method;
+  if (xti_tcp_rr_request->measure_cpu) {
+    xti_tcp_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  /* we are done with the socket, free it */
+  t_close(s_data);
+
+  send_response();
+  
+}
+
+
+
+ /* this test is intended to test the performance of establishing a */
+ /* connection, exchanging a request/response pair, and repeating. it */
+ /* is expected that this would be a good starting-point for */
+ /* comparision of T/TCP with classic TCP for transactional workloads. */
+ /* it will also look (can look) much like the communication pattern */
+ /* of http for www access. */
+
+void 
+send_xti_tcp_conn_rr(char remote_host[])
+{
+  
+  char *tput_title = "\
+Local /Remote\n\
+Socket Size   Request  Resp.   Elapsed  Trans.\n\
+Send   Recv   Size     Size    Time     Rate         \n\
+bytes  Bytes  bytes    bytes   secs.    per sec   \n\n";
+  
+  char *tput_fmt_0 =
+    "%7.2f\n";
+  
+  char *tput_fmt_1_line_1 = "\
+%-6d %-6d %-6d   %-6d  %-6.2f   %7.2f   \n";
+  char *tput_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *cpu_title = "\
+Local /Remote\n\
+Socket Size   Request Resp.  Elapsed Trans.   CPU    CPU    S.dem   S.dem\n\
+Send   Recv   Size    Size   Time    Rate     local  remote local   remote\n\
+bytes  bytes  bytes   bytes  secs.   per sec  %%      %%      us/Tr   us/Tr\n\n";
+  
+  char *cpu_fmt_0 =
+    "%6.3f\n";
+  
+  char *cpu_fmt_1_line_1 = "\
+%-6d %-6d %-6d  %-6d %-6.2f  %-6.2f   %-6.2f %-6.2f %-6.3f  %-6.3f\n";
+  
+  char *cpu_fmt_1_line_2 = "\
+%-6d %-6d\n";
+  
+  char *ksink_fmt = "\
+Alignment      Offset\n\
+Local  Remote  Local  Remote\n\
+Send   Recv    Send   Recv\n\
+%5d  %5d   %5d  %5d\n";
+  
+  
+  int 			one = 1;
+  int			timed_out = 0;
+  float			elapsed_time;
+  
+  int	len;
+  struct ring_elt *send_ring;
+  struct ring_elt *recv_ring;
+  char	*temp_message_ptr;
+  int	nummessages;
+  SOCKET send_socket;
+  int	trans_remaining;
+  double	bytes_xferd;
+  int	sock_opt_len = sizeof(int);
+  int	rsp_bytes_left;
+  int	rsp_bytes_recvd;
+  
+  float	local_cpu_utilization;
+  float	local_service_demand;
+  float	remote_cpu_utilization;
+  float	remote_service_demand;
+  double	thruput;
+  
+  struct	hostent	        *hp;
+  struct	sockaddr_in	server;
+  struct        sockaddr_in     *myaddr;
+  unsigned      int             addr;
+  int                           myport;
+
+  struct	xti_tcp_conn_rr_request_struct	*xti_tcp_conn_rr_request;
+  struct	xti_tcp_conn_rr_response_struct	*xti_tcp_conn_rr_response;
+  struct	xti_tcp_conn_rr_results_struct	*xti_tcp_conn_rr_result;
+  
+  xti_tcp_conn_rr_request = 
+    (struct xti_tcp_conn_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_conn_rr_response = 
+    (struct xti_tcp_conn_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_conn_rr_result =
+    (struct xti_tcp_conn_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. */
+  
+  myaddr = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
+  if (myaddr == NULL) {
+    printf("malloc(%d) failed!\n", sizeof(struct sockaddr_in));
+    exit(1);
+  }
+
+  bzero((char *)&server,
+	sizeof(server));
+  bzero((char *)myaddr,
+	sizeof(struct sockaddr_in));
+  myaddr->sin_family = AF_INET;
+
+  /* it would seem that while HP-UX will allow an IP address (as a */
+  /* string) in a call to gethostbyname, other, less enlightened */
+  /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
+  /* order changed to check for IP address first. raj 7/96 */
+
+  if ((addr = inet_addr(remote_host)) == SOCKET_ERROR) {
+    /* it was not an IP address, try it as a name */
+    if ((hp = gethostbyname(remote_host)) == NULL) {
+      /* we have no idea what it is */
+      fprintf(where,
+	      "establish_control: could not resolve the destination %s\n",
+	      remote_host);
+      fflush(where);
+      exit(1);
+    }
+    else {
+      /* it was a valid remote_host */
+      bcopy(hp->h_addr,
+	    (char *)&server.sin_addr,
+	    hp->h_length);
+      server.sin_family = hp->h_addrtype;
+    }
+  }
+  else {
+    /* it was a valid IP address */
+    server.sin_addr.s_addr = addr;
+    server.sin_family = AF_INET;
+  }    
+  
+  if ( print_headers ) {
+    fprintf(where,"TCP Connect/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 */
+  if (send_width == 0) send_width = 1;
+  if (recv_width == 0) recv_width = 1;
+
+  send_ring = allocate_buffer_ring(send_width,
+				   req_size,
+				   local_send_align,
+				   local_send_offset);
+
+  recv_ring = allocate_buffer_ring(recv_width,
+				   rsp_size,
+				   local_recv_align,
+				   local_recv_offset);
+
+
+  if (debug) {
+    fprintf(where,"send_xti_tcp_conn_rr: send_socket obtained...\n");
+  }
+  
+  /* If the user has requested cpu utilization measurements, we must */
+  /* calibrate the cpu(s). We will perform this task within the tests */
+  /* themselves. If the user has specified the cpu rate, then */
+  /* calibrate_local_cpu will return rather quickly as it will have */
+  /* nothing to do. If local_cpu_rate is zero, then we will go through */
+  /* all the "normal" calibration stuff and return the rate back.*/
+  
+  if (local_cpu_usage) {
+    local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
+  }
+  
+  /* Tell the remote end to do a listen. The server alters the socket */
+  /* paramters on the other side at this point, hence the reason for */
+  /* all the values being passed in the setup message. If the user did */
+  /* not specify any of the parameters, they will be passed as 0, which */
+  /* will indicate to the remote that no changes beyond the system's */
+  /* default should be used. Alignment is the exception, it will */
+  /* default to 8, which will be no alignment alterations. */
+  
+  netperf_request.content.request_type	        =	DO_XTI_TCP_CRR;
+  xti_tcp_conn_rr_request->recv_buf_size	=	rsr_size;
+  xti_tcp_conn_rr_request->send_buf_size	=	rss_size;
+  xti_tcp_conn_rr_request->recv_alignment	=	remote_recv_align;
+  xti_tcp_conn_rr_request->recv_offset	=	remote_recv_offset;
+  xti_tcp_conn_rr_request->send_alignment	=	remote_send_align;
+  xti_tcp_conn_rr_request->send_offset	=	remote_send_offset;
+  xti_tcp_conn_rr_request->request_size	=	req_size;
+  xti_tcp_conn_rr_request->response_size	=	rsp_size;
+  xti_tcp_conn_rr_request->no_delay	        =	rem_nodelay;
+  xti_tcp_conn_rr_request->measure_cpu	=	remote_cpu_usage;
+  xti_tcp_conn_rr_request->cpu_rate	        =	remote_cpu_rate;
+  xti_tcp_conn_rr_request->so_rcvavoid	=	rem_rcvavoid;
+  xti_tcp_conn_rr_request->so_sndavoid	=	rem_sndavoid;
+  if (test_time) {
+    xti_tcp_conn_rr_request->test_length	=	test_time;
+  }
+  else {
+    xti_tcp_conn_rr_request->test_length	=	test_trans * -1;
+  }
+  
+  if (debug > 1) {
+    fprintf(where,"netperf: send_xti_tcp_conn_rr: requesting TCP crr 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) {
+    rsr_size	=	xti_tcp_conn_rr_response->recv_buf_size;
+    rss_size	=	xti_tcp_conn_rr_response->send_buf_size;
+    rem_nodelay	=	xti_tcp_conn_rr_response->no_delay;
+    remote_cpu_usage=	xti_tcp_conn_rr_response->measure_cpu;
+    remote_cpu_rate = 	xti_tcp_conn_rr_response->cpu_rate;
+    /* make sure that port numbers are in network order */
+    server.sin_port	=	(short)xti_tcp_conn_rr_response->data_port_number;
+    server.sin_port =	htons(server.sin_port);
+    if (debug) {
+      fprintf(where,"remote listen done.\n");
+      fprintf(where,"remote port is %d\n",ntohs(server.sin_port));
+      fflush(where);
+    }
+  }
+  else {
+    Set_errno(netperf_response.content.serv_errno);
+    perror("netperf: remote error");
+    
+    exit(1);
+  }
+  
+  /* 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. */
+
+  /* just for grins, start the port numbers at 65530. this should */
+  /* quickly flush-out those broken implementations of TCP which treat */
+  /* the port number as a signed 16 bit quantity. */
+  myport = 65530;
+  myaddr->sin_port = htons(myport);
+  
+  while ((!times_up) || (trans_remaining > 0)) {
+
+    /* set up the data socket */
+    send_socket = create_xti_endpoint(loc_xti_device);
+  
+    if (send_socket == INVALID_SOCKET) {
+      perror("netperf: send_xti_tcp_conn_rr: tcp stream data socket");
+      exit(1);
+    }
+
+    /* we set SO_REUSEADDR on the premis that no unreserved port */
+    /* number on the local system is going to be already connected to */
+    /* the remote netserver's port number. we might still have a */
+    /* problem if there is a port in the unconnected state. In that */
+    /* case, we might want to throw-in a goto to the point where we */
+    /* increment the port number by one and try again. of course, this */
+    /* could lead to a big load of spinning. one thing that I might */
+    /* try later is to have the remote actually allocate a couple of */
+    /* port numbers and cycle through those as well. depends on if we */
+    /* can get through all the unreserved port numbers in less than */
+    /* the length of the TIME_WAIT state raj 8/94 */
+    one = 1;
+    if(setsockopt(send_socket, SOL_SOCKET, SO_REUSEADDR,
+		  (char *)&one, sock_opt_len) == SOCKET_ERROR) {
+      perror("netperf: send_xti_tcp_conn_rr: so_reuseaddr");
+      exit(1);
+    }
+
+    /* we want to bind our socket to a particular port number. */
+    if (bind(send_socket,
+	     (struct sockaddr *)myaddr,
+	     sizeof(struct sockaddr_in)) == SOCKET_ERROR) {
+      printf("netperf: send_xti_tcp_conn_rr: tried to bind to port %d\n",
+	     ntohs(myaddr->sin_port));
+      perror("netperf: send_xti_tcp_conn_rr: bind");
+      exit(1);
+    }
+
+    /* Connect up to the remote port on the data socket  */
+    if (connect(send_socket, 
+		(struct sockaddr *)&server,
+		sizeof(server)) == INVALID_SOCKET){
+      if (errno == EINTR) {
+	/* we hit the end of a */
+	/* timed test. */
+	timed_out = 1;
+	break;
+      }
+      perror("netperf: data socket connect failed");
+      printf("\tattempted to connect on socket %d to port %d",
+	     send_socket,
+	     ntohs(server.sin_port));
+      printf(" from port %d \n",ntohs(myaddr->sin_port));
+      exit(1);
+    }
+
+    /* send the request */
+    if((len=send(send_socket,
+		 send_ring->buffer_ptr,
+		 req_size,
+		 0)) != req_size) {
+      if (errno == EINTR) {
+	/* we hit the end of a */
+	/* timed test. */
+	timed_out = 1;
+	break;
+      }
+      perror("send_xti_tcp_conn_rr: data send error");
+      exit(1);
+    }
+    send_ring = send_ring->next;
+
+    /* receive the response */
+    rsp_bytes_left = rsp_size;
+    temp_message_ptr  = recv_ring->buffer_ptr;
+    while(rsp_bytes_left > 0) {
+      if((rsp_bytes_recvd=recv(send_socket,
+			       temp_message_ptr,
+			       rsp_bytes_left,
+			       0)) == SOCKET_ERROR) {
+	if (errno == EINTR) {
+	  /* We hit the end of a timed test. */
+	  timed_out = 1;
+	  break;
+	}
+	perror("send_xti_tcp_conn_rr: data recv error");
+	exit(1);
+      }
+      rsp_bytes_left -= rsp_bytes_recvd;
+      temp_message_ptr  += rsp_bytes_recvd;
+    }	
+    recv_ring = recv_ring->next;
+
+    if (timed_out) {
+      /* we may have been in a nested while loop - we need */
+      /* another call to break. */
+      break;
+    }
+
+    close(send_socket);
+
+    nummessages++;          
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug > 3) {
+      fprintf(where,
+	      "Transaction %d completed on local port %d\n",
+	      nummessages,
+	      ntohs(myaddr->sin_port));
+      fflush(where);
+    }
+
+newport:
+    /* pick a new port number */
+    myport = ntohs(myaddr->sin_port);
+    myport++;
+    /* we do not want to use the port number that the server is */
+    /* sitting at - this would cause us to fail in a loopback test */
+
+    if (myport == ntohs(server.sin_port)) myport++;
+
+    /* wrap the port number when we get to 65535. NOTE, some broken */
+    /* TCP's might treat the port number as a signed 16 bit quantity. */
+    /* we aren't interested in testing such broekn implementations :) */
+    /* raj 8/94  */
+    if (myport == 65535) {
+      myport = 5000;
+    }
+    myaddr->sin_port = htons(myport);
+
+    if (debug) {
+      if ((myport % 1000) == 0) {
+	printf("port %d\n",myport);
+      }
+    }
+
+  }
+  
+  /* 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 = xti_tcp_conn_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,
+						  xti_tcp_conn_rr_result->num_cpus);
+    }
+    else {
+      remote_cpu_utilization = -1.0;
+      remote_service_demand  = -1.0;
+    }
+    
+    /* We are now ready to print all the information. If the user */
+    /* has specified zero-level verbosity, we will just print the */
+    /* local service demand, or the remote service demand. If the */
+    /* user has requested verbosity level 1, he will get the basic */
+    /* "streamperf" numbers. If the user has specified a verbosity */
+    /* of greater than 1, we will display a veritable plethora of */
+    /* background information from outside of this block as it it */
+    /* not cpu_measurement specific...  */
+    
+    switch (verbosity) {
+    case 0:
+      if (local_cpu_usage) {
+	fprintf(where,
+		cpu_fmt_0,
+		local_service_demand);
+      }
+      else {
+	fprintf(where,
+		cpu_fmt_0,
+		remote_service_demand);
+      }
+      break;
+    case 1:
+      fprintf(where,
+	      cpu_fmt_1_line_1,		/* the format string */
+	      lss_size,		/* local sendbuf size */
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* guess */
+	      elapsed_time,		/* how long was the test */
+	      nummessages/elapsed_time,
+	      local_cpu_utilization,	/* local cpu */
+	      remote_cpu_utilization,	/* remote cpu */
+	      local_service_demand,	/* local service demand */
+	      remote_service_demand);	/* remote service demand */
+      fprintf(where,
+	      cpu_fmt_1_line_2,
+	      rss_size,
+	      rsr_size);
+      break;
+    }
+  }
+  else {
+    /* The tester did not wish to measure service demand. */
+    switch (verbosity) {
+    case 0:
+      fprintf(where,
+	      tput_fmt_0,
+	      nummessages/elapsed_time);
+      break;
+    case 1:
+      fprintf(where,
+	      tput_fmt_1_line_1,	/* the format string */
+	      lss_size,
+	      lsr_size,
+	      req_size,		/* how large were the requests */
+	      rsp_size,		/* how large were the responses */
+	      elapsed_time, 		/* how long did it take */
+	      nummessages/elapsed_time);
+      fprintf(where,
+	      tput_fmt_1_line_2,
+	      rss_size, 		/* remote recvbuf size */
+	      rsr_size);
+      
+      break;
+    }
+  }
+  
+  /* it would be a good thing to include information about some of the */
+  /* other parameters that may have been set for this test, but at the */
+  /* moment, I do not wish to figure-out all the  formatting, so I will */
+  /* just put this comment here to help remind me that it is something */
+  /* that should be done at a later time. */
+  
+  if (verbosity > 1) {
+    /* The user wanted to know it all, so we will give it to him. */
+    /* This information will include as much as we can find about */
+    /* TCP statistics, the alignments of the sends and receives */
+    /* and all that sort of rot... */
+    
+    fprintf(where,
+	    ksink_fmt);
+  }
+  
+}
+
+
+void 
+recv_xti_tcp_conn_rr()
+{
+  
+  char  *message;
+  struct	sockaddr_in        myaddr_in,
+  peeraddr_in;
+  SOCKET s_listen,s_data;
+  int 	addrlen;
+  char	*recv_message_ptr;
+  char	*send_message_ptr;
+  char	*temp_message_ptr;
+  int	trans_received;
+  int	trans_remaining;
+  int	bytes_sent;
+  int	request_bytes_recvd;
+  int	request_bytes_remaining;
+  int	timed_out = 0;
+  float	elapsed_time;
+  
+  struct	xti_tcp_conn_rr_request_struct	*xti_tcp_conn_rr_request;
+  struct	xti_tcp_conn_rr_response_struct	*xti_tcp_conn_rr_response;
+  struct	xti_tcp_conn_rr_results_struct	*xti_tcp_conn_rr_results;
+  
+  xti_tcp_conn_rr_request = 
+    (struct xti_tcp_conn_rr_request_struct *)netperf_request.content.test_specific_data;
+  xti_tcp_conn_rr_response = 
+    (struct xti_tcp_conn_rr_response_struct *)netperf_response.content.test_specific_data;
+  xti_tcp_conn_rr_results = 
+    (struct xti_tcp_conn_rr_results_struct *)netperf_response.content.test_specific_data;
+  
+  if (debug) {
+    fprintf(where,"netserver: recv_xti_tcp_conn_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_xti_tcp_conn_rr: setting the response type...\n");
+    fflush(where);
+  }
+  
+  netperf_response.content.response_type = XTI_TCP_CRR_RESPONSE;
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_conn_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_xti_tcp_conn_rr: requested recv alignment of %d offset %d\n",
+	    xti_tcp_conn_rr_request->recv_alignment,
+	    xti_tcp_conn_rr_request->recv_offset);
+    fprintf(where,
+	    "recv_xti_tcp_conn_rr: requested send alignment of %d offset %d\n",
+	    xti_tcp_conn_rr_request->send_alignment,
+	    xti_tcp_conn_rr_request->send_offset);
+    fflush(where);
+  }
+
+  recv_message_ptr = ALIGN_BUFFER(message, xti_tcp_conn_rr_request->recv_alignment, xti_tcp_conn_rr_request->recv_offset);
+  
+  send_message_ptr = ALIGN_BUFFER(message, xti_tcp_conn_rr_request->send_alignment, xti_tcp_conn_rr_request->send_offset);
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_conn_rr: receive alignment and offset set...\n");
+    fflush(where);
+  }
+  
+  /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
+  /* can put in OUR values !-) At some point, we may want to nail this */
+  /* socket to a particular network-level address, but for now, */
+  /* INADDR_ANY should be just fine. */
+  
+  bzero((char *)&myaddr_in,
+	sizeof(myaddr_in));
+  myaddr_in.sin_family      = AF_INET;
+  myaddr_in.sin_addr.s_addr = INADDR_ANY;
+  myaddr_in.sin_port        = 0;
+  
+  /* Grab a socket to listen on, and then listen on it. */
+  
+  if (debug) {
+    fprintf(where,"recv_xti_tcp_conn_rr: grabbing a socket...\n");
+    fflush(where);
+  }
+
+  /* create_xti_endpoint expects to find some things in the global */
+  /* variables, so set the globals based on the values in the request. */
+  /* once the socket has been created, we will set the response values */
+  /* based on the updated value of those globals. raj 7/94 */
+  lss_size = xti_tcp_conn_rr_request->send_buf_size;
+  lsr_size = xti_tcp_conn_rr_request->recv_buf_size;
+  loc_nodelay = xti_tcp_conn_rr_request->no_delay;
+  loc_rcvavoid = xti_tcp_conn_rr_request->so_rcvavoid;
+  loc_sndavoid = xti_tcp_conn_rr_request->so_sndavoid;
+  
+  s_listen = create_xti_endpoint(loc_xti_device);
+  
+  if (s_listen == INVALID_SOCKET) {
+    netperf_response.content.serv_errno = errno;
+    send_response();
+    if (debug) {
+      fprintf(where,"could not create data socket\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+  /* Let's get an address assigned to this socket so we can tell the */
+  /* initiator how to reach the data socket. There may be a desire to */
+  /* nail this socket to a specific IP address in a multi-homed, */
+  /* multi-connection situation, but for now, we'll ignore the issue */
+  /* and concentrate on single connection testing. */
+  
+  if (bind(s_listen,
+	   (struct sockaddr *)&myaddr_in,
+	   sizeof(myaddr_in)) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not bind\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+
+  /* Now, let's set-up the socket to listen for connections */
+  if (listen(s_listen, 5) == SOCKET_ERROR) {
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not listen\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* now get the port number assigned by the system  */
+  addrlen = sizeof(myaddr_in);
+  if (getsockname(s_listen,
+		  (struct sockaddr *)&myaddr_in,
+		  &addrlen) == SOCKET_ERROR){
+    netperf_response.content.serv_errno = errno;
+    close(s_listen);
+    send_response();
+    if (debug) {
+      fprintf(where,"could not geetsockname\n");
+      fflush(where);
+    }
+    exit(1);
+  }
+  
+  /* Now myaddr_in contains the port and the internet address this is */
+  /* returned to the sender also implicitly telling the sender that the */
+  /* socket buffer sizing has been done. */
+  
+  xti_tcp_conn_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
+  if (debug) {
+    fprintf(where,"telling the remote to call me at %d\n",
+	    xti_tcp_conn_rr_response->data_port_number);
+    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 0.0 to */
+  /* the initiator. */
+  
+  xti_tcp_conn_rr_response->cpu_rate = 0.0; 	/* assume no cpu */
+  if (xti_tcp_conn_rr_request->measure_cpu) {
+    xti_tcp_conn_rr_response->measure_cpu = 1;
+    xti_tcp_conn_rr_response->cpu_rate = 
+      calibrate_local_cpu(xti_tcp_conn_rr_request->cpu_rate);
+  }
+  
+
+  
+  /* before we send the response back to the initiator, pull some of */
+  /* the socket parms from the globals */
+  xti_tcp_conn_rr_response->send_buf_size = lss_size;
+  xti_tcp_conn_rr_response->recv_buf_size = lsr_size;
+  xti_tcp_conn_rr_response->no_delay = loc_nodelay;
+  xti_tcp_conn_rr_response->so_rcvavoid = loc_rcvavoid;
+  xti_tcp_conn_rr_response->so_sndavoid = loc_sndavoid;
+
+  send_response();
+  
+  addrlen = sizeof(peeraddr_in);
+  
+  /* Now it's time to start receiving data on the connection. We will */
+  /* first grab the apropriate counters and then start grabbing. */
+  
+  cpu_start(xti_tcp_conn_rr_request->measure_cpu);
+  
+  /* The loop will exit when the sender does a shutdown, which will */
+  /* return a length of zero   */
+  
+  if (xti_tcp_conn_rr_request->test_length > 0) {
+    times_up = 0;
+    trans_remaining = 0;
+    start_timer(xti_tcp_conn_rr_request->test_length + PAD_TIME);
+  }
+  else {
+    times_up = 1;
+    trans_remaining = xti_tcp_conn_rr_request->test_length * -1;
+  }
+  
+  trans_received = 0;
+
+  while ((!times_up) || (trans_remaining > 0)) {
+
+    /* accept a connection from the remote */
+    if ((s_data=accept(s_listen,
+		       (struct sockaddr *)&peeraddr_in,
+		       &addrlen)) == INVALID_SOCKET) {
+      if (errno == EINTR) {
+	/* the timer popped */
+	timed_out = 1;
+	break;
+      }
+      fprintf(where,"recv_xti_tcp_conn_rr: accept: errno = %d\n",errno);
+      fflush(where);
+      close(s_listen);
+      
+      exit(1);
+    }
+  
+    if (debug) {
+      fprintf(where,"recv_xti_tcp_conn_rr: accepted data connection.\n");
+      fflush(where);
+    }
+  
+    temp_message_ptr	= recv_message_ptr;
+    request_bytes_remaining	= xti_tcp_conn_rr_request->request_size;
+    
+    /* receive the request from the other side */
+    while(request_bytes_remaining > 0) {
+      if((request_bytes_recvd=recv(s_data,
+				   temp_message_ptr,
+				   request_bytes_remaining,
+				   0)) == SOCKET_ERROR) {
+	if (errno == EINTR) {
+	  /* the timer popped */
+	  timed_out = 1;
+	  break;
+	}
+	netperf_response.content.serv_errno = errno;
+	send_response();
+	exit(1);
+      }
+      else {
+	request_bytes_remaining -= request_bytes_recvd;
+	temp_message_ptr  += request_bytes_recvd;
+      }
+    }
+    
+    if (timed_out) {
+      /* we hit the end of the test based on time - lets */
+      /* bail out of here now... */
+      fprintf(where,"yo5\n");
+      fflush(where);						
+      break;
+    }
+    
+    /* Now, send the response to the remote */
+    if((bytes_sent=send(s_data,
+			send_message_ptr,
+			xti_tcp_conn_rr_request->response_size,
+			0)) == SOCKET_ERROR) {
+      if (errno == EINTR) {
+	/* the test timer has popped */
+	timed_out = 1;
+	fprintf(where,"yo6\n");
+	fflush(where);						
+	break;
+      }
+      netperf_response.content.serv_errno = 99;
+      send_response();
+      exit(1);
+    }
+    
+    trans_received++;
+    if (trans_remaining) {
+      trans_remaining--;
+    }
+    
+    if (debug) {
+      fprintf(where,
+	      "recv_xti_tcp_conn_rr: Transaction %d complete\n",
+	      trans_received);
+      fflush(where);
+    }
+
+    /* close the connection */
+    close(s_data);
+
+  }
+  
+  
+  /* The loop now exits due to timeout or transaction count being */
+  /* reached */
+  
+  cpu_stop(xti_tcp_conn_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_xti_tcp_conn_rr: got %d transactions\n",
+	    trans_received);
+    fflush(where);
+  }
+  
+  xti_tcp_conn_rr_results->bytes_received	= (trans_received * 
+					   (xti_tcp_conn_rr_request->request_size + 
+					    xti_tcp_conn_rr_request->response_size));
+  xti_tcp_conn_rr_results->trans_received	= trans_received;
+  xti_tcp_conn_rr_results->elapsed_time	= elapsed_time;
+  if (xti_tcp_conn_rr_request->measure_cpu) {
+    xti_tcp_conn_rr_results->cpu_util	= calc_cpu_util(elapsed_time);
+  }
+  
+  if (debug) {
+    fprintf(where,
+	    "recv_xti_tcp_conn_rr: test complete, sending results.\n");
+    fflush(where);
+  }
+  
+  send_response();
+  
+}
+
+void
+print_xti_usage()
+{
+
+  fwrite(xti_usage, sizeof(char), strlen(xti_usage), stdout);
+  exit(1);
+
+}
+
+void
+scan_xti_args(int argc, char *argv[])
+{
+#define XTI_ARGS "Dhm:M:r:s:S:Vw:W:X:"
+  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 XTI tests do not know how to run with no control connection\n");
+    exit(-1);
+  }
+
+  /* Go through all the command line arguments and break them */
+  /* out. For those options that take two parms, specifying only */
+  /* the first will set both to that value. Specifying only the */
+  /* second will leave the first untouched. To change only the */
+  /* first, use the form "first," (see the routine break_args.. */
+  
+  while ((c= getopt(argc, argv, XTI_ARGS)) != EOF) {
+    switch (c) {
+    case '?':	
+    case 'h':
+      print_xti_usage();
+      exit(1);
+    case 'D':
+      /* set the TCP nodelay flag */
+      loc_nodelay = 1;
+      rem_nodelay = 1;
+      break;
+    case 's':
+      /* set local socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	lss_size = convert(arg1);
+      if (arg2[0])
+	lsr_size = convert(arg2);
+      break;
+    case 'S':
+      /* set remote socket sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	rss_size = convert(arg1);
+      if (arg2[0])
+	rsr_size = convert(arg2);
+      break;
+    case 'r':
+      /* set the request/response sizes */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	req_size = convert(arg1);
+      if (arg2[0])	
+	rsp_size = convert(arg2);
+      break;
+    case 'm':
+      /* set the send size */
+      send_size = convert(optarg);
+      break;
+    case 'M':
+      /* set the recv size */
+      recv_size = convert(optarg);
+      break;
+    case 'W':
+      /* set the "width" of the user space data */
+      /* buffer. This will be the number of */
+      /* send_size buffers malloc'd in the */
+      /* *_STREAM test. It may be enhanced to set */
+      /* both send and receive "widths" but for now */
+      /* it is just the sending *_STREAM. */
+      send_width = convert(optarg);
+      break;
+    case 'V' :
+      /* we want to do copy avoidance and will set */
+      /* it for everything, everywhere, if we really */
+      /* can. of course, we don't know anything */
+      /* about the remote... */
+#ifdef SO_SND_COPYAVOID
+      loc_sndavoid = 1;
+#else
+      loc_sndavoid = 0;
+      printf("Local send copy avoidance not available.\n");
+#endif
+#ifdef SO_RCV_COPYAVOID
+      loc_rcvavoid = 1;
+#else
+      loc_rcvavoid = 0;
+      printf("Local recv copy avoidance not available.\n");
+#endif
+      rem_sndavoid = 1;
+      rem_rcvavoid = 1;
+      break;
+    case 'X':
+      /* set the xti device file name(s) */
+      break_args(optarg,arg1,arg2);
+      if (arg1[0])
+	strcpy(loc_xti_device,arg1);
+      if (arg2[0])
+	strcpy(rem_xti_device,arg2);
+      break;
+    };
+  }
+}
+#endif /* WANT_XTI */
diff --git a/nettest_xti.h b/nettest_xti.h
new file mode 100644
index 0000000..3bf9968
--- /dev/null
+++ b/nettest_xti.h
@@ -0,0 +1,264 @@
+/*
+ *       Copyright (C) 1995,2004 Hewlett-Packard Company
+ */
+
+ /* This file contains the test-specific definitions for netperf's BSD */
+ /* sockets tests */
+
+struct	xti_tcp_stream_request_struct {
+  int	send_buf_size;
+  int	recv_buf_size;	/* how big does the client want it - the */
+			/* receive socket buffer that is */ 
+  int	receive_size;   /* how many bytes do we want to receive at one */
+			/* time? */ 
+  int	recv_alignment; /* what is the alignment of the receive */
+			/* buffer? */ 
+  int	recv_offset;    /* and at what offset from that alignment? */ 
+  int	no_delay;       /* do we disable the nagle algorithm for send */
+			/* coalescing? */ 
+  int	measure_cpu;	/* does the client want server cpu utilization */
+			/* measured? */ 
+  float	cpu_rate;	/* do we know how fast the cpu is already? */ 
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid copies on */
+			/* receives? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dirty_count;    /* how many integers in the receive buffer */
+			/* should be made dirty before calling recv? */  
+  int   clean_count;    /* how many integers should be read from the */
+			/* recv buffer before calling recv? */ 
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  xti_device[32]; /* the path to the dlpi device */
+};
+
+struct	xti_tcp_stream_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	receive_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */ 
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct xti_tcp_stream_results_struct {
+  double         bytes_received;
+  unsigned int	 recv_calls;	
+  float	         elapsed_time;	/* how long the test ran */
+  float	         cpu_util;	/* -1 if not measured */
+  float	         serv_dem;	/* -1 if not measured */
+  int            cpu_method;    /* how was cpu util measured? */
+  int            num_cpus;      /* how many CPUs were there */
+};
+
+struct	xti_tcp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  xti_device[32]; /* the path to the dlpi device */
+};
+
+struct	xti_tcp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct xti_tcp_rr_results_struct {
+  unsigned int  bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs were there */
+};
+
+struct	xti_tcp_conn_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  xti_device[32]; /* the path to the dlpi device */
+};
+
+
+struct	xti_tcp_conn_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct xti_tcp_conn_rr_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs were there */
+};
+
+struct	xti_udp_stream_request_struct {
+  int	recv_buf_size;
+  int	message_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	checksum_off;   /* not used. left in for compatibility */
+  int	measure_cpu;
+  float	cpu_rate;
+  int	test_length;
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  xti_device[32]; /* the path to the dlpi device */
+};
+
+struct	xti_udp_stream_response_struct {
+  int	recv_buf_size;
+  int	send_buf_size;
+  int	measure_cpu;
+  int	test_length;
+  int	data_port_number;
+  float	cpu_rate;
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct	xti_udp_stream_results_struct {
+  unsigned int	messages_recvd;
+  unsigned int	bytes_received;
+  float	        elapsed_time;
+  float	        cpu_util;
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs were there */
+};
+
+
+struct	xti_udp_rr_request_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	send_buf_size;
+  int	recv_alignment;
+  int	recv_offset;
+  int	send_alignment;
+  int	send_offset;
+  int	request_size;
+  int	response_size;
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  float	cpu_rate;	/* do we know how fast the cpu is?	*/
+  int	test_length;	/* how long is the test?		*/
+  int	so_rcvavoid;    /* do we want the remote to avoid receive */
+			/* copies? */ 
+  int	so_sndavoid;    /* do we want the remote to avoid send copies? */
+  int   dev_name_len;   /* the length of the device name string. this */
+			/* is used to put it into the proper order on */
+			/* @#$% byte-swapped boxes... */
+  char  xti_device[32]; /* the path to the dlpi device */
+};
+
+struct	xti_udp_rr_response_struct {
+  int	recv_buf_size;	/* how big does the client want it	*/
+  int	no_delay;
+  int	measure_cpu;	/* does the client want server cpu	*/
+  int	test_length;	/* how long is the test?		*/
+  int	send_buf_size;
+  int	data_port_number;	/* connect to me here	*/
+  float	cpu_rate;		/* could we measure	*/
+  int	so_rcvavoid;	/* could the remote avoid receive copies? */
+  int	so_sndavoid;	/* could the remote avoid send copies? */
+};
+
+struct xti_udp_rr_results_struct {
+  unsigned int	bytes_received;	/* ignored initially */
+  unsigned int	recv_calls;	/* ignored initially */
+  unsigned int	trans_received;	/* not ignored  */
+  float	        elapsed_time;	/* how long the test ran */
+  float	        cpu_util;	/* -1 if not measured */
+  float	        serv_dem;	/* -1 if not measured */
+  int           cpu_method;    /* how was cpu util measured? */
+  int           num_cpus;      /* how many CPUs were there */
+};
+
+extern void send_xti_tcp_stream(char remote_host[]);
+
+extern void recv_xti_tcp_stream();
+
+extern void send_xti_tcp_rr(char remote_host[]);
+
+extern void send_xti_udp_stream(char remote_host[]);
+
+extern void recv_xti_udp_stream();
+
+extern void send_xti_udp_rr(char remote_host[]);
+
+extern void recv_xti_udp_rr();
+
+extern void recv_xti_tcp_rr();
+
+extern void send_xti_tcp_conn_rr(char remote_host[]);
+
+extern void recv_xti_tcp_conn_rr();
+
+extern void scan_xti_args(int argc, char *argv[]);
+
+
+
+
+
+
+
+
+
+