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

#ifdef WANT_OMNI
char nettest_omni_id[]="\
@(#)nettest_omni.c (c) Copyright 2008 Hewlett-Packard Co. Version 2.5.0pre";

#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

#include <ctype.h>

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

#ifdef WANT_SCTP
#include <netinet/sctp.h>
#endif

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

#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_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_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); \
	    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_STREAM_INTERVAL(units) DEMO_INTERVAL(units)

#define DEMO_RR_SETUP(a) \
    if ((demo_mode) && (demo_units == 0)) { \
      /* take whatever we are given */ \
	demo_units = a; \
    }

#define DEMO_RR_INTERVAL(units) DEMO_INTERVAL(units)

#endif 

#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

#define NETPERF_WAITALL 0x1
#define NETPERF_XMIT 0x2
#define NETPERF_RECV 0x4

#define NETPERF_IS_RR(x) (((x & NETPERF_XMIT) && (x & NETPERF_RECV)) || \
			  (!((x & NETPERF_XMIT) || (x & NETPERF_RECV))))

#define NETPERF_RECV_ONLY(x) ((x & NETPERF_RECV) && !(x & NETPERF_XMIT))

#define NETPERF_XMIT_ONLY(x) ((x & NETPERF_XMIT) && !(x & NETPERF_RECV))

#define NETPERF_CC(x) (!(x & NETPERF_XMIT) && !(x & NETPERF_RECV))

extern void get_uuid_string(char *string, size_t size);

/* a boatload of globals while I settle things out */
char *csv_selection_file = NULL;
char *human_selection_file = NULL;
char *keyword_selection_file = NULL;

char test_uuid[38];

double result_confid_pct = -1.0;
double loc_cpu_confid_pct = -1.0;
double rem_cpu_confid_pct = -1.0;
double interval_pct = -1.0;

int protocol;
int direction;
int remote_send_size = -1;
int remote_recv_size = -1;
int remote_send_size_req = -1;
int remote_recv_size_req = -1;
int remote_use_sendfile;
#if 0
int remote_send_dirty_count;
int remote_recv_dirty_count;
int remote_recv_clean_count;
#endif
extern int loc_dirty_count;
extern int loc_clean_count;
extern int rem_dirty_count;
extern int rem_clean_count;
int remote_checksum_off;
int connection_test;
int need_to_connect;
int need_connection;
int bytes_to_send;
double bytes_per_send;
int failed_sends;
int bytes_to_recv;
double bytes_per_recv;
int null_message_ok = 0;
int csv = 0;
int keyword = 0;
uint64_t      trans_completed = 0;
uint64_t      units_remaining;
uint64_t      bytes_sent = 0;
uint64_t      bytes_received = 0;
uint64_t      local_send_calls = 0;
uint64_t      local_receive_calls = 0;
uint64_t      remote_bytes_sent;
uint64_t      remote_bytes_received;
uint64_t      remote_send_calls;
uint64_t      remote_receive_calls;
double        bytes_xferd;
double        remote_bytes_xferd;
double        remote_bytes_per_recv;
double        remote_bytes_per_send;
float         elapsed_time;
float         local_cpu_utilization;
float	      local_service_demand;
float         remote_cpu_utilization;
float	      remote_service_demand;
double	      thruput;
double        local_send_thruput;
double        local_recv_thruput;
double        remote_send_thruput;
double        remote_recv_thruput;

/* kludges for omni output */
double      elapsed_time_double;
double      local_cpu_utilization_double;
double      local_service_demand_double;
double      remote_cpu_utilization_double;
double      remote_service_demand_double;
double      transaction_rate = 1.0;
double      rtt_latency = -1.0;
int32_t     transport_mss = -2;
char        *local_interface_name=NULL;
char        *remote_interface_name=NULL;
char        local_driver_name[32]="";
char        local_driver_version[32]="";
char        local_driver_firmware[32]="";
char        local_driver_bus[32]="";
char        remote_driver_name[32]="";
char        remote_driver_version[32]="";
char        remote_driver_firmware[32]="";
char        remote_driver_bus[32]="";
char        *local_interface_slot=NULL;
char        *remote_interface_slot=NULL;
int         remote_interface_vendor;
int         remote_interface_device;
int         remote_interface_subvendor;
int         remote_interface_subdevice;
int         local_interface_vendor;
int         local_interface_device;
int         local_interface_subvendor;
int         local_interface_subdevice;
char        *local_system_model;
char        *local_cpu_model;
int         local_cpu_frequency;
char        *remote_system_model;
char        *remote_cpu_model;
int         remote_cpu_frequency;

int         local_security_type_id;
int         local_security_enabled_num;
char        *local_security_type;
char        *local_security_enabled;
char        *local_security_specific;
int         remote_security_type_id;
int         remote_security_enabled_num;
char        *remote_security_enabled;
char        *remote_security_type;
char        *remote_security_specific;

int printing_initialized = 0;

char *sd_str;
char *thruput_format_str;

char *socket_type_str;
char *protocol_str;
char *direction_str;

extern int first_burst_size;

#if defined(HAVE_SENDFILE) && (defined(__linux) || defined(__sun))
#include <sys/sendfile.h>
#endif /* HAVE_SENDFILE && (__linux || __sun) */

static int confidence_iteration;

static  int local_cpu_method;
static  int 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	*/
  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 int
  loc_tcpcork,
  rem_tcpcork,
  local_connected,
  remote_connected;

/* you should add to this in the order in which they should appear in
   the default csv (everything) output */

enum netperf_output_name {
  OUTPUT_NONE,
  SOCKET_TYPE,
  PROTOCOL,
  DIRECTION,
  ELAPSED_TIME,
  THROUGHPUT,
  THROUGHPUT_UNITS,
  LSS_SIZE_REQ,
  LSS_SIZE,
  LSS_SIZE_END,
  LSR_SIZE_REQ,
  LSR_SIZE,
  LSR_SIZE_END,
  RSS_SIZE_REQ,
  RSS_SIZE,
  RSS_SIZE_END,
  RSR_SIZE_REQ,
  RSR_SIZE,
  RSR_SIZE_END,
  LOCAL_SEND_SIZE,
  LOCAL_RECV_SIZE,
  REMOTE_SEND_SIZE,
  REMOTE_RECV_SIZE,
  REQUEST_SIZE,
  RESPONSE_SIZE,
  LOCAL_CPU_UTIL,
  LOCAL_CPU_METHOD,
  LOCAL_SD,
  REMOTE_CPU_UTIL,
  REMOTE_CPU_METHOD,
  REMOTE_SD,
  SD_UNITS,
  CONFIDENCE_LEVEL,
  CONFIDENCE_INTERVAL,
  CONFIDENCE_ITERATION,
  THROUGHPUT_CONFID,
  LOCAL_CPU_CONFID,
  REMOTE_CPU_CONFID,
  TRANSACTION_RATE,
  RT_LATENCY,
  BURST_SIZE,
  TRANSPORT_MSS,
  LOCAL_SEND_THROUGHPUT,
  LOCAL_RECV_THROUGHPUT,
  REMOTE_SEND_THROUGHPUT,
  REMOTE_RECV_THROUGHPUT,
  LOCAL_CPU_BIND,
  LOCAL_CPU_COUNT,
  LOCAL_CPU_PEAK_UTIL,
  LOCAL_CPU_PEAK_ID,
  LOCAL_CPU_MODEL,
  LOCAL_CPU_FREQUENCY,
  REMOTE_CPU_BIND,
  REMOTE_CPU_COUNT,
  REMOTE_CPU_PEAK_UTIL,
  REMOTE_CPU_PEAK_ID,
  REMOTE_CPU_MODEL,
  REMOTE_CPU_FREQUENCY,
  SOURCE_PORT,
  SOURCE_ADDR,
  SOURCE_FAMILY,
  DEST_PORT,
  DEST_ADDR,
  DEST_FAMILY,
  LOCAL_SEND_CALLS,
  LOCAL_RECV_CALLS,
  LOCAL_BYTES_PER_RECV,
  LOCAL_BYTES_PER_SEND,
  LOCAL_BYTES_SENT,
  LOCAL_BYTES_RECVD,
  LOCAL_BYTES_XFERD,
  LOCAL_SEND_OFFSET,
  LOCAL_RECV_OFFSET,
  LOCAL_SEND_ALIGN,
  LOCAL_RECV_ALIGN,
  LOCAL_SEND_WIDTH,
  LOCAL_RECV_WIDTH,
  LOCAL_SEND_DIRTY_COUNT,
  LOCAL_RECV_DIRTY_COUNT,
  LOCAL_RECV_CLEAN_COUNT,
  LOCAL_NODELAY,
  LOCAL_CORK,
  REMOTE_SEND_CALLS,
  REMOTE_RECV_CALLS,
  REMOTE_BYTES_PER_RECV,
  REMOTE_BYTES_PER_SEND,
  REMOTE_BYTES_SENT,
  REMOTE_BYTES_RECVD,
  REMOTE_BYTES_XFERD,
  REMOTE_SEND_OFFSET,
  REMOTE_RECV_OFFSET,
  REMOTE_SEND_ALIGN,
  REMOTE_RECV_ALIGN,
  REMOTE_SEND_WIDTH,
  REMOTE_RECV_WIDTH,
  REMOTE_SEND_DIRTY_COUNT,
  REMOTE_RECV_DIRTY_COUNT,
  REMOTE_RECV_CLEAN_COUNT,
  REMOTE_NODELAY,
  REMOTE_CORK,
  LOCAL_SYSNAME,
  LOCAL_SYSTEM_MODEL,
  LOCAL_RELEASE,
  LOCAL_VERSION,
  LOCAL_MACHINE,
  REMOTE_SYSNAME,
  REMOTE_SYSTEM_MODEL,
  REMOTE_RELEASE,
  REMOTE_VERSION,
  REMOTE_MACHINE,
  LOCAL_INTERFACE_NAME,
  LOCAL_INTERFACE_VENDOR,
  LOCAL_INTERFACE_DEVICE,
  LOCAL_INTERFACE_SUBVENDOR,
  LOCAL_INTERFACE_SUBDEVICE,
  LOCAL_DRIVER_NAME,
  LOCAL_DRIVER_VERSION,
  LOCAL_DRIVER_FIRMWARE,
  LOCAL_DRIVER_BUS,
  LOCAL_INTERFACE_SLOT,
  REMOTE_INTERFACE_NAME,
  REMOTE_INTERFACE_VENDOR,
  REMOTE_INTERFACE_DEVICE,
  REMOTE_INTERFACE_SUBVENDOR,
  REMOTE_INTERFACE_SUBDEVICE,
  REMOTE_DRIVER_NAME,
  REMOTE_DRIVER_VERSION,
  REMOTE_DRIVER_FIRMWARE,
  REMOTE_DRIVER_BUS,
  REMOTE_INTERFACE_SLOT,
  LOCAL_INTERVAL_USECS,
  LOCAL_INTERVAL_BURST,
  REMOTE_INTERVAL_USECS,
  REMOTE_INTERVAL_BURST,
  LOCAL_SECURITY_TYPE_ID,
  LOCAL_SECURITY_TYPE,
  LOCAL_SECURITY_ENABLED_NUM,
  LOCAL_SECURITY_ENABLED,
  LOCAL_SECURITY_SPECIFIC,
  REMOTE_SECURITY_TYPE_ID,
  REMOTE_SECURITY_TYPE,
  REMOTE_SECURITY_ENABLED_NUM,
  REMOTE_SECURITY_ENABLED,
  REMOTE_SECURITY_SPECIFIC,
  RESULT_BRAND,
  UUID,
  COMMAND_LINE,
  OUTPUT_END,
  NETPERF_OUTPUT_MAX
};

typedef struct netperf_output_elt {
  enum netperf_output_name output_name;  /* belt and suspenders */
  int max_line_len; /* length of the longest of the "lines" */
  int tot_line_len; /* total length of all lines, including spaces */
  char *line[4];
  char *brief;          /* the brief name of the value */
  char *format;         /* format to apply to value */
  void *display_value;  /* where to find the value */
} netperf_output_elt_t;

netperf_output_elt_t netperf_output_source[NETPERF_OUTPUT_MAX];

/* the list of things we will emit for CSV output.  I suppose we could
   at some point try to make this a special case of output_human_list,
   or at least use some of that space... but for now we won't worry
   about it.  that can come after things are actually working :) raj
   2008-01-23  */
enum netperf_output_name output_csv_list[NETPERF_OUTPUT_MAX];

/* the list of things we will emit for "human" output. up to
   NETPERF_MAX_BLOCKS of output (groups of lines) each out to
   NETPERF_OUTPUT_MAX entries. that should more than cover it */

#define NETPERF_MAX_BLOCKS 4
enum netperf_output_name output_human_list[NETPERF_MAX_BLOCKS][NETPERF_OUTPUT_MAX];

char *direction_to_str(int direction) {
  if (NETPERF_RECV_ONLY(direction)) return "Receive";
  if (NETPERF_XMIT_ONLY(direction)) return "Send";
  if (NETPERF_CC(direction)) return "Connection";
  else return "Send|Recv";
}

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 %u\n",res->ai_family);
    fflush(where);
    exit(-1);
  }
}

static void
extract_inet_address_and_port(struct addrinfo *res, void *addr, int len, int *port)
{
 switch(res->ai_family) {
  case AF_INET: {
    struct sockaddr_in *foo = (struct sockaddr_in *)res->ai_addr;
    *port = foo->sin_port;
    memcpy(addr,&(foo->sin_addr),min(len,sizeof(foo->sin_addr)));
    break;
  }
#if defined(AF_INET6)
  case AF_INET6: {
    struct sockaddr_in6 *foo = (struct sockaddr_in6 *)res->ai_addr;
    *port = foo->sin6_port;
    memcpy(addr,&(foo->sin6_addr),min(len,sizeof(foo->sin6_addr)));
    break;
  }
#endif
  default:
    *port = 0xDEADBEEF;
    strncpy(addr,"UNKN FAMILY",len);
  }
}

void
pick_next_port_number(struct addrinfo *local_res, struct addrinfo *remote_res) {

  static int myport_init = 0;
  static unsigned short myport = 0;

  if (0 == myport_init)  {
    /* pick a nice random spot between client_port_min and
       client_port_max for our initial port number, but only for a
       connection oriented test. otherwise, we will want to set myport
       to a specific port provided by the user if they have so provided
       a specific port :)  raj 2008-01-08 */
    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--;
    myport_init = 1;
  }
    
 newport:
    /* pick a new port number */
  myport++;
    
  /* check to see if we are using the port number on which the
     server is sitting _before_ we check against the boundaries lest
     the server sits at the upper boundary. if this happens to be a
     loopback test, trying to use the same portnumber would lead to
     unsatisfying results and should be avoided.  if this isn't a
     loopback test, avoiding using the same port number doesn't
     seriously affect anything anyway */
  
  if (myport == get_port_number(remote_res)) myport++;
  
  /* wrap the port number when we reach the upper bound.  for
     students of networking history, some ancient stacks (1980's and
     early 1990's perhaps) mistakenly treated these port numbers as
     signed 16 bit quantities.  we make no effort here to support
     such stacks. raj 2008-01-08 */
  if (myport >= client_port_max) {
    myport = client_port_min;
  }
  
  /* set up the data socket */
  set_port_number(local_res, (unsigned short)myport);
}

char *
netperf_output_enum_to_str(enum netperf_output_name output_name)
{
  switch (output_name) {
  case OUTPUT_NONE:
    return "OUTPUT_NONE";
  case   COMMAND_LINE:
    return "COMMAND_LINE";
  case UUID:
    return "UUID";
  case RESULT_BRAND:
    return "RESULT_BRAND";
  case   SOCKET_TYPE:
    return "SOCKET_TYPE";
  case   DIRECTION:
    return "DIRECTION";
  case   PROTOCOL:
    return "PROTOCOL";
  case   ELAPSED_TIME:
    return "ELAPSED_TIME";
  case   SOURCE_PORT:
    return "SOURCE_PORT";
  case   SOURCE_ADDR:
    return "SOURCE_ADDR";
  case SOURCE_FAMILY:
    return "SOURCE_FAMILY";
  case   DEST_PORT:
    return "DEST_PORT";
  case   DEST_ADDR:
    return "DEST_ADDR";
  case DEST_FAMILY:
    return "DEST_FAMILY";
  case THROUGHPUT:
    return "THROUGHPUT";
  case LOCAL_SEND_THROUGHPUT:
    return "LOCAL_SEND_THROUGHPUT";
  case LOCAL_RECV_THROUGHPUT:
    return "LOCAL_RECV_THROUGHPUT";
  case REMOTE_SEND_THROUGHPUT:
    return "REMOTE_SEND_THROUGHPUT";
  case REMOTE_RECV_THROUGHPUT:
    return "REMOTE_RECV_THROUGHPUT";
  case THROUGHPUT_UNITS:
    return "THROUGHPUT_UNITS";
  case CONFIDENCE_LEVEL:
    return "CONFIDENCE_LEVEL";
  case CONFIDENCE_INTERVAL:
    return "CONFIDENCE_INTERVAL";
  case CONFIDENCE_ITERATION:
    return "CONFIDENCE_ITERATION";
  case THROUGHPUT_CONFID:
    return "THROUGHPUT_CONFID";
  case LOCAL_CPU_CONFID:
    return "LOCAL_CPU_CONFID";
  case REMOTE_CPU_CONFID:
    return "REMOTE_CPU_CONFID";
  case RT_LATENCY:
    return "RT_LATENCY";
  case TRANSACTION_RATE:
    return "TRANSACTION_RATE";
  case BURST_SIZE:
    return "BURST_SIZE";
  case TRANSPORT_MSS:
    return "TRANSPORT_MSS";
  case REQUEST_SIZE:
    return "REQUEST_SIZE";
  case RESPONSE_SIZE:
    return "RESPONSE_SIZE";
  case   LSS_SIZE_REQ:
    return "LSS_SIZE_REQ";
  case   LSS_SIZE:
    return "LSS_SIZE";
  case   LSS_SIZE_END:
    return "LSS_SIZE_END";
  case   LSR_SIZE_REQ:
    return "LSR_SIZE_REQ";
  case   LSR_SIZE:
    return "LSR_SIZE";
  case   LSR_SIZE_END:
    return "LSR_SIZE_END";
  case   LOCAL_SEND_SIZE:
    return "LOCAL_SEND_SIZE";
  case   LOCAL_RECV_SIZE:
    return "LOCAL_RECV_SIZE";
  case   LOCAL_SEND_CALLS:
    return "LOCAL_SEND_CALLS";
  case   LOCAL_RECV_CALLS:
    return "LOCAL_RECV_CALLS";
  case   LOCAL_BYTES_PER_RECV:
    return "LOCAL_BYTES_PER_RECV";
  case   LOCAL_BYTES_PER_SEND:
    return "LOCAL_BYTES_PER_SEND";
  case   LOCAL_BYTES_SENT:
    return "LOCAL_BYTES_SENT";
  case   LOCAL_BYTES_RECVD:
    return "LOCAL_BYTES_RECVD";
  case   LOCAL_BYTES_XFERD:
    return "LOCAL_BYTES_XFERD";
  case LOCAL_SEND_OFFSET:
    return "LOCAL_SEND_OFFSET";
  case LOCAL_RECV_OFFSET:
    return "LOCAL_RECV_OFFSET";
  case LOCAL_RECV_ALIGN:
    return "LOCAL_RECV_ALIGN";
  case LOCAL_SEND_ALIGN:
    return "LOCAL_SEND_ALIGN";
  case LOCAL_SEND_WIDTH:
    return "LOCAL_SEND_WIDTH";
  case LOCAL_RECV_WIDTH:
    return "LOCAL_RECV_WIDTH";
  case   LOCAL_SEND_DIRTY_COUNT:
    return "LOCAL_SEND_DIRTY_COUNT";
  case   LOCAL_RECV_DIRTY_COUNT:
    return "LOCAL_RECV_DIRTY_COUNT";
  case   LOCAL_RECV_CLEAN_COUNT:
    return "LOCAL_RECV_CLEAN_COUNT";
  case   LOCAL_CPU_UTIL:
    return "LOCAL_CPU_UTIL";
  case   LOCAL_CPU_BIND:
    return "LOCAL_CPU_BIND";
  case   LOCAL_SD:
    return "LOCAL_SD";
  case   SD_UNITS:
    return "SD_UNITS";
  case   LOCAL_CPU_METHOD:
    return "LOCAL_CPU_METHOD";
  case LOCAL_CPU_COUNT:
    return "LOCAL_CPU_COUNT";
  case   LOCAL_CPU_PEAK_UTIL:
    return "LOCAL_CPU_PEAK_UTIL";
  case LOCAL_CPU_PEAK_ID:
    return "LOCAL_CPU_PEAK_ID";
  case   LOCAL_NODELAY:
    return "LOCAL_NODELAY";
  case   LOCAL_CORK:
    return "LOCAL_CORK";
  case   RSS_SIZE_REQ:
    return "RSS_SIZE_REQ";
  case   RSS_SIZE:
    return "RSS_SIZE";
  case   RSS_SIZE_END:
    return "RSS_SIZE_END";
  case   RSR_SIZE_REQ:
    return "RSR_SIZE_REQ";
  case   RSR_SIZE:
    return "RSR_SIZE";
  case   RSR_SIZE_END:
    return "RSR_SIZE_END";
  case   REMOTE_SEND_SIZE:
    return "REMOTE_SEND_SIZE";
  case   REMOTE_RECV_SIZE:
    return "REMOTE_RECV_SIZE";
  case   REMOTE_SEND_CALLS:
    return "REMOTE_SEND_CALLS";
  case   REMOTE_RECV_CALLS:
    return "REMOTE_RECV_CALLS";
  case   REMOTE_BYTES_PER_RECV:
    return "REMOTE_BYTES_PER_RECV";
  case   REMOTE_BYTES_PER_SEND:
    return "REMOTE_BYTES_PER_SEND";
  case   REMOTE_BYTES_SENT:
    return "REMOTE_BYTES_SENT";
  case   REMOTE_BYTES_RECVD:
    return "REMOTE_BYTES_RECVD";
  case   REMOTE_BYTES_XFERD:
    return "REMOTE_BYTES_XFERD";
  case REMOTE_SEND_OFFSET:
    return "REMOTE_SEND_OFFSET";
  case REMOTE_RECV_OFFSET:
    return "REMOTE_RECV_OFFSET";
  case REMOTE_RECV_ALIGN:
    return "REMOTE_RECV_ALIGN";
  case REMOTE_SEND_ALIGN:
    return "REMOTE_SEND_ALIGN";
  case REMOTE_SEND_WIDTH:
    return "REMOTE_SEND_WIDTH";
  case REMOTE_RECV_WIDTH:
    return "REMOTE_RECV_WIDTH";
  case   REMOTE_SEND_DIRTY_COUNT:
    return "REMOTE_SEND_DIRTY_COUNT";
  case   REMOTE_RECV_DIRTY_COUNT:
    return "REMOTE_RECV_DIRTY_COUNT";
  case   REMOTE_RECV_CLEAN_COUNT:
    return "REMOTE_RECV_CLEAN_COUNT";
  case   REMOTE_CPU_UTIL:
    return "REMOTE_CPU_UTIL";
  case   REMOTE_CPU_BIND:
    return "REMOTE_CPU_BIND";
  case   REMOTE_SD:
    return "REMOTE_SD";
  case   REMOTE_CPU_METHOD:
    return "REMOTE_CPU_METHOD";
  case REMOTE_CPU_COUNT:
    return "REMOTE_CPU_COUNT";
  case REMOTE_CPU_PEAK_UTIL:
    return "REMOTE_CPU_PEAK_UTIL";
  case REMOTE_CPU_PEAK_ID:
    return "REMOTE_CPU_PEAK_ID";
  case   REMOTE_NODELAY:
    return "REMOTE_NODELAY";
  case   REMOTE_CORK:
    return "REMOTE_CORK";
  case LOCAL_INTERFACE_SLOT:
    return "LOCAL_INTERFACE_SLOT";
  case REMOTE_INTERFACE_SLOT:
    return "REMOTE_INTERFACE_SLOT";
  case REMOTE_INTERFACE_SUBDEVICE:
    return "REMOTE_INTERFACE_SUBDEVICE";
  case REMOTE_INTERFACE_SUBVENDOR:
    return "REMOTE_INTERFACE_SUBVENDOR";
  case REMOTE_INTERFACE_DEVICE:
    return "REMOTE_INTERFACE_DEVICE";
  case REMOTE_INTERFACE_VENDOR:
    return "REMOTE_INTERFACE_VENDOR";
  case LOCAL_INTERFACE_SUBDEVICE:
    return "LOCAL_INTERFACE_SUBDEVICE";
  case LOCAL_INTERFACE_SUBVENDOR:
    return "LOCAL_INTERFACE_SUBVENDOR";
  case LOCAL_INTERFACE_DEVICE:
    return "LOCAL_INTERFACE_DEVICE";
  case LOCAL_INTERFACE_VENDOR:
    return "LOCAL_INTERFACE_VENDOR";
  case LOCAL_INTERFACE_NAME:
    return "LOCAL_INTERFACE_NAME";
  case REMOTE_INTERFACE_NAME:
    return "REMOTE_INTERFACE_NAME";
  case REMOTE_DRIVER_NAME:
    return "REMOTE_DRIVER_NAME";
  case REMOTE_DRIVER_VERSION:
    return "REMOTE_DRIVER_VERSION";
  case REMOTE_DRIVER_FIRMWARE:
    return "REMOTE_DRIVER_FIRMWARE";
  case REMOTE_DRIVER_BUS:
    return "REMOTE_DRIVER_BUS";
  case LOCAL_DRIVER_NAME:
    return "LOCAL_DRIVER_NAME";
  case LOCAL_DRIVER_VERSION:
    return "LOCAL_DRIVER_VERSION";
  case LOCAL_DRIVER_FIRMWARE:
    return "LOCAL_DRIVER_FIRMWARE";
  case LOCAL_INTERVAL_USECS:
    return "LOCAL_INTERVAL_USECS";
  case LOCAL_INTERVAL_BURST:
    return "LOCAL_INTERVAL_BURST";
  case REMOTE_INTERVAL_USECS:
    return "REMOTE_INTERVAL_USECS";
  case REMOTE_INTERVAL_BURST:
    return "REMOTE_INTERVAL_BURST";
  case LOCAL_SECURITY_TYPE_ID:
    return "LOCAL_SECURITY_TYPE_ID";
  case LOCAL_SECURITY_ENABLED_NUM:
    return "LOCAL_SECURITY_ENABLED_NUM";
  case LOCAL_SECURITY_TYPE:
    return "LOCAL_SECURITY_TYPE";
  case LOCAL_SECURITY_ENABLED:
    return "LOCAL_SECURITY_ENABLED";
  case LOCAL_SECURITY_SPECIFIC:
    return "LOCAL_SECURITY_SPECIFIC";
  case REMOTE_SECURITY_TYPE_ID:
    return "REMOTE_SECURITY_TYPE_ID";
  case REMOTE_SECURITY_ENABLED_NUM:
    return "REMOTE_SECURITY_ENABLED_NUM";
  case REMOTE_SECURITY_TYPE:
    return "REMOTE_SECURITY_TYPE";
  case REMOTE_SECURITY_ENABLED:
    return "REMOTE_SECURITY_ENABLED";
  case REMOTE_SECURITY_SPECIFIC:
    return "REMOTE_SECURITY_SPECIFIC";
  case LOCAL_DRIVER_BUS:
    return "LOCAL_DRIVER_BUS";
  case REMOTE_SYSNAME:
    return "REMOTE_SYSNAME";
  case REMOTE_MACHINE:
    return "REMOTE_MACHINE";
  case REMOTE_VERSION:
    return "REMOTE_VERSION";
  case REMOTE_RELEASE:
    return "REMOTE_RELEASE";
  case LOCAL_SYSNAME:
    return "LOCAL_SYSNAME";
  case LOCAL_MACHINE:
    return "LOCAL_MACHINE";
  case LOCAL_VERSION:
    return "LOCAL_VERSION";
  case LOCAL_RELEASE:
    return "LOCAL_RELEASE";
  case REMOTE_CPU_MODEL:
    return "REMOTE_CPU_MODEL";
  case REMOTE_CPU_FREQUENCY:
    return "REMOTE_CPU_FREQUENCY";
  case REMOTE_SYSTEM_MODEL:
    return "REMOTE_SYSTEM_MODEL";
  case LOCAL_CPU_MODEL:
    return "LOCAL_CPU_MODEL";
  case LOCAL_CPU_FREQUENCY:
    return "LOCAL_CPU_FREQUENCY";
  case LOCAL_SYSTEM_MODEL:
    return "LOCAL_SYSTEM_MODEL";
  case OUTPUT_END:
    return "OUTPUT_END";
  default:
    return "!UNKNOWN OUTPUT SELECTOR!";
  }
}

void
print_netperf_output_entry(FILE *where, enum netperf_output_name what)
{
}

void print_omni_init_list();

void
dump_netperf_output_list(FILE *where, int csv) {
  int i;

  print_omni_init_list();

  for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++){
    if (OUTPUT_NONE != i) {
      fprintf(where,"%c",(csv) ? ',' : '\n');
    }
    fprintf(where,
	    "%s",
	    netperf_output_enum_to_str(netperf_output_source[i].output_name));
  }
  fprintf(where,"\n");
  fflush(where);
}

void
dump_netperf_output_source(FILE *where)
{
  int i;

  /* belts and suspenders everyone... */
  for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
    fprintf(where,
	    "Output Name: %s\n",
	    netperf_output_enum_to_str(netperf_output_source[i].output_name));
    fprintf(where,
	    "\tmax_line_len %d tot_line_len %d display_value %p\n",
	    netperf_output_source[i].max_line_len,
	    netperf_output_source[i].tot_line_len,
	    netperf_output_source[i].display_value);
    fprintf(where,
	    "\tline[0]: |%s|\n",
	    (netperf_output_source[i].line[0] == NULL) ? "" : 
	    netperf_output_source[i].line[0]);
    fprintf(where,
	    "\tline[1]: |%s|\n",
	    (netperf_output_source[i].line[1] == NULL) ? "" : 
	    netperf_output_source[i].line[1]);
    fprintf(where,
	    "\tline[2]: |%s|\n",
	    (netperf_output_source[i].line[2] == NULL) ? "" : 
	    netperf_output_source[i].line[2]);
    fprintf(where,
	    "\tline[3]: |%s|\n",
	    (netperf_output_source[i].line[3] == NULL) ? "" : 
	    netperf_output_source[i].line[3]);
    fprintf(where,
	    "\tbrief: |%s|\n",
	    (netperf_output_source[i].brief == NULL) ? "" : 
	    netperf_output_source[i].brief);
    fprintf(where,
	    "\tformat: |%s|\n",
	    (netperf_output_source[i].format == NULL) ? "" : 
	    netperf_output_source[i].format);
  }
  fflush(where);
}

#define MY_MAX(a,b) ((a > b) ? a : b)

#define NETPERF_LINE_MAX(x) \
    MY_MAX(MY_MAX(MY_MAX(strlen(netperf_output_source[x].line[0]),\
		         strlen(netperf_output_source[x].line[1])),\
	          strlen(netperf_output_source[x].line[2])),\
	   strlen(netperf_output_source[x].line[3]))

#define NETPERF_LINE_TOT(x) \
    strlen(netperf_output_source[x].line[0]) +\
    strlen(netperf_output_source[x].line[1]) +\
    strlen(netperf_output_source[x].line[2]) +\
    strlen(netperf_output_source[x].line[3]) + 4

enum netperf_output_name
match_string_to_output(char *candidate)
{
  char *h1,*temp;
  enum netperf_output_name name;
  int k,len;

  /* at some point we may need/want to worry about leading and
     trailing spaces, but for now we will leave that onus on the
     user. */

  for (name = OUTPUT_NONE; name < NETPERF_OUTPUT_MAX; name++) {
    /* try for a match based on the nmemonic/enum */
    if (!strcasecmp(candidate,netperf_output_enum_to_str(name)))
      return name;
    
    /* try for a match on the actual header text */
    temp = malloc(NETPERF_LINE_TOT(name));
    h1 = temp;
    if (h1 != NULL) {
      for (k = 0; ((k < 4) &&
		   (NULL != netperf_output_source[name].line[k]) &&
		   (strcmp("",netperf_output_source[name].line[k]))); k++) {
	len = sprintf(h1,
		      "%s",
		      netperf_output_source[name].line[k]);
	*(h1 + len) = ' ';
	/* now move to the next starting column. for csv we aren't worried
	   about alignment between the header and the value lines */
	h1 += len + 1;
      }
      /* this time we want null termination please */
      *(h1 - 1) = 0;
      if (!strcasecmp(candidate,temp)) {
	free(temp);
	return name;
      }
      else 
	free(temp);
    }
  }
  /* if we get here it means there was no match */
  return OUTPUT_NONE;
}

void
parse_output_csv_selection_file(char *selection_file) {
  FILE *selections;
  char name[81]; /* best be more than enough */
  int namepos;
  int c;
  int j;
  enum netperf_output_name match;
  int line,column;

  selections = fopen(selection_file,"r");
  if (!selections) {
    perror("Could Not Open output selection file");
    exit(-1);
  }
  
  /* should this really be necessary? */
  rewind(selections);

  line = 0;
  column = 1;
  namepos = 0;
  name[0] = 0;
  name[80] = 0;
  j = 0;
  /* let's allow the csv to turn the four lines of a human readable
     output file to be used to create a single line csv output file by
     not worrying about the line count. raj 2008--02-04 */
  while ((c = fgetc(selections)) != EOF) {
    if (namepos == 80) {
      /* too long */
      
      fprintf(where,
	      "Output selection starting column %d on line %d is too long\n",
	      line + 1,
	      column);
      fflush(where);
      exit(-1);
    }
    if (c == ',') {
      /* time to check for a match, but only if we won't overflow the
	 current row of the array  */
      if (j == NETPERF_OUTPUT_MAX) {
	fprintf(where,"Too many output selectors on line %d\n",line);
	fflush(where);
	exit(-1);
      }
      name[namepos] = 0;
      output_csv_list[j++] = match_string_to_output(name);
      namepos = 0;
    }
    else if (c == '\n') {
      /* move to the next line after checking for a match */
      name[namepos] = 0;
      output_csv_list[j++] = match_string_to_output(name);
      line++;
      namepos = 0;
    }
    else if (isprint(c)) {
      name[namepos++] = c;
    }
    column++;
  }

  /* ok, do we need/want to do anything here? at present we will
     silently ignore the rest of the file if we exit the loop on line
     count */
  if ((c == EOF) && (namepos > 0)) {
    name[namepos] = 0;
    output_csv_list[j] =   match_string_to_output(name);
  }
}
void
parse_output_human_selection_file(char *selection_file) {
  FILE *selections;
  char name[81]; /* best be more than enough */
  int namepos;
  char c;
  int j;
  enum netperf_output_name match;
  int line,column;

  selections = fopen(selection_file,"r");
  if (!selections) {
    perror("Could Not Open output selection file");
    exit(-1);
  }
  
  line = 0;
  column = 1;
  namepos = 0;
  name[0] = 0;
  name[80] = 0;
  j = 0;
  while (((c = fgetc(selections)) != EOF) && (line < 4)) {
    if (namepos == 80) {
      /* too long */
      
      fprintf(where,
	      "Output selection starting column %d on line %d is too long\n",
	      line + 1,
	      column);
      fflush(where);
      exit(-1);
    }
    if (c == ',') {
      /* time to check for a match, but only if we won't overflow the
	 current row of the array  */
      if (j == NETPERF_OUTPUT_MAX) {
	fprintf(where,"Too many output selectors on line %d\n",line);
	fflush(where);
	exit(-1);
      }
      name[namepos] = 0;
      output_human_list[line][j++] = match_string_to_output(name);
      namepos = 0;
    }
    else if (c == '\n') {
      /* move to the next line after checking for a match */
      name[namepos] = 0;
      output_human_list[line++][j++] = match_string_to_output(name);
      namepos = 0;
      j = 0;
    }
    else if (isprint(c)) {
      name[namepos++] = c;
    }
    column++;
  }

  /* ok, do we need/want to do anything here? at present we will
     silently ignore the rest of the file if we exit the loop on line
     count */
  if ((c == EOF) && (namepos > 0)) {
    name[namepos] = 0;
    output_human_list[line][j] =   match_string_to_output(name);
  }

}

void
set_output_csv_list_default() {

  int  i = 0;
  enum netperf_output_name j;

  /* this should cause us to catch everything unless someone botches
     adding an output name to the enum.  raj 2008-02-22 */
  for (j = SOCKET_TYPE; j < OUTPUT_END; j++) {
    output_csv_list[i++] = j;
  }

}

void
set_output_human_list_default() {

  int i, j;  /* line, column */
  enum netperf_output_name k;

  /* Line One SOCKET_TYPE to RESPONSE_SIZE */
  i = 0;
  j = 0;
  for (k = SOCKET_TYPE; k <= RESPONSE_SIZE; k++)
    output_human_list[i][j++] = k;

  /* Line Two LOCAL_CPU_UTIL to TRANSPORT_MSS */
  i = 1;
  j = 0;
  for (k = LOCAL_CPU_UTIL; k <= TRANSPORT_MSS; k++)
    output_human_list[i][j++] = k;

  /* Line Three LOCAL_SEND_THROUGHPUT throught REMOTE_CORK */
  i = 2;
  j = 0;
  for (k = LOCAL_SEND_THROUGHPUT; k <= REMOTE_CORK; k++)
    output_human_list[i][j++] = k;

  /* Line Four LOCAL_SYSNAME through COMMAND_LINE */
  i = 3;
  j = 0;
  for (k = LOCAL_SYSNAME; k <= COMMAND_LINE; k++)
    output_human_list[i][j++] = k;

}

void
print_omni_init_list() {

  int i;

  /* belts and suspenders everyone... */
  for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
    netperf_output_source[i].output_name = i;
    netperf_output_source[i].max_line_len = 0;
    netperf_output_source[i].tot_line_len = 0;
    netperf_output_source[i].line[0] = "";
    netperf_output_source[i].line[1] = "";
    netperf_output_source[i].line[2] = "";
    netperf_output_source[i].line[3] = "";
    netperf_output_source[i].brief = "";
    netperf_output_source[i].format = "";
    netperf_output_source[i].display_value = NULL;
  }

  netperf_output_source[OUTPUT_NONE].output_name = OUTPUT_NONE;
  netperf_output_source[OUTPUT_NONE].line[0] = " ";
  netperf_output_source[OUTPUT_NONE].format = "%s";
  netperf_output_source[OUTPUT_NONE].display_value = &" ";
  netperf_output_source[OUTPUT_NONE].max_line_len = 
    NETPERF_LINE_MAX(OUTPUT_NONE);
  netperf_output_source[OUTPUT_NONE].tot_line_len = 
    NETPERF_LINE_TOT(OUTPUT_NONE);

  netperf_output_source[COMMAND_LINE].output_name = COMMAND_LINE;
  netperf_output_source[COMMAND_LINE].line[0] = "Command";
  netperf_output_source[COMMAND_LINE].line[1] = "Line";
  netperf_output_source[COMMAND_LINE].format = "\"%s\"";
  netperf_output_source[COMMAND_LINE].display_value = command_line;
  netperf_output_source[COMMAND_LINE].max_line_len = 
    NETPERF_LINE_MAX(COMMAND_LINE);
  netperf_output_source[COMMAND_LINE].tot_line_len = 
    NETPERF_LINE_TOT(COMMAND_LINE);

  netperf_output_source[UUID].output_name = UUID;
  netperf_output_source[UUID].line[0] = "Test";
  netperf_output_source[UUID].line[1] = "UUID";
  netperf_output_source[UUID].format = "%s";
  netperf_output_source[UUID].display_value = test_uuid;
  netperf_output_source[UUID].max_line_len = 
    NETPERF_LINE_MAX(UUID);
  netperf_output_source[UUID].tot_line_len = 
    NETPERF_LINE_TOT(UUID);

  netperf_output_source[RESULT_BRAND].output_name = RESULT_BRAND;
  netperf_output_source[RESULT_BRAND].line[0] = "Result";
  netperf_output_source[RESULT_BRAND].line[1] = "Tag";
  netperf_output_source[RESULT_BRAND].format = "\"%s\"";
  netperf_output_source[RESULT_BRAND].display_value = result_brand;
  netperf_output_source[RESULT_BRAND].max_line_len = 
    NETPERF_LINE_MAX(RESULT_BRAND);
  netperf_output_source[RESULT_BRAND].tot_line_len = 
    NETPERF_LINE_TOT(RESULT_BRAND);

  netperf_output_source[SOCKET_TYPE].output_name = SOCKET_TYPE;
  netperf_output_source[SOCKET_TYPE].line[0] = "Socket";
  netperf_output_source[SOCKET_TYPE].line[1] = "Type";
  netperf_output_source[SOCKET_TYPE].format = "%s";
  netperf_output_source[SOCKET_TYPE].display_value = socket_type_str;
  netperf_output_source[SOCKET_TYPE].max_line_len = 
    NETPERF_LINE_MAX(SOCKET_TYPE);
  netperf_output_source[SOCKET_TYPE].tot_line_len = 
    NETPERF_LINE_TOT(SOCKET_TYPE);

  netperf_output_source[DIRECTION].output_name = DIRECTION;
  netperf_output_source[DIRECTION].line[0] = "Direction";
  netperf_output_source[DIRECTION].line[1] = "";
  netperf_output_source[DIRECTION].format = "%s";
  netperf_output_source[DIRECTION].display_value = direction_str;
  netperf_output_source[DIRECTION].max_line_len = 
    NETPERF_LINE_MAX(DIRECTION);
  netperf_output_source[DIRECTION].tot_line_len = 
    NETPERF_LINE_TOT(DIRECTION);

  netperf_output_source[PROTOCOL].output_name = PROTOCOL;
  netperf_output_source[PROTOCOL].line[0] = "Protocol";
  netperf_output_source[PROTOCOL].format = "%s";
  netperf_output_source[PROTOCOL].display_value = protocol_str;
  netperf_output_source[PROTOCOL].max_line_len = 
    NETPERF_LINE_MAX(PROTOCOL);
  netperf_output_source[PROTOCOL].tot_line_len = 
    NETPERF_LINE_TOT(PROTOCOL);

  netperf_output_source[ELAPSED_TIME].output_name = ELAPSED_TIME;
  netperf_output_source[ELAPSED_TIME].line[0] = "Elapsed";
  netperf_output_source[ELAPSED_TIME].line[1] = "Time";
  netperf_output_source[ELAPSED_TIME].line[2] = "(sec)";
  netperf_output_source[ELAPSED_TIME].format = "%.2f";
  netperf_output_source[ELAPSED_TIME].display_value = &elapsed_time_double;
  netperf_output_source[ELAPSED_TIME].max_line_len = 
    NETPERF_LINE_MAX(ELAPSED_TIME);
  netperf_output_source[ELAPSED_TIME].tot_line_len = 
    NETPERF_LINE_TOT(ELAPSED_TIME);

  netperf_output_source[SOURCE_PORT].output_name = SOURCE_PORT;
  netperf_output_source[SOURCE_PORT].line[0] = "Source";
  netperf_output_source[SOURCE_PORT].line[1] = "Port";
  netperf_output_source[SOURCE_PORT].format = "%s";
  netperf_output_source[SOURCE_PORT].display_value = local_data_port;
  netperf_output_source[SOURCE_PORT].max_line_len = 
    NETPERF_LINE_MAX(SOURCE_PORT);
  netperf_output_source[SOURCE_PORT].tot_line_len = 
    NETPERF_LINE_TOT(SOURCE_PORT);

  netperf_output_source[SOURCE_ADDR].output_name = SOURCE_ADDR;
  netperf_output_source[SOURCE_ADDR].line[0] = "Source";
  netperf_output_source[SOURCE_ADDR].line[1] = "Address";
  netperf_output_source[SOURCE_ADDR].format = "%s";
  netperf_output_source[SOURCE_ADDR].display_value = local_data_address;
  netperf_output_source[SOURCE_ADDR].max_line_len = 
    NETPERF_LINE_MAX(SOURCE_ADDR);
  netperf_output_source[SOURCE_ADDR].tot_line_len = 
    NETPERF_LINE_TOT(SOURCE_ADDR);

  netperf_output_source[SOURCE_FAMILY].output_name = SOURCE_FAMILY;
  netperf_output_source[SOURCE_FAMILY].line[0] = "Source";
  netperf_output_source[SOURCE_FAMILY].line[1] = "Family";
  netperf_output_source[SOURCE_FAMILY].format = "%d";
  netperf_output_source[SOURCE_FAMILY].display_value = &local_data_family;
  netperf_output_source[SOURCE_FAMILY].max_line_len = 
    NETPERF_LINE_MAX(SOURCE_FAMILY);
  netperf_output_source[SOURCE_FAMILY].tot_line_len = 
    NETPERF_LINE_TOT(SOURCE_FAMILY);

  netperf_output_source[DEST_PORT].output_name = DEST_PORT;
  netperf_output_source[DEST_PORT].line[0] = "Destination";
  netperf_output_source[DEST_PORT].line[1] = "Port";
  netperf_output_source[DEST_PORT].format = "%s";
  netperf_output_source[DEST_PORT].display_value = remote_data_port;
  netperf_output_source[DEST_PORT].max_line_len = 
    NETPERF_LINE_MAX(DEST_PORT);
  netperf_output_source[DEST_PORT].tot_line_len = 
    NETPERF_LINE_TOT(DEST_PORT);

  netperf_output_source[DEST_ADDR].output_name = DEST_ADDR;
  netperf_output_source[DEST_ADDR].line[0] = "Destination";
  netperf_output_source[DEST_ADDR].line[1] = "Address";
  netperf_output_source[DEST_ADDR].format = "%s";
  netperf_output_source[DEST_ADDR].display_value = remote_data_address;
  netperf_output_source[DEST_ADDR].max_line_len = 
    NETPERF_LINE_MAX(DEST_ADDR);
  netperf_output_source[DEST_ADDR].tot_line_len = 
    NETPERF_LINE_TOT(DEST_ADDR);

  netperf_output_source[DEST_FAMILY].output_name = DEST_FAMILY;
  netperf_output_source[DEST_FAMILY].line[0] = "Destination";
  netperf_output_source[DEST_FAMILY].line[1] = "Family";
  netperf_output_source[DEST_FAMILY].format = "%d";
  netperf_output_source[DEST_FAMILY].display_value = &remote_data_family;
  netperf_output_source[DEST_FAMILY].max_line_len = 
    NETPERF_LINE_MAX(DEST_FAMILY);
  netperf_output_source[DEST_FAMILY].tot_line_len = 
    NETPERF_LINE_TOT(DEST_FAMILY);

  netperf_output_source[THROUGHPUT].output_name = THROUGHPUT;
  netperf_output_source[THROUGHPUT].line[0] = "Throughput";
  netperf_output_source[THROUGHPUT].line[1] = "";
  netperf_output_source[THROUGHPUT].format = "%.2f";
  netperf_output_source[THROUGHPUT].display_value = &thruput;
  netperf_output_source[THROUGHPUT].max_line_len = 
    NETPERF_LINE_MAX(THROUGHPUT);
  netperf_output_source[THROUGHPUT].tot_line_len = 
    NETPERF_LINE_TOT(THROUGHPUT);

  netperf_output_source[LOCAL_SEND_THROUGHPUT].output_name = LOCAL_SEND_THROUGHPUT;
  netperf_output_source[LOCAL_SEND_THROUGHPUT].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_THROUGHPUT].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_THROUGHPUT].line[2] = "Throughput";
  netperf_output_source[LOCAL_SEND_THROUGHPUT].format = "%.2f";
  netperf_output_source[LOCAL_SEND_THROUGHPUT].display_value = &local_send_thruput;
  netperf_output_source[LOCAL_SEND_THROUGHPUT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_THROUGHPUT);
  netperf_output_source[LOCAL_SEND_THROUGHPUT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_THROUGHPUT);

  netperf_output_source[LOCAL_RECV_THROUGHPUT].output_name = LOCAL_RECV_THROUGHPUT;
  netperf_output_source[LOCAL_RECV_THROUGHPUT].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_THROUGHPUT].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_THROUGHPUT].line[2] = "Throughput";
  netperf_output_source[LOCAL_RECV_THROUGHPUT].format = "%.2f";
  netperf_output_source[LOCAL_RECV_THROUGHPUT].display_value = &local_recv_thruput;
  netperf_output_source[LOCAL_RECV_THROUGHPUT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_THROUGHPUT);
  netperf_output_source[LOCAL_RECV_THROUGHPUT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_THROUGHPUT);

  netperf_output_source[REMOTE_SEND_THROUGHPUT].output_name = REMOTE_SEND_THROUGHPUT;
  netperf_output_source[REMOTE_SEND_THROUGHPUT].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_THROUGHPUT].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_THROUGHPUT].line[2] = "Throughput";
  netperf_output_source[REMOTE_SEND_THROUGHPUT].format = "%.2f";
  netperf_output_source[REMOTE_SEND_THROUGHPUT].display_value = &remote_send_thruput;
  netperf_output_source[REMOTE_SEND_THROUGHPUT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_THROUGHPUT);
  netperf_output_source[REMOTE_SEND_THROUGHPUT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_THROUGHPUT);

  netperf_output_source[REMOTE_RECV_THROUGHPUT].output_name = REMOTE_RECV_THROUGHPUT;
  netperf_output_source[REMOTE_RECV_THROUGHPUT].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_THROUGHPUT].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_THROUGHPUT].line[2] = "Throughput";
  netperf_output_source[REMOTE_RECV_THROUGHPUT].format = "%.2f";
  netperf_output_source[REMOTE_RECV_THROUGHPUT].display_value = &remote_recv_thruput;
  netperf_output_source[REMOTE_RECV_THROUGHPUT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_THROUGHPUT);
  netperf_output_source[REMOTE_RECV_THROUGHPUT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_THROUGHPUT);

  netperf_output_source[THROUGHPUT_UNITS].output_name = THROUGHPUT_UNITS;
  netperf_output_source[THROUGHPUT_UNITS].line[0] = "Throughput";
  netperf_output_source[THROUGHPUT_UNITS].line[1] = "Units";
  netperf_output_source[THROUGHPUT_UNITS].format = "%s/s";
  netperf_output_source[THROUGHPUT_UNITS].display_value = thruput_format_str;
  netperf_output_source[THROUGHPUT_UNITS].max_line_len = 
    NETPERF_LINE_MAX(THROUGHPUT_UNITS);
  netperf_output_source[THROUGHPUT_UNITS].tot_line_len = 
    NETPERF_LINE_TOT(THROUGHPUT_UNITS);

  netperf_output_source[CONFIDENCE_LEVEL].output_name = CONFIDENCE_LEVEL;
  netperf_output_source[CONFIDENCE_LEVEL].line[0] = "Confidence";
  netperf_output_source[CONFIDENCE_LEVEL].line[1] = "Level";
  netperf_output_source[CONFIDENCE_LEVEL].line[2] = "Percent";
  netperf_output_source[CONFIDENCE_LEVEL].format = "%d";
  netperf_output_source[CONFIDENCE_LEVEL].display_value = &confidence_level;
  netperf_output_source[CONFIDENCE_LEVEL].max_line_len = 
    NETPERF_LINE_MAX(CONFIDENCE_LEVEL);
  netperf_output_source[CONFIDENCE_LEVEL].tot_line_len = 
    NETPERF_LINE_TOT(CONFIDENCE_LEVEL);

  netperf_output_source[CONFIDENCE_INTERVAL].output_name = CONFIDENCE_INTERVAL;
  netperf_output_source[CONFIDENCE_INTERVAL].line[0] = "Confidence";
  netperf_output_source[CONFIDENCE_INTERVAL].line[1] = "Width";
  netperf_output_source[CONFIDENCE_INTERVAL].line[2] = "Target";
  netperf_output_source[CONFIDENCE_INTERVAL].format = "%f";
  netperf_output_source[CONFIDENCE_INTERVAL].display_value = &interval_pct;
  netperf_output_source[CONFIDENCE_INTERVAL].max_line_len = 
    NETPERF_LINE_MAX(CONFIDENCE_INTERVAL);
  netperf_output_source[CONFIDENCE_INTERVAL].tot_line_len = 
    NETPERF_LINE_TOT(CONFIDENCE_INTERVAL);

  netperf_output_source[CONFIDENCE_ITERATION].output_name = CONFIDENCE_ITERATION;
  netperf_output_source[CONFIDENCE_ITERATION].line[0] = "Confidence";
  netperf_output_source[CONFIDENCE_ITERATION].line[1] = "Iterations";
  netperf_output_source[CONFIDENCE_ITERATION].line[2] = "Run";
  netperf_output_source[CONFIDENCE_ITERATION].format = "%d";
  netperf_output_source[CONFIDENCE_ITERATION].display_value = &confidence_iteration;
  netperf_output_source[CONFIDENCE_ITERATION].max_line_len = 
    NETPERF_LINE_MAX(CONFIDENCE_ITERATION);
  netperf_output_source[CONFIDENCE_ITERATION].tot_line_len = 
    NETPERF_LINE_TOT(CONFIDENCE_ITERATION);

  netperf_output_source[THROUGHPUT_CONFID].output_name = THROUGHPUT_CONFID;
  netperf_output_source[THROUGHPUT_CONFID].line[0] = "Throughput";
  netperf_output_source[THROUGHPUT_CONFID].line[1] = "Confidence";
  netperf_output_source[THROUGHPUT_CONFID].line[2] = "Width (%)";
  netperf_output_source[THROUGHPUT_CONFID].format = "%.3f";
  netperf_output_source[THROUGHPUT_CONFID].display_value = &result_confid_pct;
  netperf_output_source[THROUGHPUT_CONFID].max_line_len = 
    NETPERF_LINE_MAX(THROUGHPUT_CONFID);
  netperf_output_source[THROUGHPUT_CONFID].tot_line_len = 
    NETPERF_LINE_TOT(THROUGHPUT_CONFID);

  netperf_output_source[LOCAL_CPU_CONFID].output_name = LOCAL_CPU_CONFID;
  netperf_output_source[LOCAL_CPU_CONFID].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_CONFID].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_CONFID].line[2] = "Confidence";
  netperf_output_source[LOCAL_CPU_CONFID].line[3] = "Width (%)";
  netperf_output_source[LOCAL_CPU_CONFID].format = "%.3f";
  netperf_output_source[LOCAL_CPU_CONFID].display_value = &loc_cpu_confid_pct;
  netperf_output_source[LOCAL_CPU_CONFID].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_CONFID);
  netperf_output_source[LOCAL_CPU_CONFID].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_CONFID);

  netperf_output_source[REMOTE_CPU_CONFID].output_name = REMOTE_CPU_CONFID;
  netperf_output_source[REMOTE_CPU_CONFID].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_CONFID].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_CONFID].line[2] = "Confidence";
  netperf_output_source[REMOTE_CPU_CONFID].line[3] = "Width (%)";
  netperf_output_source[REMOTE_CPU_CONFID].format = "%.3f";
  netperf_output_source[REMOTE_CPU_CONFID].display_value = &rem_cpu_confid_pct;
  netperf_output_source[REMOTE_CPU_CONFID].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_CONFID);
  netperf_output_source[REMOTE_CPU_CONFID].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_CONFID);

  netperf_output_source[RT_LATENCY].output_name = RT_LATENCY;
  netperf_output_source[RT_LATENCY].line[0] = "Round";
  netperf_output_source[RT_LATENCY].line[1] = "Trip";
  netperf_output_source[RT_LATENCY].line[2] = "Latency";
  netperf_output_source[RT_LATENCY].line[3] = "usec/tran";
  netperf_output_source[RT_LATENCY].format = "%.3f";
  netperf_output_source[RT_LATENCY].display_value = &rtt_latency;
  netperf_output_source[RT_LATENCY].max_line_len = 
    NETPERF_LINE_MAX(RT_LATENCY);
  netperf_output_source[RT_LATENCY].tot_line_len = 
    NETPERF_LINE_TOT(RT_LATENCY);

  netperf_output_source[TRANSACTION_RATE].output_name = TRANSACTION_RATE;
  netperf_output_source[TRANSACTION_RATE].line[0] = "Transaction";
  netperf_output_source[TRANSACTION_RATE].line[1] = "Rate";
  netperf_output_source[TRANSACTION_RATE].line[2] = "Tran/s";
  netperf_output_source[TRANSACTION_RATE].format = "%.3f";
  netperf_output_source[TRANSACTION_RATE].display_value = &transaction_rate;
  netperf_output_source[TRANSACTION_RATE].max_line_len = 
    NETPERF_LINE_MAX(TRANSACTION_RATE);
  netperf_output_source[TRANSACTION_RATE].tot_line_len = 
    NETPERF_LINE_TOT(TRANSACTION_RATE);

  netperf_output_source[TRANSPORT_MSS].output_name = TRANSPORT_MSS;
  netperf_output_source[TRANSPORT_MSS].line[0] = "Transport";
  netperf_output_source[TRANSPORT_MSS].line[1] = "MSS";
  netperf_output_source[TRANSPORT_MSS].line[2] = "bytes";
  netperf_output_source[TRANSPORT_MSS].format = "%d";
  netperf_output_source[TRANSPORT_MSS].display_value = &transport_mss;
  netperf_output_source[TRANSPORT_MSS].max_line_len = 
    NETPERF_LINE_MAX(TRANSPORT_MSS);
  netperf_output_source[TRANSPORT_MSS].tot_line_len = 
    NETPERF_LINE_TOT(TRANSPORT_MSS);

  netperf_output_source[REQUEST_SIZE].output_name = REQUEST_SIZE;
  netperf_output_source[REQUEST_SIZE].line[0] = "Request";
  netperf_output_source[REQUEST_SIZE].line[1] = "Size";
  netperf_output_source[REQUEST_SIZE].line[2] = "Bytes";
  netperf_output_source[REQUEST_SIZE].format = "%d";
  netperf_output_source[REQUEST_SIZE].display_value = &req_size;
  netperf_output_source[REQUEST_SIZE].max_line_len = 
    NETPERF_LINE_MAX(REQUEST_SIZE);
  netperf_output_source[REQUEST_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(REQUEST_SIZE);

  netperf_output_source[RESPONSE_SIZE].output_name = RESPONSE_SIZE;
  netperf_output_source[RESPONSE_SIZE].line[0] = "Response";
  netperf_output_source[RESPONSE_SIZE].line[1] = "Size";
  netperf_output_source[RESPONSE_SIZE].line[2] = "Bytes";
  netperf_output_source[RESPONSE_SIZE].format = "%d";
  netperf_output_source[RESPONSE_SIZE].display_value = &rsp_size;
  netperf_output_source[RESPONSE_SIZE].max_line_len = 
    NETPERF_LINE_MAX(RESPONSE_SIZE);
  netperf_output_source[RESPONSE_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(RESPONSE_SIZE);

  netperf_output_source[BURST_SIZE].output_name = BURST_SIZE;
  netperf_output_source[BURST_SIZE].line[0] = "Initial";
  netperf_output_source[BURST_SIZE].line[1] = "Burst";
  netperf_output_source[BURST_SIZE].line[2] = "Requests";
  netperf_output_source[BURST_SIZE].format = "%d";
  netperf_output_source[BURST_SIZE].display_value = &first_burst_size;
  netperf_output_source[BURST_SIZE].max_line_len = 
    NETPERF_LINE_MAX(BURST_SIZE);
  netperf_output_source[BURST_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(BURST_SIZE);

  netperf_output_source[LSS_SIZE_REQ].output_name = LSS_SIZE_REQ;
  netperf_output_source[LSS_SIZE_REQ].line[0] = "Local";
  netperf_output_source[LSS_SIZE_REQ].line[1] = "Send Socket";
  netperf_output_source[LSS_SIZE_REQ].line[2] = "Size";
  netperf_output_source[LSS_SIZE_REQ].line[3] = "Requested";
  netperf_output_source[LSS_SIZE_REQ].format = "%d";
  netperf_output_source[LSS_SIZE_REQ].display_value = &lss_size_req;
  netperf_output_source[LSS_SIZE_REQ].max_line_len = 
    NETPERF_LINE_MAX(LSS_SIZE_REQ);
  netperf_output_source[LSS_SIZE_REQ].tot_line_len = 
    NETPERF_LINE_TOT(LSS_SIZE_REQ);

  netperf_output_source[LSS_SIZE].output_name = LSS_SIZE;
  netperf_output_source[LSS_SIZE].line[0] = "Local";
  netperf_output_source[LSS_SIZE].line[1] = "Send Socket";
  netperf_output_source[LSS_SIZE].line[2] = "Size";
  netperf_output_source[LSS_SIZE].line[3] = "Initial";
  netperf_output_source[LSS_SIZE].format = "%d";
  netperf_output_source[LSS_SIZE].display_value = &lss_size;
  netperf_output_source[LSS_SIZE].max_line_len = 
    NETPERF_LINE_MAX(LSS_SIZE);
  netperf_output_source[LSS_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(LSS_SIZE);

  netperf_output_source[LSS_SIZE_END].output_name = LSS_SIZE_END;
  netperf_output_source[LSS_SIZE_END].line[0] = "Local";
  netperf_output_source[LSS_SIZE_END].line[1] = "Send Socket";
  netperf_output_source[LSS_SIZE_END].line[2] = "Size";
  netperf_output_source[LSS_SIZE_END].line[3] = "Final";
  netperf_output_source[LSS_SIZE_END].format = "%d";
  netperf_output_source[LSS_SIZE_END].display_value = &lss_size_end;
  netperf_output_source[LSS_SIZE_END].max_line_len = 
    NETPERF_LINE_MAX(LSS_SIZE_END);
  netperf_output_source[LSS_SIZE_END].tot_line_len = 
    NETPERF_LINE_TOT(LSS_SIZE_END);

  netperf_output_source[LSR_SIZE_REQ].output_name = LSR_SIZE_REQ;
  netperf_output_source[LSR_SIZE_REQ].line[0] = "Local";
  netperf_output_source[LSR_SIZE_REQ].line[1] = "Recv Socket";
  netperf_output_source[LSR_SIZE_REQ].line[2] = "Size";
  netperf_output_source[LSR_SIZE_REQ].line[3] = "Requested";
  netperf_output_source[LSR_SIZE_REQ].format = "%d";
  netperf_output_source[LSR_SIZE_REQ].display_value = &lsr_size_req;
  netperf_output_source[LSR_SIZE_REQ].max_line_len = 
    NETPERF_LINE_MAX(LSR_SIZE_REQ);
  netperf_output_source[LSR_SIZE_REQ].tot_line_len = 
    NETPERF_LINE_TOT(LSR_SIZE_REQ);

  netperf_output_source[LSR_SIZE].output_name = LSR_SIZE;
  netperf_output_source[LSR_SIZE].line[0] = "Local";
  netperf_output_source[LSR_SIZE].line[1] = "Recv Socket";
  netperf_output_source[LSR_SIZE].line[2] = "Size";
  netperf_output_source[LSR_SIZE].line[3] = "Initial";
  netperf_output_source[LSR_SIZE].format = "%d";
  netperf_output_source[LSR_SIZE].display_value = &lsr_size;
  netperf_output_source[LSR_SIZE].max_line_len = 
    NETPERF_LINE_MAX(LSR_SIZE);
  netperf_output_source[LSR_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(LSR_SIZE);

  netperf_output_source[LSR_SIZE_END].output_name = LSR_SIZE_END;
  netperf_output_source[LSR_SIZE_END].line[0] = "Local";
  netperf_output_source[LSR_SIZE_END].line[1] = "Recv Socket";
  netperf_output_source[LSR_SIZE_END].line[2] = "Size";
  netperf_output_source[LSR_SIZE_END].line[3] = "Final";
  netperf_output_source[LSR_SIZE_END].format = "%d";
  netperf_output_source[LSR_SIZE_END].display_value = &lsr_size_end;
  netperf_output_source[LSR_SIZE_END].max_line_len = 
    NETPERF_LINE_MAX(LSR_SIZE_END);
  netperf_output_source[LSR_SIZE_END].tot_line_len = 
    NETPERF_LINE_TOT(LSR_SIZE_END);

  netperf_output_source[LOCAL_SEND_SIZE].output_name = LOCAL_SEND_SIZE;
  netperf_output_source[LOCAL_SEND_SIZE].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_SIZE].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_SIZE].line[2] = "Size";
  netperf_output_source[LOCAL_SEND_SIZE].line[3] = "";
  netperf_output_source[LOCAL_SEND_SIZE].format = "%d";
  netperf_output_source[LOCAL_SEND_SIZE].display_value = &send_size;
  netperf_output_source[LOCAL_SEND_SIZE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_SIZE);
  netperf_output_source[LOCAL_SEND_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_SIZE);

  netperf_output_source[LOCAL_RECV_SIZE].output_name = LOCAL_RECV_SIZE;
  netperf_output_source[LOCAL_RECV_SIZE].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_SIZE].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_SIZE].line[2] = "Size";
  netperf_output_source[LOCAL_RECV_SIZE].line[3] = "";
  netperf_output_source[LOCAL_RECV_SIZE].format = "%d";
  netperf_output_source[LOCAL_RECV_SIZE].display_value = &recv_size;
  netperf_output_source[LOCAL_RECV_SIZE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_SIZE);
  netperf_output_source[LOCAL_RECV_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_SIZE);

  netperf_output_source[LOCAL_SEND_CALLS].output_name = LOCAL_SEND_CALLS;
  netperf_output_source[LOCAL_SEND_CALLS].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_CALLS].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_CALLS].line[2] = "Calls";
  netperf_output_source[LOCAL_SEND_CALLS].line[3] = "";
  netperf_output_source[LOCAL_SEND_CALLS].format = "%d";
  netperf_output_source[LOCAL_SEND_CALLS].display_value = &local_send_calls;
  netperf_output_source[LOCAL_SEND_CALLS].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_CALLS);
  netperf_output_source[LOCAL_SEND_CALLS].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_CALLS);

  netperf_output_source[LOCAL_RECV_CALLS].output_name = LOCAL_RECV_CALLS;
  netperf_output_source[LOCAL_RECV_CALLS].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_CALLS].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_CALLS].line[2] = "Calls";
  netperf_output_source[LOCAL_RECV_CALLS].line[3] = "";
  netperf_output_source[LOCAL_RECV_CALLS].format = "%d";
  netperf_output_source[LOCAL_RECV_CALLS].display_value = &local_receive_calls;
  netperf_output_source[LOCAL_RECV_CALLS].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_CALLS);
  netperf_output_source[LOCAL_RECV_CALLS].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_CALLS);

  netperf_output_source[LOCAL_BYTES_PER_RECV].output_name = LOCAL_BYTES_PER_RECV;
  netperf_output_source[LOCAL_BYTES_PER_RECV].line[0] = "Local";
  netperf_output_source[LOCAL_BYTES_PER_RECV].line[1] = "Bytes";
  netperf_output_source[LOCAL_BYTES_PER_RECV].line[2] = "Per";
  netperf_output_source[LOCAL_BYTES_PER_RECV].line[3] = "Recv";
  netperf_output_source[LOCAL_BYTES_PER_RECV].format = "%.2f";
  netperf_output_source[LOCAL_BYTES_PER_RECV].display_value = &bytes_per_recv;
  netperf_output_source[LOCAL_BYTES_PER_RECV].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_BYTES_PER_RECV);
  netperf_output_source[LOCAL_BYTES_PER_RECV].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_BYTES_PER_RECV);

  netperf_output_source[LOCAL_BYTES_PER_SEND].output_name = LOCAL_BYTES_PER_SEND;
  netperf_output_source[LOCAL_BYTES_PER_SEND].line[0] = "Local";
  netperf_output_source[LOCAL_BYTES_PER_SEND].line[1] = "Bytes";
  netperf_output_source[LOCAL_BYTES_PER_SEND].line[2] = "Per";
  netperf_output_source[LOCAL_BYTES_PER_SEND].line[3] = "Send";
  netperf_output_source[LOCAL_BYTES_PER_SEND].format = "%.2f";
  netperf_output_source[LOCAL_BYTES_PER_SEND].display_value = &bytes_per_send;
  netperf_output_source[LOCAL_BYTES_PER_SEND].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_BYTES_PER_SEND);
  netperf_output_source[LOCAL_BYTES_PER_SEND].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_BYTES_PER_SEND);

  netperf_output_source[LOCAL_BYTES_RECVD].output_name = LOCAL_BYTES_RECVD;
  netperf_output_source[LOCAL_BYTES_RECVD].line[0] = "Local";
  netperf_output_source[LOCAL_BYTES_RECVD].line[1] = "Bytes";
  netperf_output_source[LOCAL_BYTES_RECVD].line[2] = "Received";
  netperf_output_source[LOCAL_BYTES_RECVD].line[3] = "";
  netperf_output_source[LOCAL_BYTES_RECVD].format = "%lld";
  netperf_output_source[LOCAL_BYTES_RECVD].display_value = &bytes_received;
  netperf_output_source[LOCAL_BYTES_RECVD].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_BYTES_RECVD);
  netperf_output_source[LOCAL_BYTES_RECVD].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_BYTES_RECVD);

  netperf_output_source[LOCAL_BYTES_SENT].output_name = LOCAL_BYTES_SENT;
  netperf_output_source[LOCAL_BYTES_SENT].line[0] = "Local";
  netperf_output_source[LOCAL_BYTES_SENT].line[1] = "Bytes";
  netperf_output_source[LOCAL_BYTES_SENT].line[2] = "Sent";
  netperf_output_source[LOCAL_BYTES_SENT].line[3] = "";
  netperf_output_source[LOCAL_BYTES_SENT].format = "%lld";
  netperf_output_source[LOCAL_BYTES_SENT].display_value = &bytes_sent;
  netperf_output_source[LOCAL_BYTES_SENT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_BYTES_SENT);
  netperf_output_source[LOCAL_BYTES_SENT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_BYTES_SENT);

  netperf_output_source[LOCAL_BYTES_XFERD].output_name = LOCAL_BYTES_XFERD;
  netperf_output_source[LOCAL_BYTES_XFERD].line[0] = "Local";
  netperf_output_source[LOCAL_BYTES_XFERD].line[1] = "Bytes";
  netperf_output_source[LOCAL_BYTES_XFERD].line[2] = "Xferred";
  netperf_output_source[LOCAL_BYTES_XFERD].line[3] = "";
  netperf_output_source[LOCAL_BYTES_XFERD].format = "%.0f";
  netperf_output_source[LOCAL_BYTES_XFERD].display_value = &bytes_xferd;
  netperf_output_source[LOCAL_BYTES_XFERD].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_BYTES_XFERD);
  netperf_output_source[LOCAL_BYTES_XFERD].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_BYTES_XFERD);

  netperf_output_source[LOCAL_SEND_WIDTH].output_name = LOCAL_SEND_WIDTH;
  netperf_output_source[LOCAL_SEND_WIDTH].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_WIDTH].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_WIDTH].line[2] = "Width";
  netperf_output_source[LOCAL_SEND_WIDTH].format = "%d";
  netperf_output_source[LOCAL_SEND_WIDTH].display_value = &send_width;
  netperf_output_source[LOCAL_SEND_WIDTH].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_WIDTH);
  netperf_output_source[LOCAL_SEND_WIDTH].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_WIDTH);

  netperf_output_source[LOCAL_RECV_WIDTH].output_name = LOCAL_RECV_WIDTH;
  netperf_output_source[LOCAL_RECV_WIDTH].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_WIDTH].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_WIDTH].line[2] = "Width";
  netperf_output_source[LOCAL_RECV_WIDTH].format = "%d";
  netperf_output_source[LOCAL_RECV_WIDTH].display_value = &recv_width;
  netperf_output_source[LOCAL_RECV_WIDTH].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_WIDTH);
  netperf_output_source[LOCAL_RECV_WIDTH].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_WIDTH);

  netperf_output_source[LOCAL_SEND_OFFSET].output_name = LOCAL_SEND_OFFSET;
  netperf_output_source[LOCAL_SEND_OFFSET].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_OFFSET].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_OFFSET].line[2] = "Offset";
  netperf_output_source[LOCAL_SEND_OFFSET].format = "%d";
  netperf_output_source[LOCAL_SEND_OFFSET].display_value = &local_send_offset;
  netperf_output_source[LOCAL_SEND_OFFSET].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_OFFSET);
  netperf_output_source[LOCAL_SEND_OFFSET].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_OFFSET);

  netperf_output_source[LOCAL_RECV_OFFSET].output_name = LOCAL_RECV_OFFSET;
  netperf_output_source[LOCAL_RECV_OFFSET].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_OFFSET].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_OFFSET].line[2] = "Offset";
  netperf_output_source[LOCAL_RECV_OFFSET].format = "%d";
  netperf_output_source[LOCAL_RECV_OFFSET].display_value = &local_recv_offset;
  netperf_output_source[LOCAL_RECV_OFFSET].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_OFFSET);
  netperf_output_source[LOCAL_RECV_OFFSET].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_OFFSET);

  netperf_output_source[LOCAL_RECV_ALIGN].output_name = LOCAL_RECV_ALIGN;
  netperf_output_source[LOCAL_RECV_ALIGN].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_ALIGN].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_ALIGN].line[2] = "Alignment";
  netperf_output_source[LOCAL_RECV_ALIGN].format = "%d";
  netperf_output_source[LOCAL_RECV_ALIGN].display_value = &local_recv_align;
  netperf_output_source[LOCAL_RECV_ALIGN].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_ALIGN);
  netperf_output_source[LOCAL_RECV_ALIGN].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_ALIGN);

  netperf_output_source[LOCAL_SEND_ALIGN].output_name = LOCAL_SEND_ALIGN;
  netperf_output_source[LOCAL_SEND_ALIGN].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_ALIGN].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_ALIGN].line[2] = "Alignment";
  netperf_output_source[LOCAL_SEND_ALIGN].format = "%d";
  netperf_output_source[LOCAL_SEND_ALIGN].display_value = &local_send_align;
  netperf_output_source[LOCAL_SEND_ALIGN].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_ALIGN);
  netperf_output_source[LOCAL_SEND_ALIGN].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_ALIGN);

  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].output_name = LOCAL_SEND_DIRTY_COUNT;
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[0] = "Local";
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[1] = "Send";
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[2] = "Dirty";
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[3] = "Count";
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].format = "%d";
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].display_value = &loc_dirty_count;
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SEND_DIRTY_COUNT);
  netperf_output_source[LOCAL_SEND_DIRTY_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SEND_DIRTY_COUNT);

  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].output_name = LOCAL_RECV_DIRTY_COUNT;
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[2] = "Dirty";
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[3] = "Count";
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].format = "%d";
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].display_value = &loc_dirty_count;
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_DIRTY_COUNT);
  netperf_output_source[LOCAL_RECV_DIRTY_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_DIRTY_COUNT);

  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].output_name = LOCAL_RECV_CLEAN_COUNT;
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[0] = "Local";
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[1] = "Recv";
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[2] = "Clean";
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[3] = "Count";
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].format = "%d";
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].display_value = &loc_clean_count;
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RECV_CLEAN_COUNT);
  netperf_output_source[LOCAL_RECV_CLEAN_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RECV_CLEAN_COUNT);

  netperf_output_source[LOCAL_CPU_UTIL].output_name = LOCAL_CPU_UTIL;
  netperf_output_source[LOCAL_CPU_UTIL].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_UTIL].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_UTIL].line[2] = "Util";
  netperf_output_source[LOCAL_CPU_UTIL].line[3] = "%";
  netperf_output_source[LOCAL_CPU_UTIL].format = "%.2f";
  netperf_output_source[LOCAL_CPU_UTIL].display_value = &local_cpu_utilization_double;
  netperf_output_source[LOCAL_CPU_UTIL].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_UTIL);
  netperf_output_source[LOCAL_CPU_UTIL].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_UTIL);

  netperf_output_source[LOCAL_CPU_PEAK_UTIL].output_name = LOCAL_CPU_PEAK_UTIL;
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[1] = "Peak";
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[2] = "Per CPU";
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[3] = "Util %";
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].format = "%.2f";
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].display_value = &lib_local_peak_cpu_util;
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_PEAK_UTIL);
  netperf_output_source[LOCAL_CPU_PEAK_UTIL].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_PEAK_UTIL);

  netperf_output_source[LOCAL_CPU_PEAK_ID].output_name = LOCAL_CPU_PEAK_ID;
  netperf_output_source[LOCAL_CPU_PEAK_ID].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_PEAK_ID].line[1] = "Peak";
  netperf_output_source[LOCAL_CPU_PEAK_ID].line[2] = "Per CPU";
  netperf_output_source[LOCAL_CPU_PEAK_ID].line[3] = "ID";
  netperf_output_source[LOCAL_CPU_PEAK_ID].format = "%d";
  netperf_output_source[LOCAL_CPU_PEAK_ID].display_value = &lib_local_peak_cpu_id;
  netperf_output_source[LOCAL_CPU_PEAK_ID].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_PEAK_ID);
  netperf_output_source[LOCAL_CPU_PEAK_ID].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_PEAK_ID);

  netperf_output_source[LOCAL_CPU_BIND].output_name = LOCAL_CPU_BIND;
  netperf_output_source[LOCAL_CPU_BIND].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_BIND].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_BIND].line[2] = "Bind";
  netperf_output_source[LOCAL_CPU_BIND].line[3] = "";
  netperf_output_source[LOCAL_CPU_BIND].format = "%d";
  netperf_output_source[LOCAL_CPU_BIND].display_value = &local_proc_affinity;
  netperf_output_source[LOCAL_CPU_BIND].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_BIND);
  netperf_output_source[LOCAL_CPU_BIND].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_BIND);

  netperf_output_source[LOCAL_SD].output_name = LOCAL_SD;
  netperf_output_source[LOCAL_SD].line[0] = "Local";
  netperf_output_source[LOCAL_SD].line[1] = "Service";
  netperf_output_source[LOCAL_SD].line[2] = "Demand";
  netperf_output_source[LOCAL_SD].line[3] = "";
  netperf_output_source[LOCAL_SD].format = "%.3f";
  netperf_output_source[LOCAL_SD].display_value = &local_service_demand_double;
  netperf_output_source[LOCAL_SD].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SD);
  netperf_output_source[LOCAL_SD].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SD);

  netperf_output_source[SD_UNITS].output_name = SD_UNITS;
  netperf_output_source[SD_UNITS].line[0] = "Service";
  netperf_output_source[SD_UNITS].line[1] = "Demand";
  netperf_output_source[SD_UNITS].line[2] = "Units";
  netperf_output_source[SD_UNITS].format = "%s";
  netperf_output_source[SD_UNITS].display_value = sd_str;
  netperf_output_source[SD_UNITS].max_line_len = 
    NETPERF_LINE_MAX(SD_UNITS);
  netperf_output_source[SD_UNITS].tot_line_len = 
    NETPERF_LINE_TOT(SD_UNITS);

  netperf_output_source[LOCAL_CPU_METHOD].output_name = LOCAL_CPU_METHOD;
  netperf_output_source[LOCAL_CPU_METHOD].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_METHOD].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_METHOD].line[2] = "Util";
  netperf_output_source[LOCAL_CPU_METHOD].line[3] = "Method";
  netperf_output_source[LOCAL_CPU_METHOD].format = "%c";
  netperf_output_source[LOCAL_CPU_METHOD].display_value = &local_cpu_method;
  netperf_output_source[LOCAL_CPU_METHOD].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_METHOD);
  netperf_output_source[LOCAL_CPU_METHOD].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_METHOD);

  netperf_output_source[LOCAL_CPU_COUNT].output_name = LOCAL_CPU_COUNT;
  netperf_output_source[LOCAL_CPU_COUNT].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_COUNT].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_COUNT].line[2] = "Count";
  netperf_output_source[LOCAL_CPU_COUNT].format = "%d";
  netperf_output_source[LOCAL_CPU_COUNT].display_value = &lib_num_loc_cpus;
  netperf_output_source[LOCAL_CPU_COUNT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_COUNT);
  netperf_output_source[LOCAL_CPU_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_COUNT);

  netperf_output_source[LOCAL_NODELAY].output_name = LOCAL_NODELAY;
  netperf_output_source[LOCAL_NODELAY].line[0] = "Local";
  netperf_output_source[LOCAL_NODELAY].line[1] = "NODELAY";
  netperf_output_source[LOCAL_NODELAY].line[2] = "";
  netperf_output_source[LOCAL_NODELAY].line[3] = "";
  netperf_output_source[LOCAL_NODELAY].format = "%d";
  netperf_output_source[LOCAL_NODELAY].display_value = &loc_nodelay;
  netperf_output_source[LOCAL_NODELAY].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_NODELAY);
  netperf_output_source[LOCAL_NODELAY].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_NODELAY);

  netperf_output_source[LOCAL_CORK].output_name = LOCAL_CORK;
  netperf_output_source[LOCAL_CORK].line[0] = "Local";
  netperf_output_source[LOCAL_CORK].line[1] = "Cork";
  netperf_output_source[LOCAL_CORK].line[2] = "";
  netperf_output_source[LOCAL_CORK].line[3] = "";
  netperf_output_source[LOCAL_CORK].format = "%d";
  netperf_output_source[LOCAL_CORK].display_value = &loc_tcpcork;
  netperf_output_source[LOCAL_CORK].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CORK);
  netperf_output_source[LOCAL_CORK].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CORK);

  netperf_output_source[RSS_SIZE_REQ].output_name = RSS_SIZE_REQ;
  netperf_output_source[RSS_SIZE_REQ].line[0] = "Remote";
  netperf_output_source[RSS_SIZE_REQ].line[1] = "Send Socket";
  netperf_output_source[RSS_SIZE_REQ].line[2] = "Size";
  netperf_output_source[RSS_SIZE_REQ].line[3] = "Requested";
  netperf_output_source[RSS_SIZE_REQ].format = "%d";
  netperf_output_source[RSS_SIZE_REQ].display_value = &rss_size_req;
  netperf_output_source[RSS_SIZE_REQ].max_line_len = 
    NETPERF_LINE_MAX(RSS_SIZE_REQ);
  netperf_output_source[RSS_SIZE_REQ].tot_line_len = 
    NETPERF_LINE_TOT(RSS_SIZE_REQ);

  netperf_output_source[RSS_SIZE].output_name = RSS_SIZE;
  netperf_output_source[RSS_SIZE].line[0] = "Remote";
  netperf_output_source[RSS_SIZE].line[1] = "Send Socket";
  netperf_output_source[RSS_SIZE].line[2] = "Size";
  netperf_output_source[RSS_SIZE].line[3] = "Initial";
  netperf_output_source[RSS_SIZE].format = "%d";
  netperf_output_source[RSS_SIZE].display_value = &rss_size;
  netperf_output_source[RSS_SIZE].max_line_len = 
    NETPERF_LINE_MAX(RSS_SIZE);
  netperf_output_source[RSS_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(RSS_SIZE);

  netperf_output_source[RSS_SIZE_END].output_name = RSS_SIZE_END;
  netperf_output_source[RSS_SIZE_END].line[0] = "Remote";
  netperf_output_source[RSS_SIZE_END].line[1] = "Send Socket";
  netperf_output_source[RSS_SIZE_END].line[2] = "Size";
  netperf_output_source[RSS_SIZE_END].line[3] = "Final";
  netperf_output_source[RSS_SIZE_END].format = "%d";
  netperf_output_source[RSS_SIZE_END].display_value = &rss_size_end;
  netperf_output_source[RSS_SIZE_END].max_line_len = 
    NETPERF_LINE_MAX(RSS_SIZE_END);
  netperf_output_source[RSS_SIZE_END].tot_line_len = 
    NETPERF_LINE_TOT(RSS_SIZE_END);

  netperf_output_source[RSR_SIZE_REQ].output_name = RSR_SIZE_REQ;
  netperf_output_source[RSR_SIZE_REQ].line[0] = "Remote";
  netperf_output_source[RSR_SIZE_REQ].line[1] = "Recv Socket";
  netperf_output_source[RSR_SIZE_REQ].line[2] = "Size";
  netperf_output_source[RSR_SIZE_REQ].line[3] = "Requested";
  netperf_output_source[RSR_SIZE_REQ].format = "%d";
  netperf_output_source[RSR_SIZE_REQ].display_value = &rsr_size_req;
  netperf_output_source[RSR_SIZE_REQ].max_line_len = 
    NETPERF_LINE_MAX(RSR_SIZE_REQ);
  netperf_output_source[RSR_SIZE_REQ].tot_line_len = 
    NETPERF_LINE_TOT(RSR_SIZE_REQ);

  netperf_output_source[RSR_SIZE].output_name = RSR_SIZE;
  netperf_output_source[RSR_SIZE].line[0] = "Remote";
  netperf_output_source[RSR_SIZE].line[1] = "Recv Socket";
  netperf_output_source[RSR_SIZE].line[2] = "Size";
  netperf_output_source[RSR_SIZE].line[3] = "Initial";
  netperf_output_source[RSR_SIZE].format = "%d";
  netperf_output_source[RSR_SIZE].display_value = &rsr_size;
  netperf_output_source[RSR_SIZE].max_line_len = 
    NETPERF_LINE_MAX(RSR_SIZE);
  netperf_output_source[RSR_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(RSR_SIZE);

  netperf_output_source[RSR_SIZE_END].output_name = RSR_SIZE_END;
  netperf_output_source[RSR_SIZE_END].line[0] = "Remote";
  netperf_output_source[RSR_SIZE_END].line[1] = "Recv Socket";
  netperf_output_source[RSR_SIZE_END].line[2] = "Size";
  netperf_output_source[RSR_SIZE_END].line[3] = "Final";
  netperf_output_source[RSR_SIZE_END].format = "%d";
  netperf_output_source[RSR_SIZE_END].display_value = &rsr_size_end;
  netperf_output_source[RSR_SIZE_END].max_line_len = 
    NETPERF_LINE_MAX(RSR_SIZE_END);
  netperf_output_source[RSR_SIZE_END].tot_line_len = 
    NETPERF_LINE_TOT(RSR_SIZE_END);

  netperf_output_source[REMOTE_SEND_SIZE].output_name = REMOTE_SEND_SIZE;
  netperf_output_source[REMOTE_SEND_SIZE].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_SIZE].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_SIZE].line[2] = "Size";
  netperf_output_source[REMOTE_SEND_SIZE].line[3] = "";
  netperf_output_source[REMOTE_SEND_SIZE].format = "%d";
  netperf_output_source[REMOTE_SEND_SIZE].display_value = &remote_send_size;
  netperf_output_source[REMOTE_SEND_SIZE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_SIZE);
  netperf_output_source[REMOTE_SEND_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_SIZE);

  netperf_output_source[REMOTE_RECV_SIZE].output_name = REMOTE_RECV_SIZE;
  netperf_output_source[REMOTE_RECV_SIZE].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_SIZE].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_SIZE].line[2] = "Size";
  netperf_output_source[REMOTE_RECV_SIZE].line[3] = "";
  netperf_output_source[REMOTE_RECV_SIZE].format = "%d";
  netperf_output_source[REMOTE_RECV_SIZE].display_value = &remote_recv_size;
  netperf_output_source[REMOTE_RECV_SIZE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_SIZE);
  netperf_output_source[REMOTE_RECV_SIZE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_SIZE);

  netperf_output_source[REMOTE_SEND_CALLS].output_name = REMOTE_SEND_CALLS;
  netperf_output_source[REMOTE_SEND_CALLS].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_CALLS].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_CALLS].line[2] = "Calls";
  netperf_output_source[REMOTE_SEND_CALLS].line[3] = "";
  netperf_output_source[REMOTE_SEND_CALLS].format = "%lld";
  netperf_output_source[REMOTE_SEND_CALLS].display_value = &remote_send_calls;
  netperf_output_source[REMOTE_SEND_CALLS].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_CALLS);
  netperf_output_source[REMOTE_SEND_CALLS].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_CALLS);

  netperf_output_source[REMOTE_RECV_CALLS].output_name = REMOTE_RECV_CALLS;
  netperf_output_source[REMOTE_RECV_CALLS].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_CALLS].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_CALLS].line[2] = "Calls";
  netperf_output_source[REMOTE_RECV_CALLS].line[3] = "";
  netperf_output_source[REMOTE_RECV_CALLS].format = "%lld";
  netperf_output_source[REMOTE_RECV_CALLS].display_value = &remote_receive_calls;
  netperf_output_source[REMOTE_RECV_CALLS].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_CALLS);
  netperf_output_source[REMOTE_RECV_CALLS].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_CALLS);

  netperf_output_source[REMOTE_BYTES_PER_RECV].output_name = REMOTE_BYTES_PER_RECV;
  netperf_output_source[REMOTE_BYTES_PER_RECV].line[0] = "Remote";
  netperf_output_source[REMOTE_BYTES_PER_RECV].line[1] = "Bytes";
  netperf_output_source[REMOTE_BYTES_PER_RECV].line[2] = "Per";
  netperf_output_source[REMOTE_BYTES_PER_RECV].line[3] = "Recv";
  netperf_output_source[REMOTE_BYTES_PER_RECV].format = "%.2f";
  netperf_output_source[REMOTE_BYTES_PER_RECV].display_value = &remote_bytes_per_recv;
  netperf_output_source[REMOTE_BYTES_PER_RECV].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_BYTES_PER_RECV);
  netperf_output_source[REMOTE_BYTES_PER_RECV].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_BYTES_PER_RECV);

  netperf_output_source[REMOTE_BYTES_PER_SEND].output_name = REMOTE_BYTES_PER_SEND;
  netperf_output_source[REMOTE_BYTES_PER_SEND].line[0] = "Remote";
  netperf_output_source[REMOTE_BYTES_PER_SEND].line[1] = "Bytes";
  netperf_output_source[REMOTE_BYTES_PER_SEND].line[2] = "Per";
  netperf_output_source[REMOTE_BYTES_PER_SEND].line[3] = "Send";
  netperf_output_source[REMOTE_BYTES_PER_SEND].format = "%.2f";
  netperf_output_source[REMOTE_BYTES_PER_SEND].display_value = &remote_bytes_per_send;
  netperf_output_source[REMOTE_BYTES_PER_SEND].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_BYTES_PER_SEND);
  netperf_output_source[REMOTE_BYTES_PER_SEND].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_BYTES_PER_SEND);

  netperf_output_source[REMOTE_BYTES_RECVD].output_name = REMOTE_BYTES_RECVD;
  netperf_output_source[REMOTE_BYTES_RECVD].line[0] = "Remote";
  netperf_output_source[REMOTE_BYTES_RECVD].line[1] = "Bytes";
  netperf_output_source[REMOTE_BYTES_RECVD].line[2] = "Received";
  netperf_output_source[REMOTE_BYTES_RECVD].line[3] = "";
  netperf_output_source[REMOTE_BYTES_RECVD].format = "%lld";
  netperf_output_source[REMOTE_BYTES_RECVD].display_value = &remote_bytes_received;
  netperf_output_source[REMOTE_BYTES_RECVD].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_BYTES_RECVD);
  netperf_output_source[REMOTE_BYTES_RECVD].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_BYTES_RECVD);

  netperf_output_source[REMOTE_BYTES_SENT].output_name = REMOTE_BYTES_SENT;
  netperf_output_source[REMOTE_BYTES_SENT].line[0] = "Remote";
  netperf_output_source[REMOTE_BYTES_SENT].line[1] = "Bytes";
  netperf_output_source[REMOTE_BYTES_SENT].line[2] = "Sent";
  netperf_output_source[REMOTE_BYTES_SENT].line[3] = "";
  netperf_output_source[REMOTE_BYTES_SENT].format = "%lld";
  netperf_output_source[REMOTE_BYTES_SENT].display_value = &remote_bytes_sent;
  netperf_output_source[REMOTE_BYTES_SENT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_BYTES_SENT);
  netperf_output_source[REMOTE_BYTES_SENT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_BYTES_SENT);

  netperf_output_source[REMOTE_BYTES_XFERD].output_name = REMOTE_BYTES_XFERD;
  netperf_output_source[REMOTE_BYTES_XFERD].line[0] = "Remote";
  netperf_output_source[REMOTE_BYTES_XFERD].line[1] = "Bytes";
  netperf_output_source[REMOTE_BYTES_XFERD].line[2] = "Xferred";
  netperf_output_source[REMOTE_BYTES_XFERD].line[3] = "";
  netperf_output_source[REMOTE_BYTES_XFERD].format = "%.0f";
  netperf_output_source[REMOTE_BYTES_XFERD].display_value = &remote_bytes_xferd;
  netperf_output_source[REMOTE_BYTES_XFERD].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_BYTES_XFERD);
  netperf_output_source[REMOTE_BYTES_XFERD].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_BYTES_XFERD);

  netperf_output_source[REMOTE_SEND_WIDTH].output_name = REMOTE_SEND_WIDTH;
  netperf_output_source[REMOTE_SEND_WIDTH].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_WIDTH].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_WIDTH].line[2] = "Width";
  netperf_output_source[REMOTE_SEND_WIDTH].format = "%d";
  netperf_output_source[REMOTE_SEND_WIDTH].display_value = &remote_send_width;
  netperf_output_source[REMOTE_SEND_WIDTH].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_WIDTH);
  netperf_output_source[REMOTE_SEND_WIDTH].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_WIDTH);

  netperf_output_source[REMOTE_RECV_WIDTH].output_name = REMOTE_RECV_WIDTH;
  netperf_output_source[REMOTE_RECV_WIDTH].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_WIDTH].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_WIDTH].line[2] = "Width";
  netperf_output_source[REMOTE_RECV_WIDTH].format = "%d";
  netperf_output_source[REMOTE_RECV_WIDTH].display_value = &remote_recv_width;
  netperf_output_source[REMOTE_RECV_WIDTH].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_WIDTH);
  netperf_output_source[REMOTE_RECV_WIDTH].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_WIDTH);

  netperf_output_source[REMOTE_SEND_OFFSET].output_name = REMOTE_SEND_OFFSET;
  netperf_output_source[REMOTE_SEND_OFFSET].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_OFFSET].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_OFFSET].line[2] = "Offset";
  netperf_output_source[REMOTE_SEND_OFFSET].format = "%d";
  netperf_output_source[REMOTE_SEND_OFFSET].display_value = &remote_send_offset;
  netperf_output_source[REMOTE_SEND_OFFSET].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_OFFSET);
  netperf_output_source[REMOTE_SEND_OFFSET].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_OFFSET);

  netperf_output_source[REMOTE_RECV_OFFSET].output_name = REMOTE_RECV_OFFSET;
  netperf_output_source[REMOTE_RECV_OFFSET].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_OFFSET].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_OFFSET].line[2] = "Offset";
  netperf_output_source[REMOTE_RECV_OFFSET].format = "%d";
  netperf_output_source[REMOTE_RECV_OFFSET].display_value = &remote_recv_offset;
  netperf_output_source[REMOTE_RECV_OFFSET].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_OFFSET);
  netperf_output_source[REMOTE_RECV_OFFSET].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_OFFSET);

  netperf_output_source[REMOTE_RECV_ALIGN].output_name = REMOTE_RECV_ALIGN;
  netperf_output_source[REMOTE_RECV_ALIGN].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_ALIGN].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_ALIGN].line[2] = "Alignment";
  netperf_output_source[REMOTE_RECV_ALIGN].format = "%d";
  netperf_output_source[REMOTE_RECV_ALIGN].display_value = &remote_recv_align;
  netperf_output_source[REMOTE_RECV_ALIGN].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_ALIGN);
  netperf_output_source[REMOTE_RECV_ALIGN].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_ALIGN);

  netperf_output_source[REMOTE_SEND_ALIGN].output_name = REMOTE_SEND_ALIGN;
  netperf_output_source[REMOTE_SEND_ALIGN].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_ALIGN].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_ALIGN].line[2] = "Alignment";
  netperf_output_source[REMOTE_SEND_ALIGN].format = "%d";
  netperf_output_source[REMOTE_SEND_ALIGN].display_value = &remote_send_align;
  netperf_output_source[REMOTE_SEND_ALIGN].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_ALIGN);
  netperf_output_source[REMOTE_SEND_ALIGN].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_ALIGN);

  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].output_name = REMOTE_SEND_DIRTY_COUNT;
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[0] = "Remote";
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[1] = "Send";
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[2] = "Dirty";
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[3] = "Count";
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].format = "%d";
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].display_value = &rem_dirty_count;
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SEND_DIRTY_COUNT);
  netperf_output_source[REMOTE_SEND_DIRTY_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SEND_DIRTY_COUNT);

  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].output_name = REMOTE_RECV_DIRTY_COUNT;
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[2] = "Dirty";
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[3] = "Count";
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].format = "%d";
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].display_value = &rem_dirty_count;
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_DIRTY_COUNT);
  netperf_output_source[REMOTE_RECV_DIRTY_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_DIRTY_COUNT);

  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].output_name = REMOTE_RECV_CLEAN_COUNT;
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[0] = "Remote";
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[1] = "Recv";
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[2] = "Clean";
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[3] = "Count";
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].format = "%d";
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].display_value = &rem_clean_count;
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RECV_CLEAN_COUNT);
  netperf_output_source[REMOTE_RECV_CLEAN_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RECV_CLEAN_COUNT);

  netperf_output_source[REMOTE_CPU_UTIL].output_name = REMOTE_CPU_UTIL;
  netperf_output_source[REMOTE_CPU_UTIL].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_UTIL].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_UTIL].line[2] = "Util";
  netperf_output_source[REMOTE_CPU_UTIL].line[3] = "%";
  netperf_output_source[REMOTE_CPU_UTIL].format = "%.2f";
  netperf_output_source[REMOTE_CPU_UTIL].display_value = &remote_cpu_utilization_double;
  netperf_output_source[REMOTE_CPU_UTIL].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_UTIL);
  netperf_output_source[REMOTE_CPU_UTIL].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_UTIL);

  netperf_output_source[REMOTE_CPU_PEAK_UTIL].output_name = REMOTE_CPU_PEAK_UTIL;
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[1] = "Peak";
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[2] = "Per CPU";
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[3] = "Util %";
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].format = "%.2f";
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].display_value = &lib_remote_peak_cpu_util;
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_PEAK_UTIL);
  netperf_output_source[REMOTE_CPU_PEAK_UTIL].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_PEAK_UTIL);

  netperf_output_source[REMOTE_CPU_PEAK_ID].output_name = REMOTE_CPU_PEAK_ID;
  netperf_output_source[REMOTE_CPU_PEAK_ID].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_PEAK_ID].line[1] = "Peak";
  netperf_output_source[REMOTE_CPU_PEAK_ID].line[2] = "Per CPU";
  netperf_output_source[REMOTE_CPU_PEAK_ID].line[3] = "ID";
  netperf_output_source[REMOTE_CPU_PEAK_ID].format = "%d";
  netperf_output_source[REMOTE_CPU_PEAK_ID].display_value = &lib_remote_peak_cpu_id;
  netperf_output_source[REMOTE_CPU_PEAK_ID].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_PEAK_ID);
  netperf_output_source[REMOTE_CPU_PEAK_ID].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_PEAK_ID);

  netperf_output_source[REMOTE_CPU_BIND].output_name = REMOTE_CPU_BIND;
  netperf_output_source[REMOTE_CPU_BIND].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_BIND].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_BIND].line[2] = "Bind";
  netperf_output_source[REMOTE_CPU_BIND].line[3] = "";
  netperf_output_source[REMOTE_CPU_BIND].format = "%d";
  netperf_output_source[REMOTE_CPU_BIND].display_value = &remote_proc_affinity;
  netperf_output_source[REMOTE_CPU_BIND].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_BIND);
  netperf_output_source[REMOTE_CPU_BIND].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_BIND);

  netperf_output_source[REMOTE_SD].output_name = REMOTE_SD;
  netperf_output_source[REMOTE_SD].line[0] = "Remote";
  netperf_output_source[REMOTE_SD].line[1] = "Service";
  netperf_output_source[REMOTE_SD].line[2] = "Demand";
  netperf_output_source[REMOTE_SD].line[3] = "";
  netperf_output_source[REMOTE_SD].format = "%.3f";
  netperf_output_source[REMOTE_SD].display_value = &remote_service_demand_double;
  netperf_output_source[REMOTE_SD].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SD);
  netperf_output_source[REMOTE_SD].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SD);

  netperf_output_source[REMOTE_CPU_METHOD].output_name = REMOTE_CPU_METHOD;
  netperf_output_source[REMOTE_CPU_METHOD].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_METHOD].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_METHOD].line[2] = "Util";
  netperf_output_source[REMOTE_CPU_METHOD].line[3] = "Method";
  netperf_output_source[REMOTE_CPU_METHOD].format = "%c";
  netperf_output_source[REMOTE_CPU_METHOD].display_value = &remote_cpu_method;
  netperf_output_source[REMOTE_CPU_METHOD].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_METHOD);
  netperf_output_source[REMOTE_CPU_METHOD].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_METHOD);

  netperf_output_source[REMOTE_CPU_COUNT].output_name = REMOTE_CPU_COUNT;
  netperf_output_source[REMOTE_CPU_COUNT].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_COUNT].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_COUNT].line[2] = "Count";
  netperf_output_source[REMOTE_CPU_COUNT].format = "%d";
  netperf_output_source[REMOTE_CPU_COUNT].display_value = &lib_num_rem_cpus;
  netperf_output_source[REMOTE_CPU_COUNT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_COUNT);
  netperf_output_source[REMOTE_CPU_COUNT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_COUNT);

  netperf_output_source[REMOTE_NODELAY].output_name = REMOTE_NODELAY;
  netperf_output_source[REMOTE_NODELAY].line[0] = "Remote";
  netperf_output_source[REMOTE_NODELAY].line[1] = "NODELAY";
  netperf_output_source[REMOTE_NODELAY].line[2] = "";
  netperf_output_source[REMOTE_NODELAY].line[3] = "";
  netperf_output_source[REMOTE_NODELAY].format = "%d";
  netperf_output_source[REMOTE_NODELAY].display_value = &rem_nodelay;
  netperf_output_source[REMOTE_NODELAY].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_NODELAY);
  netperf_output_source[REMOTE_NODELAY].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_NODELAY);

  netperf_output_source[REMOTE_CORK].output_name = REMOTE_CORK;
  netperf_output_source[REMOTE_CORK].line[0] = "Remote";
  netperf_output_source[REMOTE_CORK].line[1] = "Cork";
  netperf_output_source[REMOTE_CORK].line[2] = "";
  netperf_output_source[REMOTE_CORK].line[3] = "";
  netperf_output_source[REMOTE_CORK].format = "%d";
  netperf_output_source[REMOTE_CORK].display_value = &rem_tcpcork;
  netperf_output_source[REMOTE_CORK].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CORK);
  netperf_output_source[REMOTE_CORK].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CORK);

  netperf_output_source[LOCAL_DRIVER_NAME].output_name = LOCAL_DRIVER_NAME;
  netperf_output_source[LOCAL_DRIVER_NAME].line[0] = "Local";
  netperf_output_source[LOCAL_DRIVER_NAME].line[1] = "Driver";
  netperf_output_source[LOCAL_DRIVER_NAME].line[2] = "Name";
  netperf_output_source[LOCAL_DRIVER_NAME].line[3] = "";
  netperf_output_source[LOCAL_DRIVER_NAME].format = "%s";
  netperf_output_source[LOCAL_DRIVER_NAME].display_value = local_driver_name;
  netperf_output_source[LOCAL_DRIVER_NAME].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_DRIVER_NAME);
  netperf_output_source[LOCAL_DRIVER_NAME].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_DRIVER_NAME);

  netperf_output_source[LOCAL_DRIVER_VERSION].output_name = LOCAL_DRIVER_VERSION;
  netperf_output_source[LOCAL_DRIVER_VERSION].line[0] = "Local";
  netperf_output_source[LOCAL_DRIVER_VERSION].line[1] = "Driver";
  netperf_output_source[LOCAL_DRIVER_VERSION].line[2] = "Version";
  netperf_output_source[LOCAL_DRIVER_VERSION].line[3] = "";
  netperf_output_source[LOCAL_DRIVER_VERSION].format = "%s";
  netperf_output_source[LOCAL_DRIVER_VERSION].display_value = local_driver_version;
  netperf_output_source[LOCAL_DRIVER_VERSION].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_DRIVER_VERSION);
  netperf_output_source[LOCAL_DRIVER_VERSION].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_DRIVER_VERSION);

  netperf_output_source[LOCAL_DRIVER_FIRMWARE].output_name = LOCAL_DRIVER_FIRMWARE;
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[0] = "Local";
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[1] = "Driver";
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[2] = "Firmware";
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[3] = "";
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].format = "%s";
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].display_value = local_driver_firmware;
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_DRIVER_FIRMWARE);
  netperf_output_source[LOCAL_DRIVER_FIRMWARE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_DRIVER_FIRMWARE);

  netperf_output_source[LOCAL_DRIVER_BUS].output_name = LOCAL_DRIVER_BUS;
  netperf_output_source[LOCAL_DRIVER_BUS].line[0] = "Local";
  netperf_output_source[LOCAL_DRIVER_BUS].line[1] = "Driver";
  netperf_output_source[LOCAL_DRIVER_BUS].line[2] = "Bus";
  netperf_output_source[LOCAL_DRIVER_BUS].line[3] = "";
  netperf_output_source[LOCAL_DRIVER_BUS].format = "%s";
  netperf_output_source[LOCAL_DRIVER_BUS].display_value = local_driver_bus;
  netperf_output_source[LOCAL_DRIVER_BUS].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_DRIVER_BUS);
  netperf_output_source[LOCAL_DRIVER_BUS].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_DRIVER_BUS);

  netperf_output_source[REMOTE_DRIVER_NAME].output_name = REMOTE_DRIVER_NAME;
  netperf_output_source[REMOTE_DRIVER_NAME].line[0] = "Remote";
  netperf_output_source[REMOTE_DRIVER_NAME].line[1] = "Driver";
  netperf_output_source[REMOTE_DRIVER_NAME].line[2] = "Name";
  netperf_output_source[REMOTE_DRIVER_NAME].line[3] = "";
  netperf_output_source[REMOTE_DRIVER_NAME].format = "%s";
  netperf_output_source[REMOTE_DRIVER_NAME].display_value = remote_driver_name;
  netperf_output_source[REMOTE_DRIVER_NAME].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_DRIVER_NAME);
  netperf_output_source[REMOTE_DRIVER_NAME].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_DRIVER_NAME);

  netperf_output_source[REMOTE_DRIVER_VERSION].output_name = REMOTE_DRIVER_VERSION;
  netperf_output_source[REMOTE_DRIVER_VERSION].line[0] = "Remote";
  netperf_output_source[REMOTE_DRIVER_VERSION].line[1] = "Driver";
  netperf_output_source[REMOTE_DRIVER_VERSION].line[2] = "Version";
  netperf_output_source[REMOTE_DRIVER_VERSION].line[3] = "";
  netperf_output_source[REMOTE_DRIVER_VERSION].format = "%s";
  netperf_output_source[REMOTE_DRIVER_VERSION].display_value = remote_driver_version;
  netperf_output_source[REMOTE_DRIVER_VERSION].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_DRIVER_VERSION);
  netperf_output_source[REMOTE_DRIVER_VERSION].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_DRIVER_VERSION);

  netperf_output_source[REMOTE_DRIVER_FIRMWARE].output_name = REMOTE_DRIVER_FIRMWARE;
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[0] = "Remote";
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[1] = "Driver";
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[2] = "Firmware";
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[3] = "";
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].format = "%s";
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].display_value = remote_driver_firmware;
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_DRIVER_FIRMWARE);
  netperf_output_source[REMOTE_DRIVER_FIRMWARE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_DRIVER_FIRMWARE);

  netperf_output_source[REMOTE_DRIVER_BUS].output_name = REMOTE_DRIVER_BUS;
  netperf_output_source[REMOTE_DRIVER_BUS].line[0] = "Remote";
  netperf_output_source[REMOTE_DRIVER_BUS].line[1] = "Driver";
  netperf_output_source[REMOTE_DRIVER_BUS].line[2] = "Bus";
  netperf_output_source[REMOTE_DRIVER_BUS].line[3] = "";
  netperf_output_source[REMOTE_DRIVER_BUS].format = "%s";
  netperf_output_source[REMOTE_DRIVER_BUS].display_value = remote_driver_bus;
  netperf_output_source[REMOTE_DRIVER_BUS].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_DRIVER_BUS);
  netperf_output_source[REMOTE_DRIVER_BUS].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_DRIVER_BUS);

  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].output_name = LOCAL_INTERFACE_SUBDEVICE;
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[2] = "Subdevice";
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].format = "0x%.4x";
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].display_value = &local_interface_subdevice;
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_SUBDEVICE);
  netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_SUBDEVICE);

  netperf_output_source[LOCAL_INTERFACE_DEVICE].output_name = LOCAL_INTERFACE_DEVICE;
  netperf_output_source[LOCAL_INTERFACE_DEVICE].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_DEVICE].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_DEVICE].line[2] = "Device";
  netperf_output_source[LOCAL_INTERFACE_DEVICE].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_DEVICE].format = "0x%.4x";
  netperf_output_source[LOCAL_INTERFACE_DEVICE].display_value = &local_interface_device;
  netperf_output_source[LOCAL_INTERFACE_DEVICE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_DEVICE);
  netperf_output_source[LOCAL_INTERFACE_DEVICE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_DEVICE);

  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].output_name = LOCAL_INTERFACE_SUBVENDOR;
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[2] = "Subvendor";
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].format = "0x%.4x";
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].display_value = &local_interface_subvendor;
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_SUBVENDOR);
  netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_SUBVENDOR);

  netperf_output_source[LOCAL_INTERFACE_VENDOR].output_name = LOCAL_INTERFACE_VENDOR;
  netperf_output_source[LOCAL_INTERFACE_VENDOR].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_VENDOR].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_VENDOR].line[2] = "Vendor";
  netperf_output_source[LOCAL_INTERFACE_VENDOR].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_VENDOR].format = "0x%.4x";
  netperf_output_source[LOCAL_INTERFACE_VENDOR].display_value = &local_interface_vendor;
  netperf_output_source[LOCAL_INTERFACE_VENDOR].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_VENDOR);
  netperf_output_source[LOCAL_INTERFACE_VENDOR].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_VENDOR);

  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].output_name = REMOTE_INTERFACE_SUBDEVICE;
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[2] = "Subdevice";
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].format = "0x%.4x";
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].display_value = &remote_interface_subdevice;
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_SUBDEVICE);
  netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_SUBDEVICE);

  netperf_output_source[REMOTE_INTERFACE_DEVICE].output_name = REMOTE_INTERFACE_DEVICE;
  netperf_output_source[REMOTE_INTERFACE_DEVICE].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_DEVICE].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_DEVICE].line[2] = "Device";
  netperf_output_source[REMOTE_INTERFACE_DEVICE].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_DEVICE].format = "0x%.4x";
  netperf_output_source[REMOTE_INTERFACE_DEVICE].display_value = &remote_interface_device;
  netperf_output_source[REMOTE_INTERFACE_DEVICE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_DEVICE);
  netperf_output_source[REMOTE_INTERFACE_DEVICE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_DEVICE);

  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].output_name = REMOTE_INTERFACE_SUBVENDOR;
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[2] = "Subvendor";
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].format = "0x%.4x";
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].display_value = &remote_interface_subvendor;
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_SUBVENDOR);
  netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_SUBVENDOR);

  netperf_output_source[REMOTE_INTERFACE_VENDOR].output_name = REMOTE_INTERFACE_VENDOR;
  netperf_output_source[REMOTE_INTERFACE_VENDOR].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_VENDOR].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_VENDOR].line[2] = "Vendor";
  netperf_output_source[REMOTE_INTERFACE_VENDOR].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_VENDOR].format = "0x%.4x";
  netperf_output_source[REMOTE_INTERFACE_VENDOR].display_value = &remote_interface_vendor;
  netperf_output_source[REMOTE_INTERFACE_VENDOR].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_VENDOR);
  netperf_output_source[REMOTE_INTERFACE_VENDOR].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_VENDOR);

  netperf_output_source[LOCAL_INTERFACE_NAME].output_name = LOCAL_INTERFACE_NAME;
  netperf_output_source[LOCAL_INTERFACE_NAME].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_NAME].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_NAME].line[2] = "Name";
  netperf_output_source[LOCAL_INTERFACE_NAME].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_NAME].format = "%s";
  netperf_output_source[LOCAL_INTERFACE_NAME].display_value = local_interface_name;
  netperf_output_source[LOCAL_INTERFACE_NAME].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_NAME);
  netperf_output_source[LOCAL_INTERFACE_NAME].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_NAME);

  netperf_output_source[REMOTE_INTERFACE_NAME].output_name = REMOTE_INTERFACE_NAME;
  netperf_output_source[REMOTE_INTERFACE_NAME].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_NAME].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_NAME].line[2] = "Name";
  netperf_output_source[REMOTE_INTERFACE_NAME].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_NAME].format = "%s";
  netperf_output_source[REMOTE_INTERFACE_NAME].display_value = remote_interface_name;
  netperf_output_source[REMOTE_INTERFACE_NAME].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_NAME);
  netperf_output_source[REMOTE_INTERFACE_NAME].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_NAME);

  netperf_output_source[LOCAL_INTERFACE_SLOT].output_name = LOCAL_INTERFACE_SLOT;
  netperf_output_source[LOCAL_INTERFACE_SLOT].line[0] = "Local";
  netperf_output_source[LOCAL_INTERFACE_SLOT].line[1] = "Interface";
  netperf_output_source[LOCAL_INTERFACE_SLOT].line[2] = "Slot";
  netperf_output_source[LOCAL_INTERFACE_SLOT].line[3] = "";
  netperf_output_source[LOCAL_INTERFACE_SLOT].format = "%s";
  netperf_output_source[LOCAL_INTERFACE_SLOT].display_value = local_interface_slot;
  netperf_output_source[LOCAL_INTERFACE_SLOT].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERFACE_SLOT);
  netperf_output_source[LOCAL_INTERFACE_SLOT].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERFACE_SLOT);

  netperf_output_source[REMOTE_INTERFACE_SLOT].output_name = REMOTE_INTERFACE_SLOT;
  netperf_output_source[REMOTE_INTERFACE_SLOT].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERFACE_SLOT].line[1] = "Interface";
  netperf_output_source[REMOTE_INTERFACE_SLOT].line[2] = "Slot";
  netperf_output_source[REMOTE_INTERFACE_SLOT].line[3] = "";
  netperf_output_source[REMOTE_INTERFACE_SLOT].format = "%s";
  netperf_output_source[REMOTE_INTERFACE_SLOT].display_value = remote_interface_slot;
  netperf_output_source[REMOTE_INTERFACE_SLOT].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERFACE_SLOT);
  netperf_output_source[REMOTE_INTERFACE_SLOT].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERFACE_SLOT);

  netperf_output_source[REMOTE_MACHINE].output_name = REMOTE_MACHINE;
  netperf_output_source[REMOTE_MACHINE].line[0] = "Remote";
  netperf_output_source[REMOTE_MACHINE].line[1] = "Machine";
  netperf_output_source[REMOTE_MACHINE].line[2] = "";
  netperf_output_source[REMOTE_MACHINE].line[3] = "";
  netperf_output_source[REMOTE_MACHINE].format = "%s";
  netperf_output_source[REMOTE_MACHINE].display_value = remote_machine;
  netperf_output_source[REMOTE_MACHINE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_MACHINE);
  netperf_output_source[REMOTE_MACHINE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_MACHINE);

  netperf_output_source[REMOTE_VERSION].output_name = REMOTE_VERSION;
  netperf_output_source[REMOTE_VERSION].line[0] = "Remote";
  netperf_output_source[REMOTE_VERSION].line[1] = "Version";
  netperf_output_source[REMOTE_VERSION].line[2] = "";
  netperf_output_source[REMOTE_VERSION].line[3] = "";
  netperf_output_source[REMOTE_VERSION].format = "%s";
  netperf_output_source[REMOTE_VERSION].display_value = remote_version;
  netperf_output_source[REMOTE_VERSION].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_VERSION);
  netperf_output_source[REMOTE_VERSION].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_VERSION);

  netperf_output_source[REMOTE_RELEASE].output_name = REMOTE_RELEASE;
  netperf_output_source[REMOTE_RELEASE].line[0] = "Remote";
  netperf_output_source[REMOTE_RELEASE].line[1] = "Release";
  netperf_output_source[REMOTE_RELEASE].line[2] = "";
  netperf_output_source[REMOTE_RELEASE].line[3] = "";
  netperf_output_source[REMOTE_RELEASE].format = "%s";
  netperf_output_source[REMOTE_RELEASE].display_value = remote_release;
  netperf_output_source[REMOTE_RELEASE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_RELEASE);
  netperf_output_source[REMOTE_RELEASE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_RELEASE);

  netperf_output_source[REMOTE_SYSNAME].output_name = REMOTE_SYSNAME;
  netperf_output_source[REMOTE_SYSNAME].line[0] = "Remote";
  netperf_output_source[REMOTE_SYSNAME].line[1] = "Sysname";
  netperf_output_source[REMOTE_SYSNAME].line[2] = "";
  netperf_output_source[REMOTE_SYSNAME].line[3] = "";
  netperf_output_source[REMOTE_SYSNAME].format = "%s";
  netperf_output_source[REMOTE_SYSNAME].display_value = remote_sysname;
  netperf_output_source[REMOTE_SYSNAME].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SYSNAME);
  netperf_output_source[REMOTE_SYSNAME].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SYSNAME);

  netperf_output_source[LOCAL_MACHINE].output_name = LOCAL_MACHINE;
  netperf_output_source[LOCAL_MACHINE].line[0] = "Local";
  netperf_output_source[LOCAL_MACHINE].line[1] = "Machine";
  netperf_output_source[LOCAL_MACHINE].line[2] = "";
  netperf_output_source[LOCAL_MACHINE].line[3] = "";
  netperf_output_source[LOCAL_MACHINE].format = "%s";
  netperf_output_source[LOCAL_MACHINE].display_value = local_machine;
  netperf_output_source[LOCAL_MACHINE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_MACHINE);
  netperf_output_source[LOCAL_MACHINE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_MACHINE);

  netperf_output_source[LOCAL_VERSION].output_name = LOCAL_VERSION;
  netperf_output_source[LOCAL_VERSION].line[0] = "Local";
  netperf_output_source[LOCAL_VERSION].line[1] = "Version";
  netperf_output_source[LOCAL_VERSION].line[2] = "";
  netperf_output_source[LOCAL_VERSION].line[3] = "";
  netperf_output_source[LOCAL_VERSION].format = "%s";
  netperf_output_source[LOCAL_VERSION].display_value = local_version;
  netperf_output_source[LOCAL_VERSION].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_VERSION);
  netperf_output_source[LOCAL_VERSION].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_VERSION);

  netperf_output_source[LOCAL_RELEASE].output_name = LOCAL_RELEASE;
  netperf_output_source[LOCAL_RELEASE].line[0] = "Local";
  netperf_output_source[LOCAL_RELEASE].line[1] = "Release";
  netperf_output_source[LOCAL_RELEASE].line[2] = "";
  netperf_output_source[LOCAL_RELEASE].line[3] = "";
  netperf_output_source[LOCAL_RELEASE].format = "%s";
  netperf_output_source[LOCAL_RELEASE].display_value = local_release;
  netperf_output_source[LOCAL_RELEASE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_RELEASE);
  netperf_output_source[LOCAL_RELEASE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_RELEASE);

  netperf_output_source[LOCAL_SYSNAME].output_name = LOCAL_SYSNAME;
  netperf_output_source[LOCAL_SYSNAME].line[0] = "Local";
  netperf_output_source[LOCAL_SYSNAME].line[1] = "Sysname";
  netperf_output_source[LOCAL_SYSNAME].line[2] = "";
  netperf_output_source[LOCAL_SYSNAME].line[3] = "";
  netperf_output_source[LOCAL_SYSNAME].format = "%s";
  netperf_output_source[LOCAL_SYSNAME].display_value = local_sysname;
  netperf_output_source[LOCAL_SYSNAME].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SYSNAME);
  netperf_output_source[LOCAL_SYSNAME].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SYSNAME);

  netperf_output_source[REMOTE_INTERVAL_USECS].output_name = REMOTE_INTERVAL_USECS;
  netperf_output_source[REMOTE_INTERVAL_USECS].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERVAL_USECS].line[1] = "Interval";
  netperf_output_source[REMOTE_INTERVAL_USECS].line[2] = "Usecs";
  netperf_output_source[REMOTE_INTERVAL_USECS].line[3] = "";
  netperf_output_source[REMOTE_INTERVAL_USECS].format = "%d";
  netperf_output_source[REMOTE_INTERVAL_USECS].display_value = &remote_interval_usecs;
  netperf_output_source[REMOTE_INTERVAL_USECS].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERVAL_USECS);
  netperf_output_source[REMOTE_INTERVAL_USECS].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERVAL_USECS);

  netperf_output_source[REMOTE_INTERVAL_BURST].output_name = REMOTE_INTERVAL_BURST;
  netperf_output_source[REMOTE_INTERVAL_BURST].line[0] = "Remote";
  netperf_output_source[REMOTE_INTERVAL_BURST].line[1] = "Interval";
  netperf_output_source[REMOTE_INTERVAL_BURST].line[2] = "Burst";
  netperf_output_source[REMOTE_INTERVAL_BURST].line[3] = "";
  netperf_output_source[REMOTE_INTERVAL_BURST].format = "%d";
  netperf_output_source[REMOTE_INTERVAL_BURST].display_value = &remote_interval_burst;
  netperf_output_source[REMOTE_INTERVAL_BURST].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_INTERVAL_BURST);
  netperf_output_source[REMOTE_INTERVAL_BURST].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_INTERVAL_BURST);

  netperf_output_source[LOCAL_SECURITY_ENABLED].output_name = LOCAL_SECURITY_ENABLED;
  netperf_output_source[LOCAL_SECURITY_ENABLED].line[0] = "Local";
  netperf_output_source[LOCAL_SECURITY_ENABLED].line[1] = "OS";
  netperf_output_source[LOCAL_SECURITY_ENABLED].line[2] = "Security";
  netperf_output_source[LOCAL_SECURITY_ENABLED].line[3] = "Enabled";
  netperf_output_source[LOCAL_SECURITY_ENABLED].format = "%s";
  netperf_output_source[LOCAL_SECURITY_ENABLED].display_value = local_security_enabled;
  netperf_output_source[LOCAL_SECURITY_ENABLED].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SECURITY_ENABLED);
  netperf_output_source[LOCAL_SECURITY_ENABLED].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SECURITY_ENABLED);

  netperf_output_source[LOCAL_SECURITY_TYPE].output_name = LOCAL_SECURITY_TYPE;
  netperf_output_source[LOCAL_SECURITY_TYPE].line[0] = "Local";
  netperf_output_source[LOCAL_SECURITY_TYPE].line[1] = "OS";
  netperf_output_source[LOCAL_SECURITY_TYPE].line[2] = "Security";
  netperf_output_source[LOCAL_SECURITY_TYPE].line[3] = "Type";
  netperf_output_source[LOCAL_SECURITY_TYPE].format = "%s";
  netperf_output_source[LOCAL_SECURITY_TYPE].display_value = local_security_type;
  netperf_output_source[LOCAL_SECURITY_TYPE].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SECURITY_TYPE);
  netperf_output_source[LOCAL_SECURITY_TYPE].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SECURITY_TYPE);

  netperf_output_source[LOCAL_SECURITY_SPECIFIC].output_name = LOCAL_SECURITY_SPECIFIC;
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].line[0] = "Local";
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].line[1] = "OS";
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].line[2] = "Security";
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].line[3] = "Specific";
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].format = "%s";
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].display_value = local_security_specific;
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SECURITY_SPECIFIC);
  netperf_output_source[LOCAL_SECURITY_SPECIFIC].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SECURITY_SPECIFIC);

  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].output_name = LOCAL_SECURITY_ENABLED_NUM;
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].line[0] = "Local";
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].line[1] = "OS";
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].line[2] = "Security";
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].line[3] = "Enabled Num";
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].format = "%d";
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].display_value = &local_security_enabled_num;
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SECURITY_ENABLED_NUM);
  netperf_output_source[LOCAL_SECURITY_ENABLED_NUM].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SECURITY_ENABLED_NUM);

  netperf_output_source[LOCAL_SECURITY_TYPE_ID].output_name = LOCAL_SECURITY_TYPE_ID;
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].line[0] = "Local";
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].line[1] = "OS";
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].line[2] = "Security";
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].line[3] = "Type ID";
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].format = "%d";
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].display_value = &local_security_type_id;
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SECURITY_TYPE_ID);
  netperf_output_source[LOCAL_SECURITY_TYPE_ID].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SECURITY_TYPE_ID);

  netperf_output_source[REMOTE_SECURITY_ENABLED].output_name = REMOTE_SECURITY_ENABLED;
  netperf_output_source[REMOTE_SECURITY_ENABLED].line[0] = "Remote";
  netperf_output_source[REMOTE_SECURITY_ENABLED].line[1] = "OS";
  netperf_output_source[REMOTE_SECURITY_ENABLED].line[2] = "Security";
  netperf_output_source[REMOTE_SECURITY_ENABLED].line[3] = "Enabled";
  netperf_output_source[REMOTE_SECURITY_ENABLED].format = "%s";
  netperf_output_source[REMOTE_SECURITY_ENABLED].display_value = remote_security_enabled;
  netperf_output_source[REMOTE_SECURITY_ENABLED].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SECURITY_ENABLED);
  netperf_output_source[REMOTE_SECURITY_ENABLED].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SECURITY_ENABLED);

  netperf_output_source[REMOTE_SECURITY_TYPE].output_name = REMOTE_SECURITY_TYPE;
  netperf_output_source[REMOTE_SECURITY_TYPE].line[0] = "Remote";
  netperf_output_source[REMOTE_SECURITY_TYPE].line[1] = "OS";
  netperf_output_source[REMOTE_SECURITY_TYPE].line[2] = "Security";
  netperf_output_source[REMOTE_SECURITY_TYPE].line[3] = "Type";
  netperf_output_source[REMOTE_SECURITY_TYPE].format = "%s";
  netperf_output_source[REMOTE_SECURITY_TYPE].display_value = remote_security_type;
  netperf_output_source[REMOTE_SECURITY_TYPE].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SECURITY_TYPE);
  netperf_output_source[REMOTE_SECURITY_TYPE].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SECURITY_TYPE);

  netperf_output_source[REMOTE_SECURITY_SPECIFIC].output_name = REMOTE_SECURITY_SPECIFIC;
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].line[0] = "Remote";
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].line[1] = "OS";
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].line[2] = "Security";
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].line[3] = "Specific";
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].format = "%s";
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].display_value = remote_security_specific;
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SECURITY_SPECIFIC);
  netperf_output_source[REMOTE_SECURITY_SPECIFIC].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SECURITY_SPECIFIC);

  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].output_name = REMOTE_SECURITY_ENABLED_NUM;
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].line[0] = "Remote";
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].line[1] = "OS";
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].line[2] = "Security";
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].line[3] = "Enabled";
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].format = "%d";
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].display_value = &remote_security_enabled_num;
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SECURITY_ENABLED_NUM);
  netperf_output_source[REMOTE_SECURITY_ENABLED_NUM].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SECURITY_ENABLED_NUM);

  netperf_output_source[REMOTE_SECURITY_TYPE_ID].output_name = REMOTE_SECURITY_TYPE_ID;
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].line[0] = "Remote";
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].line[1] = "OS";
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].line[2] = "Security";
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].line[3] = "Type";
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].format = "%d";
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].display_value = &remote_security_type_id;
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SECURITY_TYPE_ID);
  netperf_output_source[REMOTE_SECURITY_TYPE_ID].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SECURITY_TYPE_ID);

  netperf_output_source[LOCAL_INTERVAL_USECS].output_name = LOCAL_INTERVAL_USECS;
  netperf_output_source[LOCAL_INTERVAL_USECS].line[0] = "Local";
  netperf_output_source[LOCAL_INTERVAL_USECS].line[1] = "Interval";
  netperf_output_source[LOCAL_INTERVAL_USECS].line[2] = "Usecs";
  netperf_output_source[LOCAL_INTERVAL_USECS].line[3] = "";
  netperf_output_source[LOCAL_INTERVAL_USECS].format = "%d";
  netperf_output_source[LOCAL_INTERVAL_USECS].display_value = &interval_usecs;
  netperf_output_source[LOCAL_INTERVAL_USECS].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERVAL_USECS);
  netperf_output_source[LOCAL_INTERVAL_USECS].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERVAL_USECS);

  netperf_output_source[LOCAL_INTERVAL_BURST].output_name = LOCAL_INTERVAL_BURST;
  netperf_output_source[LOCAL_INTERVAL_BURST].line[0] = "Local";
  netperf_output_source[LOCAL_INTERVAL_BURST].line[1] = "Interval";
  netperf_output_source[LOCAL_INTERVAL_BURST].line[2] = "Burst";
  netperf_output_source[LOCAL_INTERVAL_BURST].line[3] = "";
  netperf_output_source[LOCAL_INTERVAL_BURST].format = "%d";
  netperf_output_source[LOCAL_INTERVAL_BURST].display_value = &interval_burst;
  netperf_output_source[LOCAL_INTERVAL_BURST].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_INTERVAL_BURST);
  netperf_output_source[LOCAL_INTERVAL_BURST].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_INTERVAL_BURST);

  netperf_output_source[REMOTE_SYSTEM_MODEL].output_name = REMOTE_SYSTEM_MODEL;
  netperf_output_source[REMOTE_SYSTEM_MODEL].line[0] = "Remote";
  netperf_output_source[REMOTE_SYSTEM_MODEL].line[1] = "System";
  netperf_output_source[REMOTE_SYSTEM_MODEL].line[2] = "Model";
  netperf_output_source[REMOTE_SYSTEM_MODEL].line[3] = "";
  netperf_output_source[REMOTE_SYSTEM_MODEL].format = "%s";
  netperf_output_source[REMOTE_SYSTEM_MODEL].display_value = remote_system_model;
  netperf_output_source[REMOTE_SYSTEM_MODEL].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_SYSTEM_MODEL);
  netperf_output_source[REMOTE_SYSTEM_MODEL].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_SYSTEM_MODEL);

  netperf_output_source[REMOTE_CPU_MODEL].output_name = REMOTE_CPU_MODEL;
  netperf_output_source[REMOTE_CPU_MODEL].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_MODEL].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_MODEL].line[2] = "Model";
  netperf_output_source[REMOTE_CPU_MODEL].line[3] = "";
  netperf_output_source[REMOTE_CPU_MODEL].format = "%s";
  netperf_output_source[REMOTE_CPU_MODEL].display_value = remote_cpu_model;
  netperf_output_source[REMOTE_CPU_MODEL].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_MODEL);
  netperf_output_source[REMOTE_CPU_MODEL].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_MODEL);

  netperf_output_source[REMOTE_CPU_FREQUENCY].output_name = REMOTE_CPU_FREQUENCY;
  netperf_output_source[REMOTE_CPU_FREQUENCY].line[0] = "Remote";
  netperf_output_source[REMOTE_CPU_FREQUENCY].line[1] = "CPU";
  netperf_output_source[REMOTE_CPU_FREQUENCY].line[2] = "Frequency";
  netperf_output_source[REMOTE_CPU_FREQUENCY].line[3] = "MHz";
  netperf_output_source[REMOTE_CPU_FREQUENCY].format = "%d";
  netperf_output_source[REMOTE_CPU_FREQUENCY].display_value = &remote_cpu_frequency;
  netperf_output_source[REMOTE_CPU_FREQUENCY].max_line_len = 
    NETPERF_LINE_MAX(REMOTE_CPU_FREQUENCY);
  netperf_output_source[REMOTE_CPU_FREQUENCY].tot_line_len = 
    NETPERF_LINE_TOT(REMOTE_CPU_FREQUENCY);

  netperf_output_source[LOCAL_SYSTEM_MODEL].output_name = LOCAL_SYSTEM_MODEL;
  netperf_output_source[LOCAL_SYSTEM_MODEL].line[0] = "Local";
  netperf_output_source[LOCAL_SYSTEM_MODEL].line[1] = "System";
  netperf_output_source[LOCAL_SYSTEM_MODEL].line[2] = "Model";
  netperf_output_source[LOCAL_SYSTEM_MODEL].line[3] = "";
  netperf_output_source[LOCAL_SYSTEM_MODEL].format = "%s";
  netperf_output_source[LOCAL_SYSTEM_MODEL].display_value = local_system_model;
  netperf_output_source[LOCAL_SYSTEM_MODEL].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_SYSTEM_MODEL);
  netperf_output_source[LOCAL_SYSTEM_MODEL].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_SYSTEM_MODEL);

  netperf_output_source[LOCAL_CPU_MODEL].output_name = LOCAL_CPU_MODEL;
  netperf_output_source[LOCAL_CPU_MODEL].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_MODEL].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_MODEL].line[2] = "Model";
  netperf_output_source[LOCAL_CPU_MODEL].line[3] = "";
  netperf_output_source[LOCAL_CPU_MODEL].format = "%s";
  netperf_output_source[LOCAL_CPU_MODEL].display_value = local_cpu_model;
  netperf_output_source[LOCAL_CPU_MODEL].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_MODEL);
  netperf_output_source[LOCAL_CPU_MODEL].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_MODEL);

  netperf_output_source[LOCAL_CPU_FREQUENCY].output_name = LOCAL_CPU_FREQUENCY;
  netperf_output_source[LOCAL_CPU_FREQUENCY].line[0] = "Local";
  netperf_output_source[LOCAL_CPU_FREQUENCY].line[1] = "CPU";
  netperf_output_source[LOCAL_CPU_FREQUENCY].line[2] = "Frequency";
  netperf_output_source[LOCAL_CPU_FREQUENCY].line[3] = "MHz";
  netperf_output_source[LOCAL_CPU_FREQUENCY].format = "%d";
  netperf_output_source[LOCAL_CPU_FREQUENCY].display_value = &local_cpu_frequency;
  netperf_output_source[LOCAL_CPU_FREQUENCY].max_line_len = 
    NETPERF_LINE_MAX(LOCAL_CPU_FREQUENCY);
  netperf_output_source[LOCAL_CPU_FREQUENCY].tot_line_len = 
    NETPERF_LINE_TOT(LOCAL_CPU_FREQUENCY);

  netperf_output_source[OUTPUT_END].output_name = OUTPUT_END;
  netperf_output_source[OUTPUT_END].line[0] = "This";
  netperf_output_source[OUTPUT_END].line[1] = "Is";
  netperf_output_source[OUTPUT_END].line[2] = "The";
  netperf_output_source[OUTPUT_END].line[3] = "End";
  netperf_output_source[OUTPUT_END].format = "%s";
  netperf_output_source[OUTPUT_END].display_value = NULL;
  netperf_output_source[OUTPUT_END].max_line_len = 
    NETPERF_LINE_MAX(OUTPUT_END);
  netperf_output_source[OUTPUT_END].tot_line_len = 
    NETPERF_LINE_TOT(OUTPUT_END);

}
/* lots of boring, repetitive code */
void 
print_omni_init() {

  int i,j;

  if (printing_initialized) return;

  printing_initialized = 1;

  print_omni_init_list();

  /* belts and suspenders */
  for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++)
    output_csv_list[i] = OUTPUT_END;

  for (j = 0; j < NETPERF_MAX_BLOCKS; j++)
    for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++)
      output_human_list[j][i] = OUTPUT_END;


  /* the default for csv is the kitchen-sink.  ultimately it will be
     possible to override by providing one's own list in a file */

  if ((csv) || (keyword)) {
    if (csv_selection_file) 
      /* name of file, list to fill, number of rows/lines */
      parse_output_csv_selection_file(csv_selection_file);
    else
      set_output_csv_list_default(output_csv_list);
  }
  else {
    if (human_selection_file)
      parse_output_human_selection_file(human_selection_file);
    else
      set_output_human_list_default(output_human_list);
  }
      

}

/* why? because one cannot simply pass a pointer to snprintf :) for
   our nefarious porpoises, we only expect to handle single-value
   format statements, not a full-blown format */
int 
my_long_long_snprintf(char *buffer, size_t size, const char *format, void *value)
{
  const char *fmt = format;
  while (*fmt)
    switch (*fmt++) {
    case 'd':
    case 'i':
      return snprintf(buffer, size, format, *(long long *)value);
    case 'u':
    case 'o':
    case 'x':
    case 'X':
      return snprintf(buffer, size, format, *(unsigned long long *)value);
    }
  return -1;
}

int
my_long_snprintf(char *buffer, size_t size, const char *format, void *value)
{
  const char *fmt = format;
  while (*fmt)
    switch (*fmt++) {
    case 'd':
    case 'i':
      return snprintf(buffer, size, format, *(long *)value);
    case 'u':
    case 'o':
    case 'x':
    case 'X':
      return snprintf(buffer, size, format, *(unsigned long *)value);
    case 'l':
      return my_long_long_snprintf(buffer, size, format, value);
    }
  return -1;
}

int
my_snprintf(char *buffer, size_t size, const char *format, void *value)
{
  const char *fmt = format;

  while (*fmt)
    switch (*fmt++) {
    case 'c':
      return snprintf(buffer, size, format, *(int *)value);
    case 'f':
    case 'e':
    case 'E':
    case 'g':
    case 'G':
      return snprintf(buffer, size, format, *(double *)value);
    case 's':
      return snprintf(buffer, size, format, (char *)value);
    case 'd':
    case 'i':
      return snprintf(buffer, size, format, *(int *)value);
    case 'u':
    case 'o':
    case 'x':
    case 'X':
      return snprintf(buffer, size, format, *(unsigned int *)value);
    case 'l':
      return my_long_snprintf(buffer, size, format, value);
    }
  return -1;
}

void
print_omni_csv()
{

  int j,k,buflen,vallen;

  char *hdr1 = NULL;
  char *val1 = NULL;
  char tmpval[1024];

  buflen = 0;
  for (j = 0; 
       ((j < NETPERF_OUTPUT_MAX) && 
	(output_csv_list[j] != OUTPUT_END));
       j++) {
    if ((netperf_output_source[output_csv_list[j]].format != NULL) &&
	(netperf_output_source[output_csv_list[j]].display_value != NULL)) {
      vallen = 
	my_snprintf(tmpval,
		    1024,
		    netperf_output_source[output_csv_list[j]].format,
		    (netperf_output_source[output_csv_list[j]].display_value));
      if (vallen == -1) {
	fprintf(where,"my_snprintf failed on %s with format %s\n",
		netperf_output_enum_to_str(j),
		netperf_output_source[output_csv_list[j]].format);
	fflush(where);
      }
      vallen += 1; /* forget not the terminator */
    }
    else
      vallen = 0;

    if (vallen > 
	netperf_output_source[output_csv_list[j]].tot_line_len)
      netperf_output_source[output_csv_list[j]].tot_line_len = vallen;
    
    buflen += 
      netperf_output_source[output_csv_list[j]].tot_line_len;
  }

  if (print_headers) hdr1 = malloc(buflen + 1);
  val1 = malloc(buflen + 1);

  if (((hdr1 == NULL) && (print_headers)) ||
      (val1 == NULL)) {
    fprintf(where,"unable to allocate output buffers\n");
    fflush(where);
    exit(-1);
  }

  if (print_headers) memset(hdr1,' ',buflen + 1);
  memset(val1,' ',buflen + 1);

  /* ostensibly, we now "know" that we have enough space in all our
     strings, and we have spaces where we want them etc */
  char *h1 = hdr1;
  char *v1 = val1;
  for (j = 0; 
       ((j < NETPERF_OUTPUT_MAX) && 
	(output_csv_list[j] != OUTPUT_END));
       j++) {
    int len;
    len = 0; 
    if (print_headers) {
      for (k = 0; ((k < 4) && 
		   (NULL != 
		    netperf_output_source[output_csv_list[j]].line[k]) &&
		   (strcmp("",netperf_output_source[output_csv_list[j]].line[k]))); k++) {

	len = sprintf(h1,
		      "%s",
		      netperf_output_source[output_csv_list[j]].line[k]);
	*(h1 + len) = ' ';
	/* now move to the next starting column. for csv we aren't worried
	   about alignment between the header and the value lines */
	h1 += len + 1;
      }
      *(h1 - 1) = ',';
    }
    if ((netperf_output_source[output_csv_list[j]].format != NULL) &&
	(netperf_output_source[output_csv_list[j]].display_value != NULL)) {
      /* tot_line_len is bogus here, but should be "OK" ? */
      len = my_snprintf(v1,
			netperf_output_source[output_csv_list[j]].tot_line_len,
			netperf_output_source[output_csv_list[j]].format,
			netperf_output_source[output_csv_list[j]].display_value);

      /* nuke the trailing \n" from the string routine.  */
      *(v1 + len) = ',';
      v1 += len + 1;
    }
    else {
      /* we need a ',' even if there is no value */
      *v1 = ',';
      v1 += 2;
    }
  }

  /* ok, _now_ null terminate each line by nuking the last comma.  do
     we have an OBOB here? */
  if (print_headers) *(h1-1) = 0;
  *(v1-1) = 0;
  /* and now spit it out, but only if it is going to have something
     in it. we don't want a bunch of blank lines or nulls...  */
  if (output_csv_list[0] != OUTPUT_END) {
    if (print_headers) printf("%s\n",hdr1);
    printf("%s\n",val1);
  }

  if (hdr1 != NULL) free(hdr1);
  if (val1 != NULL) free(val1);

}

void
print_omni_keyword()
{
  /* this one should be the simplest of all - no buffers to allocate,
     just spit it all out. raj 20080805 */

  int j;
  char tmpval[1024];
  int vallen;

  for (j = 0; 
       ((j < NETPERF_OUTPUT_MAX) && 
	(output_csv_list[j] != OUTPUT_END));
       j++) {
    if ((netperf_output_source[output_csv_list[j]].format != NULL) &&
	(netperf_output_source[output_csv_list[j]].display_value != NULL)) {
      vallen = 
	my_snprintf(tmpval,
		    1024,
		    netperf_output_source[output_csv_list[j]].format,
		    (netperf_output_source[output_csv_list[j]].display_value));
      if (vallen == -1) {
	snprintf(tmpval,
		 1024,
		 "my_snprintf failed with format %s\n",
		 netperf_output_source[output_csv_list[j]].format);
      }
      fprintf(where,
	      "%s=%s\n",netperf_output_enum_to_str(output_csv_list[j]),
	      tmpval);
    }
  }
  fflush(where);
}

void
print_omni_human()
{
  
  int i,j,k,buflen,buflen_max;

  char *hdr[4];
  char *val1 = NULL;
  char tmpval[1024];  /* excessive, but we may have the command line */
  int  vallen;

  for (k = 0; k < 4; k ++) {
    hdr[k] = NULL;
  }

  /* decisions, decisions... walk the list twice to only need to
     allocate the charcter buffers once, or walk it once and possibly
     reallocate them as I go... oh, lets walk it twice just for fun to
     start. since only now do we know that the values are around to be
     printed, we should try the snprintf for the value and see how
     much space it wants and update max_line_len accordingly */
  buflen_max = 0;
  for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
    buflen = 0;
    for (j = 0; 
	 ((j < NETPERF_OUTPUT_MAX) && 
	  (output_human_list[i][j] != OUTPUT_END));
	 j++) {
      if ((netperf_output_source[output_human_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_human_list[i][j]].display_value != NULL))
	vallen = my_snprintf(tmpval,
			     1024,
			     netperf_output_source[output_human_list[i][j]].format,
			     (netperf_output_source[output_human_list[i][j]].display_value)) + 1; /* need to count the \n */
      else
	vallen = 0;

      if (vallen > 
	  netperf_output_source[output_human_list[i][j]].max_line_len)
	netperf_output_source[output_human_list[i][j]].max_line_len = vallen;
      
      buflen += 
	netperf_output_source[output_human_list[i][j]].max_line_len + 1;
    }

    if (buflen > buflen_max) 
      buflen_max = buflen;
  }

  /* more belts and suspenders */
  for (k = 0; (k < 4) && (print_headers); k++) {
    hdr[k] = malloc(buflen_max+1);
  }
  val1 = malloc(buflen_max+1);
  
  /* we could probably be more succinct here but perhaps the compiler
     can figure that out for us :) */
  for (k = 0; (k < 4) && (print_headers); k++) {
    if (hdr[k] == NULL) {
      fprintf(where,"Unable to allocate output buffers\n");
      fflush(where);
      exit(-1);
    }
  }

  /* ostensibly, we now "know" that we have enough space in all our
     strings, and we have spaces where we want them etc */
  for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
    char *h[4];
    char *v1 = val1;

    for (k = 0; k < 4; k++) h[k] = hdr[k];

    /* we want to blank things out each time since we skip around a lot */
    for (k = 0; (k < 4) && (print_headers); k++) {
      memset(hdr[k],' ',buflen_max+1);
    }
    memset(val1,' ',buflen_max+1);


    for (j = 0; 
	 ((j < NETPERF_OUTPUT_MAX) && 
	  (output_human_list[i][j] != OUTPUT_END));
	 j++) {
      if (print_headers) {
	for (k = 0; k < 4; k++) {
	  memcpy(h[k],
		 netperf_output_source[output_human_list[i][j]].line[k],
		 strlen(netperf_output_source[output_human_list[i][j]].line[k]));
	}
      }
      if ((netperf_output_source[output_human_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_human_list[i][j]].display_value != NULL)) {
	int len;
	len = my_snprintf(v1,
			  netperf_output_source[output_human_list[i][j]].max_line_len,
			  netperf_output_source[output_human_list[i][j]].format,
			  netperf_output_source[output_human_list[i][j]].display_value);
	/* nuke the trailing \n" from the string routine.  */
	*(v1 + len) = ' ';
      }
      /* now move to the next starting column */
    for (k = 0; (k < 4) && (print_headers); k++) {
	h[k] += 
	  netperf_output_source[output_human_list[i][j]].max_line_len + 1;
      }
      v1 += netperf_output_source[output_human_list[i][j]].max_line_len + 1;
    }
    /* ok, _now_ null terminate each line.  do we have an OBOB here? */
    for (k = 0; (k < 4) && (print_headers); k++) {
      *h[k] = 0;
    }
    *v1 = 0;
    /* and now spit it out, but only if it is going to have something
       in it. we don't want a bunch of blank lines or nulls... at some
     point we might want to work backwards collapsine whitespace from
     the right but for now, we won't bother */
    if (output_human_list[i][0] != OUTPUT_END) {
      if (i > 0) printf("\n"); /* we want a blank line between blocks ? */
      for (k = 0; (k < 4) && (print_headers); k++) {
	printf("%s\n",hdr[k]);
      }
      printf("%s\n",val1);
    }
  };
  for (k = 0; k < 4; k++) {
    if (hdr[k] != NULL) free(hdr[k]);
  }
}

void
print_omni()
{

  print_omni_init();

  if (debug > 2) 
    dump_netperf_output_source(where);

  if (csv) 
    print_omni_csv();
  else if (keyword)
    print_omni_keyword();
  else
    print_omni_human();

}
/* for the next few routines (connect, accept, send, recv,
   disconnect/close) we will use a return of -1 to mean times up, -2
   to mean a transient error (eg ENOBUFS on a UDP send call) and -3 to
   mean hard error.  this means it is ok for the connect routine to
   return a 0 (zero) if that happens to be the fd/SOCKET we get and in
   theory we will be able to support zero-length messages on those
   protocols which support it.  all in theory of course. raj
   2008-01-09 */

int
connect_data_socket(SOCKET send_socket, struct addrinfo *remote_res) 
{
  int ret;
   
  /* 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 interpret this to mean that the test is supposed to be
	 over, so return a value of -1 to the caller */
      return -1;
    }
    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. we only get a new port if
	 this was a connection-including test like TCP_CRR or
	 TCP_CC. Otherwise we need to return an error. raj
	 2008-01-08 */
      return -2;
    }
    else 
      /* -3 means there was an error */
      return -3;
  }
  return 0;
}

int
send_data(SOCKET data_socket, struct ring_elt *send_ring, uint32_t bytes_to_send, struct sockaddr *destination, int destlen) {

  int len;

  /* if the user has supplied a destination, we use sendto, otherwise
     we use send.  we ass-u-me blocking operations always, so no need
     to check for eagain or the like. */

  if (debug > 1) {
    fprintf(where,
	    "send_data sock %d ring %p bytes %d dest %p len %d\n",
	    data_socket,
	    send_ring,
	    bytes_to_send,
	    destination,
	    destlen);
    fflush(where);
  }

  if (destination) {
    len = sendto(data_socket,
		 send_ring->buffer_ptr,
		 bytes_to_send,
		 0,
		 destination,
		 destlen);
  }
  else {
    len = send(data_socket,
	       send_ring->buffer_ptr,
	       bytes_to_send,
	       0);
  }
  if(len != bytes_to_send) {
    /* don't forget that some platforms may do a partial send upon
       receipt of the interrupt and not return an EINTR... */
    if (SOCKET_EINTR(len) || (len >= 0))
      {
	/* we hit the end of a  timed test. */
	return -1;
      }
    /* if this is UDP it is possible to receive an ENOBUFS on the send
       call and it would not be a fatal error.  of course if we were
       to return 0 then it would make the test think it was over when
       it really wasn't.  the question becomes what to do.  for the
       time being, the answer will likely be to return something like
       -2 to indicate a non-fatal error happened on the send and let
       the caller figure it out :) we won't actually check to see if
       this is UDP - it is the author's experience in many, Many, MANY
       years that the only time an ENOBUFS has been returned in a
       netperf test has been with UDP.  famous last words :) */
    if (errno == ENOBUFS)
      return -2;
    else {
      fprintf(where,"send_data: data send error: errno %d",errno);
      return -3;
    }
  }
  return len;
}

int
recv_data(SOCKET data_socket, struct ring_elt *recv_ring, uint32_t bytes_to_recv, struct sockaddr *source, int *sourcelen, uint32_t flags, uint32_t *num_receives) {

  char *temp_message_ptr;
  int bytes_left;
  int bytes_recvd;
  int my_recvs;

  /* receive data off the data_socket, ass-u-me-ing a blocking socket
     all the way!-) 2008-01-08 */
  my_recvs = 0;
  bytes_left = bytes_to_recv;
  temp_message_ptr  = recv_ring->buffer_ptr;

  if (debug > 1) {
    fprintf(where,
	    "recv_data sock %d, elt %p, bytes %d source %p srclen %d, flags %x num_recv %p\n",
	    data_socket,
	    recv_ring,
	    bytes_to_recv,
	    source,
	    (source != NULL) ? *sourcelen : -1,
	    flags,
	    num_receives);
    fflush(where);
  }
  do {
    if (source) {
      /* call recvfrom it does look a little silly here inside the do
	 while, but I think it is ok - a UDP or other DGRAM or
	 SEQPACKET (?) socket, which should be the only time we
	 pass-in a source pointer will have a semantic that should get
	 us out of the dowhile on the first call anyway.  if it
	 turns-out not to be the case, then we can hoist the if above
	 the do and put the dowhile in the else. */
      bytes_recvd = recvfrom(data_socket,
			     temp_message_ptr,
			     bytes_left,
			     0,
			     source,
			     sourcelen);
    }
    else {
      /* just call recv */
      bytes_recvd = recv(data_socket,
			 temp_message_ptr,
			 bytes_left,
			 0);
    }
    if (bytes_recvd > 0) {
      bytes_left -= bytes_recvd;
      temp_message_ptr += bytes_recvd;
    }
    else {
      break;
    }
    my_recvs++;
  } while ((bytes_left > 0) && (flags & NETPERF_WAITALL));
  
  *num_receives = my_recvs;
  
  /* OK, we are out of the loop - now what? */
  if (bytes_recvd < 0) {
    /* did the timer hit, or was there an error? */
    if (SOCKET_EINTR(bytes_recvd))
      {
	/* We hit the end of a timed test. */
	return -1;
      }
    /* it was a hard error */
    return -3;
  }
  
  
  /* this looks a little funny, but should be correct.  if we had
     NETPERF_WAITALL set and we got here, it means we got all the
     bytes of the request/response.  otherwise we would have hit the
     error or end of test cases.  if NETPERF_WAITALL isn't set, this
     is a STREAM test, and we will have only made one call to recv, so
     bytes_recvd will be accurate. */
  if (bytes_left) 
    return bytes_recvd;
  else
    return bytes_to_recv;

}


int
close_data_socket(SOCKET data_socket, struct sockaddr *peer, int peerlen)
{

  int ret;
  char buffer[4];

  if (protocol == IPPROTO_UDP) {
    int i;
    for (i = 0; i < 3; i++) {
      if (peer) 
	ret = sendto(data_socket,
		     buffer,
		     0,
		     0,
		     peer,
		     peerlen);
      else
	ret = send(data_socket,
		   buffer,
		   0,
		   0);
      if (SOCKET_EINTR(ret)) {
	close(data_socket);
	return -1;
      }
    }
  }
  ret = close(data_socket);

  if (SOCKET_EINTR(ret)) {
    /* end of test */
    return -1;
  }
  else if (ret == 0) {
    return ret;
  }
  else
    return -3;
    
}

int
disconnect_data_socket(SOCKET data_socket, int initiate, int do_close, struct sockaddr *peer, int peerlen) 
{

  char buffer[4];
  int bytes_recvd;

  if (debug) {
    fprintf(where,
	    "disconnect_d_s sock %d init %d do_close %d protocol %d\n",
	    data_socket,
	    initiate,
	    do_close,
	    protocol);
    fflush(where);
  }

  /* at some point we'll need to abstract this a little.  for now, if
     the protocol is UDP, we try to send some number of zero-length
     datagrams to allow the remote to get out of its loop without
     having to wait for the padded timer to expire. if it isn't UDP,
     we assume a reliable connection and can do the usual graceful
     shutdown thing */

  if (protocol != IPPROTO_UDP) {
    if (initiate)
      shutdown(data_socket, SHUT_WR);
    
    /* we are expecting to get either a return of zero indicating
       connection close, or an error.  */
    bytes_recvd = recv(data_socket,
		       buffer,
		       1,
		       0);
    
    if (bytes_recvd != 0) {
      /* connection close, call close. we assume that the requisite */
      /* number of bytes have been received */
      if (SOCKET_EINTR(bytes_recvd))
	{
	  /* We hit the end of a timed test. */
	  return -1;
	}
      return -3;
    }
  }
  else {
    int i;
    for (i = 0; i < 3; i++) {
      if (peer) 
	bytes_recvd = sendto(data_socket,
			     buffer,
			     0,
			     0,
			     peer,
			     peerlen);
      else
	bytes_recvd = send(data_socket,
			   buffer,
			   0,
			   0);
      /* we only really care if the timer expired on us */
      if (SOCKET_EINTR(bytes_recvd)) {
	if (do_close) close(data_socket);
	return -1;
      }
    }
  }
  
  if (do_close) 
    close(data_socket);
  
  return 0;
}

static void
get_transport_info(SOCKET socket, int *mss, int protocol)
{

  netperf_socklen_t sock_opt_len;
  int option;
  sock_opt_len = sizeof(netperf_socklen_t);

  switch (protocol) {
#if defined(IPPROTO_TCP) && defined(TCP_MAXSEG)
  case IPPROTO_TCP:
    option = TCP_MAXSEG;
    break;
#endif

#if defined(IPPROTO_SCTP) && defined(SCTP_MAXSEG)
  case IPPROTO_SCTP:
    option = SCTP_MAXSEG;
    break;
#endif
  default:
    *mss = -1;
    return;
  }
  
  if (getsockopt(socket,
		 protocol,
		 option,
		 (char *)mss,
		 &sock_opt_len) == SOCKET_ERROR) {
    fprintf(where,
	    "netperf: get_transport_info: getsockopt: errno %d\n",
	    errno);
    fflush(where);
    *mss = -1;
  }
}

/* brain dead simple way to get netperf to emit a uuid. sadly, by this
   point we will have already established the control connection but
   those are the breaks. we do _NOT_ include a trailing newline
   because we want to be able to use this in a script */

void
print_uuid(char remote_host[])
{
  printf("%s",test_uuid);
}

 /* this code is intended to be "the two routines to run them all" for
    BSDish sockets.  it comes about as part of a desire to shrink the
    code footprint of netperf and to avoid having so many blessed
    routines to alter as time goes by.  the downside is there will be
    more "ifs" than there were before. there may be some other
    "complications" for things like demo mode or perhaps histograms if
    we ever want to track individual RTTs when burst mode is in use
    etc etc... raj 2008-01-07 */

void
send_omni(char remote_host[])
{
  
  
  int len;
  int ret,rret;
  int connected = 0;
  int timed_out = 0;
  int pad_time = 0;

  struct ring_elt *send_ring;
  struct ring_elt *recv_ring;

  struct sockaddr_storage remote_addr;
  struct sockaddr_storage my_addr;
  int                     remote_addr_len = sizeof(remote_addr);
  int                     my_addr_len = sizeof(my_addr);

  SOCKET	data_socket;
  int           need_socket;

  int   temp_recvs;
  
  struct addrinfo *local_res;
  struct addrinfo *remote_res;

  struct	omni_request_struct	*omni_request;
  struct	omni_response_struct	*omni_response;
  struct	omni_results_struct	*omni_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

  omni_request = 
    (struct omni_request_struct *)netperf_request.content.test_specific_data;
  omni_response = 
    (struct omni_response_struct *)netperf_response.content.test_specific_data;
  omni_result =
    (struct omni_results_struct *)netperf_response.content.test_specific_data;
  

  /* before we start doing things with our own requests and responses
     lets go ahead and find-out about the remote system. at some point
     we probably need to put this somewhere else... */
  get_remote_system_info();
  
#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,
		     socket_type,
		     protocol,
		     0);

  if ( print_headers ) {
    print_top_test_header("OMNI TEST",local_res,remote_res);
  }

  /* initialize a few counters */
  
  need_socket   = 1;

  if (connection_test) 
    pick_next_port_number(local_res,remote_res);

  
  /* 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);
  }

  confidence_iteration = 1;
  init_stat();

  send_ring = NULL;
  recv_ring = NULL;

  /* you will keep running the test until you get it right! :) */
  while (((confidence < 0) && (confidence_iteration <= iteration_max)) ||
	 (confidence_iteration <= iteration_min)) {

    trans_completed = 0;
    bytes_xferd	= 0.0;
    remote_bytes_xferd = 0.0;
    times_up 	= 0;
    bytes_sent = 0;
    bytes_received = 0;
    local_send_calls = 0;
    local_receive_calls = 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


    data_socket = create_data_socket(local_res);
    
    if (data_socket == INVALID_SOCKET) {
      perror("netperf: send_omni: unable to create data socket");
      exit(1);
    }
    need_socket = 0;

    /* we need to consider if this is a request/response test, if we
       are receiving, if we are sending, etc, when setting-up our recv
       and send buffer rings. we should only need to do this once, and
       that would be when the relevant _ring variable is NULL. raj
       2008-01-18 */
    if ((direction & NETPERF_XMIT) && (NULL == send_ring)) {
      if (req_size > 0) {
	/* request/response test */
	if (send_width == 0) send_width = 1;
	bytes_to_send = req_size;
      }
      else {
	/* stream test */
	if (send_size == 0) {
	  if (lss_size > 0) {
	    send_size = lss_size;
	  }
	  else {
	    send_size = 4096;
	  }
	}
	if (send_width == 0) 
	  send_width = (lss_size/send_size) + 1;
	if (send_width == 1) send_width++;
	bytes_to_send = send_size;
      }
      
      send_ring = allocate_buffer_ring(send_width,
				       bytes_to_send,
				       local_send_align,
				       local_send_offset);
      if (debug) {
	fprintf(where,
		"send_omni: %d entry send_ring obtained...\n",
		send_width);
      }
    }
    
    if ((direction & NETPERF_RECV) && (NULL == recv_ring)) {
      if (rsp_size > 0) {
	if (recv_width == 0) recv_width = 1;
	bytes_to_recv = rsp_size;
      }
      else {
	/* stream test */
	if (recv_size == 0) {
	  if (lsr_size > 0) {
	    recv_size = lsr_size;
	  }
	  else {
	    recv_size = 4096;
	  }
	}
	if (recv_width == 0) {
	  recv_width = (lsr_size/recv_size) + 1;
	  if (recv_width == 1) recv_width++;
	}
	bytes_to_recv = recv_size;
      }
      
      recv_ring = allocate_buffer_ring(recv_width,
				       bytes_to_recv,
				       local_recv_align,
				       local_recv_offset);
      if (debug) {
	fprintf(where,
		"send_omni: %d entry recv_ring obtained...\n",
		recv_width);
      }
    }
    
    if (!no_control) { /* foo */
  
      /* Tell the remote end to do a listen or otherwise prepare for
	 what is to come. 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 values 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 probably be no alignment
	 alterations. */
      
      netperf_request.content.request_type = DO_OMNI;
      omni_request->send_buf_size	   = rss_size_req;
      omni_request->send_size              = remote_send_size_req;
      omni_request->send_alignment	   = remote_send_align;
      omni_request->send_offset	           = remote_send_offset;
      omni_request->send_width             = 1; /* FIX THIS */
      omni_request->request_size	   = req_size;
      
      omni_request->recv_buf_size	   = rsr_size_req;
      omni_request->receive_size           = remote_recv_size_req;
      omni_request->recv_alignment	   = remote_recv_align;
      omni_request->recv_offset	           = remote_recv_offset;
      omni_request->recv_width             = 1; /* FIX THIS */
      omni_request->response_size	   = rsp_size;
      
      omni_request->no_delay	           = rem_nodelay;
      omni_request->use_sendfile           = remote_use_sendfile;
      omni_request->connect_test           = connection_test;
      
      omni_request->measure_cpu	           = remote_cpu_usage;
      omni_request->cpu_rate	           = remote_cpu_rate;
      if (test_time)
	omni_request->test_length	   = test_time;
      else
	omni_request->test_length	   = test_trans * -1;
      omni_request->so_rcvavoid	           = rem_rcvavoid;
      omni_request->so_sndavoid	           = rem_sndavoid;
      omni_request->send_dirty_count       = rem_dirty_count;
      omni_request->recv_dirty_count       = rem_dirty_count;
      omni_request->recv_clean_count       = rem_clean_count;
      
      omni_request->checksum_off           = remote_checksum_off;
      omni_request->data_port              = atoi(remote_data_port);
      omni_request->ipfamily               = af_to_nf(remote_res->ai_family);
      omni_request->socket_type            = hst_to_nst(socket_type);
      omni_request->protocol               = protocol;

      omni_request->interval_burst         = remote_interval_burst;
      omni_request->interval_usecs         = remote_interval_usecs;

      omni_request->direction              = 0;
      /* yes, the sense here is correct - if we are transmitting, they
	 receive, if we are receiving, they are transmitting... */
      if (direction & NETPERF_XMIT)
	omni_request->direction |= NETPERF_RECV;
      if (direction & NETPERF_RECV)
	omni_request->direction |= NETPERF_XMIT;
    
      /* some tests may require knowledge of our local addressing. such
	 tests will for the time being require that the user specify a
	 local IP/name so we can extract them from the data_socket. */
      getsockname(data_socket, (struct sockaddr *)&my_addr, &my_addr_len);
      ret = get_sockaddr_family_addr_port(&my_addr,
					  nf_to_af(omni_request->ipfamily),
					  omni_request->ipaddr,
					  &(omni_request->netperf_port));
      
      if (debug > 1) {
	fprintf(where,"netperf: send_omni: requesting OMNI test\n");
      }
    

      send_request();

    
      /* the response from the remote should contain all the relevant
	 socket and other parameters we need to know for this test.
	 so, we can shove them back into the relevant variables here
	 and be on our way. */

      recv_response_n(OMNI_RESPONSE_CONV_CUTOFF); /* brittle, but functional */
  
      if (!netperf_response.content.serv_errno) {
	rsr_size	 = omni_response->recv_buf_size;
	remote_recv_size = omni_response->receive_size;
	rss_size	 = omni_response->send_buf_size;
	remote_send_size = omni_response->send_size;
	rem_nodelay      = omni_response->no_delay;
	remote_use_sendfile = omni_response->use_sendfile;
	remote_cpu_usage = omni_response->measure_cpu;
	remote_cpu_rate  = omni_response->cpu_rate;
	remote_send_width = omni_response->send_width;
	remote_recv_width = omni_response->recv_width;
	/* make sure that port numbers are in network order because
	   recv_response will have put everything into host order */
	set_port_number(remote_res,
			(unsigned short)omni_response->data_port);
	
	if (debug) {
	  fprintf(where,"remote listen done.\n");
	  fprintf(where,"remote port is %u\n",get_port_number(remote_res));
	  fflush(where);
	}
	/* just in case the remote didn't null terminate */
	if (NULL == remote_system_model) {
	  omni_response->system_model[sizeof(omni_response->system_model)-1] = 0;
	  remote_system_model = strdup(omni_response->system_model);
	}
	if (NULL == remote_cpu_model) {
	  omni_response->cpu_model[sizeof(omni_response->cpu_model) -1 ] = 0;
	  remote_cpu_model = strdup(omni_response->cpu_model);
	}
	remote_cpu_frequency = omni_response->cpu_frequency;

	if (NULL == remote_security_specific) {
	  omni_response->security_string[sizeof(omni_response->security_string) - 1] = 0;
	  remote_security_specific = strdup(omni_response->security_string);
	}
	/* top bits type, bottom bits enabled */
	remote_security_type_id = (int) omni_response->security_info >> 16;
	remote_security_enabled_num = (short)omni_response->security_info;
	remote_security_type = nsec_type_to_str(remote_security_type_id);
	remote_security_enabled = 
	  nsec_enabled_to_str(remote_security_enabled_num);
      }
      else {
	Set_errno(netperf_response.content.serv_errno);
	fprintf(where,
		"netperf: remote error %d",
		netperf_response.content.serv_errno);
	perror("");
	fflush(where);
	exit(1);
      }
    
    }
    else {
      if (NULL == remote_system_model) 
	remote_system_model = strdup("Unknown System Model");
      if (NULL == remote_cpu_model)
	remote_cpu_model = strdup("Unknown CPU Model");
      remote_cpu_frequency = -1;
    }

#ifdef WANT_DEMO
    /* at some point we will have to be more clever about this, but
       for now we won't */

    DEMO_RR_SETUP(100);
#endif

    /* if we are not a connectionless protocol, we need to connect. at
       some point even if we are a connectionless protocol, we may
       still want to "connect" for convenience raj 2008-01-14 */
    need_to_connect = (protocol != IPPROTO_UDP);
      
    /* Set-up the test end conditions. For tests over a
       "reliable/connection-oriented" transport (eg TCP, SCTP, etc) this
       can be either time or byte/transaction count based.  for
       unreliable transport or connection tests it can only be time
       based.  having said that, we rely entirely on other code to
       enforce this before we even get here. raj 2008-01-08 */
    
    if (test_time) {
      /* The user wanted to end the test after a period of time.  if
	 we are a recv-only test, we need to protect ourself against
	 the remote going poof, but we want to make sure we don't
	 give-up before they finish, so we will add a PAD_TIME to the
	 timer.  if we are RR or XMIT, there should be no need for
	 padding */
      times_up = 0;
      units_remaining = 0;
      if ((!no_control) && (NETPERF_RECV_ONLY(direction)))
	pad_time = PAD_TIME;
      start_timer(test_time + pad_time);
    }
    else {
      /* The tester wanted to send a number of bytes or exchange a
	 number of transactions. */
      if (NETPERF_IS_RR(direction))
	units_remaining = test_trans;
      else
	units_remaining = test_bytes;
      times_up = 1;
    }
    
    /* grab the current time, and if necessary any starting information
       for the gathering of CPU utilization at this end. */
    cpu_start(local_cpu_usage);

#if defined(WANT_INTERVALS)
    INTERVALS_INIT();
#endif /* WANT_INTERVALS */

#ifdef WANT_DEMO
    if (demo_mode) {
      HIST_timestamp(demo_one_ptr);
    }
#endif
    
    /* the "OR" here allows us to control test length by either
       byte/transaction count or by timer.  when the test is
       byte/transaction count based the time test will always evaluate
       false. when the test is controlled by time, the byte/transaction
       count will always evaluate to false.  when the test is finished
       the whole expression will go false and we will stop sending
       data. at least that is the plan :)  raj 2008-01-08 */
    
    while ((!times_up) || (units_remaining > 0)) {
      
#ifdef WANT_HISTOGRAM
      /* only pull the timestamp if we are actually going to use the
	 results of the work.  we put the call here so it can work for
	 any sort of test - connection, request/response, or stream.
	 no, it isn't "perfect" for all of them - for some it will
	 include a few more "if's" than a purpose-written routine, but
	 it _should_ be the case that the time spent up here is
	 epsilon compared to time spent elsewhere in the stack so it
	 should not be a big deal.  famous last words of raj
	 2008-01-08 */
      if (verbosity > 1) {
	HIST_timestamp(&time_one);
      }
#endif /* WANT_HISTOGRAM */

    again:

      if (need_socket) {
	if (connection_test) 
	  pick_next_port_number(local_res,remote_res);

	data_socket = create_data_socket(local_res);
  
	if (data_socket == INVALID_SOCKET) {
	  perror("netperf: send_omni: unable to create data socket");
	  exit(1);
	}
	need_socket = 0;
      }

      /* only connect if and when we need to */
      if (need_to_connect) {
	/* assign to data_socket since connect_data_socket returns
	   SOCKET and not int thanks to Windows. */
	ret = connect_data_socket(data_socket,remote_res);
	if (ret == 0) {
	  connected = 1;
	  need_to_connect = 0;
	}
	else if (ret == -1) {
	  times_up = 1;
	  timed_out = 1;
	  break;
	}
	else if ((ret == -2) && connection_test) {
	  /* transient error  on a connection test means go around and
	     try again with another local port number */
	  fprintf(where,"transient! transient! torpedo in the water!\n");
	  fflush(where);
	  close(data_socket);
	  connected = 0;  /* probably redundant but what the heck... */
	  need_socket = 1;
	  need_to_connect = 1;
	  /* this will stuff the next local port number within bounds
	     into our local res, and then when the goto has us
	     allocating a new socket it will do the right thing with the
	     bind() call */
	  pick_next_port_number(local_res,remote_res);
	  goto again;
	}
	else {
	  /* either this was a hard failure (-3) or a soft failure on
	     something other than a connection test */
	  perror("netperf: send_omni: connect_data_socket failed");
	  exit(1);
	}
      }

#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 */
      /* we only want to inject the burst if this is a full-on
	 request/response test. otherwise it doesn't make any sense
	 anyway. raj 2008-01-25 */
      while ((first_burst_size > 0) &&
	     (requests_outstanding < request_cwnd) &&
	     (requests_outstanding < first_burst_size) &&
	     (NETPERF_IS_RR(direction)) &&
	     (!connection_test)) {
	if (debug) {
	  fprintf(where,
		  "injecting, req_outstanding %d req_cwnd %d burst %d\n",
		  requests_outstanding,
		  request_cwnd,
		  first_burst_size);
	}
	if ((ret = send_data(data_socket,
			     send_ring,
			     bytes_to_send,
			     (connected) ? NULL : remote_res->ai_addr,
			     remote_res->ai_addrlen)) != bytes_to_send) {
	  /* in theory, we should never hit the end of the test in the
	     first burst */
	  perror("send_omni: initial burst data send error");
	  exit(-1);
	}
	local_send_calls += 1;
	requests_outstanding += 1;
      }

#endif /* WANT_FIRST_BURST */

      /* if we should try to send something, then by all means, let us
	 try to send something. */
      if (direction & NETPERF_XMIT) {
	ret = send_data(data_socket,
			send_ring,
			bytes_to_send,
			(connected) ? NULL : remote_res->ai_addr,
			/* if the destination above is NULL, this is ignored */
			remote_res->ai_addrlen);
	/* the order of these if's will seem a triffle strange, but they
	   are my best guess as to order of probabilty and/or importance
	   to the overhead raj 2008-01-09*/
	if (ret == bytes_to_send) {
	  /* if this is a send-only test controlled by byte count we
	     decrement units_remaining by the bytes sent */
	  if (!(direction & NETPERF_RECV) && (units_remaining > 0)) {
	    units_remaining -= ret;
	  }
	  bytes_sent += ret;
	  send_ring = send_ring->next;
	  local_send_calls++;
	}
	else if (ret == -2) {
	  /* what to do here -2 means a non-fatal error - probably
	     ENOBUFS and so our send didn't happen.  in the old code for
	     UDP_STREAM we would just continue in the while loop.  it
	     isn't clear that is what to do here, so we will simply
	     increment the failed_sends stat and fall-through. If this
	     is a UDP_STREAM style of test, the net effect should be the
	     same. if this is a UDP_RR with a really-big burst count, I
	     don't think we were checking for ENOBUFS there anyway and
	     so would have failed.  Here we can just let things
	     slide. */
	  failed_sends++;
	}
	else if (ret == 0) {
	  /* was this a zero-byte send? if it was, then ostensibly we
	     would hit the ret == bytes_to_send case which means we'd
	     never get here as we are using blocking semantics */
	  fprintf(where,"HOW DID I GET HERE?\n");
	  fflush(where);
	}
	else if (ret == -1) {
	  times_up = 1;
	  timed_out = 1;
	  break;
	}
	else {
	  perror("netperf: send_omni: send_data failed");
	  exit(1);
	}

      }

#ifdef WANT_FIRST_BURST
      /* it isn't clear we need to check the directions here.  the
	 increment should be cheaper than the conditional, and it
	 shouldn't hurt the other directions because they'll never
	 look at them. famous last words of raj 2008-01-25 */
      requests_outstanding += 1;
#endif

      if (direction & NETPERF_RECV) {
	rret = recv_data(data_socket,
			recv_ring,
			bytes_to_recv,
			(connected) ? NULL : (struct sockaddr *)&remote_addr,
			/* if remote_addr NULL this is ignored */
			&remote_addr_len,
			/* if XMIT also set this is RR so waitall */
			(direction & NETPERF_XMIT) ? NETPERF_WAITALL: 0,
			&temp_recvs);
	if (rret > 0) {
	  /* if this is a recv-only test controlled by byte count we
	     decrement the units_remaining by the bytes received */
	  if (!(direction & NETPERF_XMIT) && (units_remaining > 0)) {
	    units_remaining -= rret;
	  }
	  bytes_received += rret;
	  local_receive_calls += temp_recvs;
	}
	else if (rret == 0) {
	  /* is this the end of a test, just a zero-byte recv, or
	     something else? that is an exceedingly good question and
	     one for which I don't presently have a good answer, but
	     that won't stop me from guessing :) raj 2008-01-09 */
	  if (!((connection_test) || (null_message_ok))) {
	    /* if it is neither a connection_test nor null_message_ok it
	       must be the end of the test */
	    times_up = 1; /* ostensibly the signal handler did this */
	    break;
	  }
	  local_receive_calls += temp_recvs;
	}
	else if (rret == -1) {
	  /* test timed-out */
	  times_up = 1;
	  timed_out = 1;
	  break;
	}
	else {
	  /* presently at least, -2 and -3 are equally bad on recv */
	  perror("netperf: send_omni: recv_data failed");
	  exit(1);
	}
	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) &&
	    (NETPERF_IS_RR(direction))) {
	  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 this is a connection test, we want to do some stuff about
	 connection close here in the test loop. raj 2008-01-08 */
      if (connection_test) {

#ifdef __linux
	/* so, "Linux" with autotuning likes to alter the socket buffer
	   sizes over the life of the connection, but only does so when
	   one takes the defaults at time of socket creation.  if we
	   took those defaults, we should inquire as to what the values
	   ultimately became. raj 2008-01-15 */
	if (lsr_size_req < 0)
	  get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
	else
	  lsr_size_end = lsr_size;
	if (lss_size_req < 0)
	  get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
	else
	  lss_size_end = lss_size;
#else
	lsr_size_end = lsr_size;
	lss_size_end = lss_size;
#endif

	/* we will only make this call the one time - after the first
	   call, the value will be real or -1. if this is a connection
	   test we want to do this here because later we won't be
	   connected and the data may no longer be available */
	if (transport_mss == -2) 
	  get_transport_info(data_socket,
			     &transport_mss,
			     local_res->ai_protocol);


	ret = disconnect_data_socket(data_socket,
				     (no_control) ? 1 : 0,
				     1,
				     NULL,
				     0);
	if (ret == 0) {
	  /* we will need a new connection to be established next time
	     around the loop */
	  need_to_connect = 1;
	  connected = 0;
	  need_socket = 1;
	  pick_next_port_number(local_res,remote_res);
	}
	else if (ret == -1) {
	  times_up = 1;
	  timed_out = 1;
	  break;
	}
	else {
	  perror("netperf: send_omni: disconnect_data_socket failed");
	  exit(1);
	}
      }


#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
      if (NETPERF_IS_RR(direction)) {
	DEMO_INTERVAL(1);
      }
      else if (NETPERF_XMIT_ONLY(direction)) {
	DEMO_INTERVAL(bytes_to_send);
      }
      else {
	DEMO_INTERVAL(rret);
      }
#endif

#if defined(WANT_INTERVALS)
      INTERVALS_WAIT();
#endif /* WANT_INTERVALS */


      /* was this a "transaction" test? */ 
      if (NETPERF_IS_RR(direction)) {
	trans_completed++;
	if (units_remaining) {
	  units_remaining--;
	}
      }
    
    
    }

    /* we are now, ostensibly, at the end of this iteration */

    if (transport_mss == -2) 
      get_transport_info(data_socket,
			 &transport_mss,
			 local_res->ai_protocol);
    

    find_security_info(&local_security_enabled_num,
		       &local_security_type_id,
		       &local_security_specific);
    local_security_enabled = nsec_enabled_to_str(local_security_enabled_num);
    local_security_type    = nsec_type_to_str(local_security_type_id);

    /* so, if we have/had a data connection, we will want to close it
       now, and this will be independent of whether there is a control
       connection. */

    if (connected) {

#ifdef __linux
      /* so, "Linux" with autotuning likes to alter the socket buffer
	 sizes over the life of the connection, but only does so when
	 one takes the defaults at time of socket creation.  if we took
	 those defaults, we should inquire as to what the values
	 ultimately became. raj 2008-01-15 */
      if (lsr_size_req < 0)
	get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
      else
	lsr_size_end = lsr_size;
      if (lss_size_req < 0)
	get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
      else
	lss_size_end = lss_size;
#else
      lsr_size_end = lsr_size;
      lss_size_end = lss_size;
#endif
      /* CHECK PARMS HERE; */
      ret = disconnect_data_socket(data_socket,
				   1,
				   1,
				   NULL,
				   0);
      connected = 0;
      need_socket = 1;

    }
    else {
      /* this is the UDP case at present */
      ret = disconnect_data_socket(data_socket,
				   1,
				   1,
				   remote_res->ai_addr,
				   remote_res->ai_addrlen);
      need_socket = 1;
      lsr_size_end = lsr_size;
      lss_size_end = lss_size;
    }

    /* 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);
    
    find_system_info(&local_system_model,
		     &local_cpu_model,
		     &local_cpu_frequency);

    local_interface_name = 
      find_egress_interface(local_res->ai_addr,remote_res->ai_addr);

    find_driver_info(local_interface_name,local_driver_name,local_driver_version,local_driver_firmware,local_driver_bus,32);

    local_interface_slot = find_interface_slot(local_interface_name);

    find_interface_ids(local_interface_name,
		       &local_interface_vendor,
		       &local_interface_device,
		       &local_interface_subvendor,
		       &local_interface_subdevice);

    /* if we timed-out, and had padded the timer, we need to subtract
       the pad_time from the elapsed time on the assumption that we
       were essentially idle for pad_time and just waiting for a timer
       to expire on something like a UDP test.  if we have not padded
       the timer, pad_time will be zero.  if we have not timed out
       then we want to make sure we stop the timer. */
    if (timed_out) {
      if (debug) {
	fprintf(where,"Adjusting elapsed_time by %d seconds\n",pad_time);
	fflush(where);
      }
      elapsed_time -= (float)pad_time;
    }
    else {
      stop_timer();
    }

    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_n(OMNI_RESULTS_CONF_CUTOFF);
      if (!netperf_response.content.serv_errno) {
	if (debug)
	  fprintf(where,"remote results obtained\n");
	remote_cpu_method = format_cpu_method(omni_result->cpu_method);
	/* why?  because some stacks want to be clever and autotune their
	   socket buffer sizes, which means that if we accept the defaults,
	   the size we get from getsockopt() at the beginning of a
	   connection may not be what we would get at the end of the
	   connection... */
	lib_num_rem_cpus = omni_result->num_cpus;
	lib_remote_peak_cpu_util = (double)omni_result->peak_cpu_util;
	lib_remote_peak_cpu_id = omni_result->peak_cpu_id;
	rsr_size_end = omni_result->recv_buf_size;
	rss_size_end = omni_result->send_buf_size;
	remote_bytes_sent = (uint64_t)omni_result->bytes_sent_hi << 32;
	remote_bytes_sent += omni_result->bytes_sent_lo;
	remote_send_calls = omni_result->send_calls;
	remote_bytes_received = (uint64_t)omni_result->bytes_received_hi << 32;
	remote_bytes_received += omni_result->bytes_received_lo;
	remote_receive_calls = omni_result->recv_calls;
	remote_bytes_xferd = remote_bytes_received + remote_bytes_sent;
	if (omni_result->recv_calls > 0)
	  remote_bytes_per_recv = (double) remote_bytes_received /
	    (double) omni_result->recv_calls;
	else
	  remote_bytes_per_recv = 0.0;
	if (omni_result->send_calls > 0)
	  remote_bytes_per_send = (double) remote_bytes_sent /
	    (double) omni_result->send_calls;
	else
	  remote_bytes_per_send = 0.0;
	omni_result->ifname[15] = 0; /* belt and suspenders */
	remote_interface_name = strdup(omni_result->ifname);
	remote_interface_slot = strdup(omni_result->ifslot);
	strncpy(remote_driver_name,omni_result->driver,32);
	strncpy(remote_driver_version,omni_result->version,32);
	strncpy(remote_driver_firmware,omni_result->firmware,32);
	strncpy(remote_driver_bus,omni_result->bus,32);
	remote_driver_name[31] = 0;
	remote_driver_version[31] = 0;
	remote_driver_firmware[31] = 0;
	remote_driver_bus[31] = 0;
	remote_interface_vendor = omni_result->vendor;
	remote_interface_device = omni_result->device;
	remote_interface_subvendor = omni_result->subvendor;
	remote_interface_subdevice = omni_result->subdevice;
      }
      else {
	Set_errno(netperf_response.content.serv_errno);
	fprintf(where,
		"netperf: remote error %d",
		netperf_response.content.serv_errno);
	perror("");
	fflush(where);
      
	exit(1);
      }
    }

    /* so, what was the end result? */
    local_cpu_method = format_cpu_method(cpu_method);

    if (local_send_calls > 0) 
      bytes_per_send = (double) bytes_sent / (double) local_send_calls;
    else bytes_per_send = 0.0;

    if (local_receive_calls > 0)
      bytes_per_recv = (double) bytes_received / (double) local_receive_calls;
    else
      bytes_per_recv = 0.0;
    
    bytes_xferd  = bytes_sent + bytes_received;

    /* if the output format is 'x' we know the test was
       request/response.  if the libfmt is something else, it could be
       xmit, recv or bidirectional. if we were the receiver then we
       can use our byte totals even if it is
       UDP/unreliable. otherwise, we use the remote totals - they
       should be the same if the protocol is reliable, and if it is
       unreliable then we want what was actually received */
    if ('x' == libfmt)
      /* it was a request/response test */
      thruput = calc_thruput(trans_completed);
    else if (NETPERF_RECV_ONLY(direction))
      thruput      = calc_thruput(bytes_xferd);
    else 
      thruput = calc_thruput(remote_bytes_xferd);

    if (NETPERF_IS_RR(direction)) {
      char tmpfmt;
      if (!connection_test) {
      /* calculate the round trip latency, using the transaction rate
	 whether or not the user was asking for thruput to be in 'x'
	 units please... however... a connection_test only ever has
	 one transaction in flight at one time */
      rtt_latency = 
	(((double)1.0/(trans_completed/elapsed_time)) * (double)1000000.0) * 
	(double) (1 + ((first_burst_size > 0) ? first_burst_size : 0));
      }
      else 
	rtt_latency = 
	  ((double)1.0/(trans_completed/elapsed_time)) * (double)1000000.0;
      tmpfmt = libfmt;
      libfmt = 'x';
      transaction_rate = calc_thruput(trans_completed);
      libfmt = tmpfmt;
    }

    /* ok, time to possibly calculate cpu util and/or service demand */
    if (local_cpu_usage) {

      local_cpu_utilization = calc_cpu_util(elapsed_time);

      /* we need to decide what to feed the service demand beast,
	 which will, ultimately, depend on what sort of test it is and
	 whether or not the user asked for something specific - as in
	 per KB even on a TCP_RR test if it is being (ab)used as a
	 bidirectional bulk-transfer test. raj 2008-01-14 */
      local_service_demand  = 
	calc_service_demand_fmt(('x' == libfmt) ? (double)trans_completed: bytes_xferd,
				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 = omni_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_fmt(('x' == libfmt) ? (double) trans_completed: bytes_xferd,
				0.0,
				remote_cpu_utilization,
				omni_result->num_cpus);
    }
    else {
      remote_cpu_utilization = (float) -1.0;
      remote_service_demand  = (float) -1.0;
    }
    
    /* time to calculate our confidence */
    calculate_confidence(confidence_iteration,
			 elapsed_time,
			 thruput,
			 local_cpu_utilization,
			 remote_cpu_utilization,
			 local_service_demand,
			 remote_service_demand);

    /* this this is the end of the confidence while loop? */
    confidence_iteration++;
  }

  /* we end with confidence_iteration one larger than the number of
     iterations.  if we weren't doing confidence intervals this will
     still be reported as one */
  confidence_iteration--;

  /* at some point we may want to actually display some results :) */

  retrieve_confident_values(&elapsed_time,
			    &thruput,
			    &local_cpu_utilization,
			    &remote_cpu_utilization,
			    &local_service_demand,
			    &remote_service_demand);

  /* a kludge for omni printing because I don't know how to tell that
     something is a float vs a double in my_snprintf() given what it
     is passed and I'm not ready to force all the netlib.c stuff to
     use doubles rather than floats. help there would be
     appreciated. raj 2008-01-28 */
  elapsed_time_double = (double) elapsed_time;
  local_cpu_utilization_double = (double)local_cpu_utilization;
  local_service_demand_double = (double)local_service_demand;
  remote_cpu_utilization_double = (double)remote_cpu_utilization;
  remote_service_demand_double = (double)remote_service_demand;

  if ('x' == libfmt) sd_str = "usec/Tran";
  else sd_str = "usec/KB";
  
  if (iteration_max > 1) {
    result_confid_pct = get_result_confid();
    loc_cpu_confid_pct = get_loc_cpu_confid();
    rem_cpu_confid_pct = get_rem_cpu_confid();
    interval_pct = interval * 100.0;
  }

  /* at some point we need to average these during a confidence
     interval run, and when we do do that, we need to make sure we
     restore the value of libfmt correctly */
  if ('x' == libfmt) libfmt = 'm';
  local_send_thruput = calc_thruput(bytes_sent);
  local_recv_thruput = calc_thruput(bytes_received);
  remote_send_thruput = calc_thruput(remote_bytes_sent);
  remote_recv_thruput = calc_thruput(remote_bytes_received);

  print_omni();

#if defined(DEBUG_OMNI_OUTPUT)  
 {
   /* just something quick to sanity check the output selectors. this
      should be gone for "production" :) */
   int i;
   print_omni_init();
   output_csv_list[1] = OUTPUT_END;
   for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
     output_csv_list[0] = i;
     print_omni_csv();
   }
 }
#endif

  /* likely as not we are going to do something slightly different here */
  if (verbosity > 1) {

#ifdef WANT_HISTOGRAM
    fprintf(where,"\nHistogram of ");
    if (NETPERF_RECV_ONLY(direction)) 
      fprintf(where,"recv");
    if (NETPERF_XMIT_ONLY(direction))
      fprintf(where,"send");
    if (NETPERF_IS_RR(direction)) {
      if (connection_test) {
	if (NETPERF_CC(direction)) {
	  fprintf(where,"connect/close");
	}
	else {
	  fprintf(where,"connect/request/response/close");
	}
      }
      else {
	fprintf(where,"request/response");
      }
    }
    fprintf(where," times\n");
    fflush(where);
    HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */

  }
  
}


/* the name is something of a misnomer since this test could send, or
   receive, or both, but it matches the historical netperf routine
   naming. */
void
recv_omni()
{
  
  char  *message;
  struct addrinfo *local_res;
  char local_name[BUFSIZ];
  char port_buffer[PORTBUFSIZE];

  struct sockaddr_storage myaddr_in, peeraddr_in;
  SOCKET s_listen, data_socket;
  netperf_socklen_t 	addrlen;

  struct ring_elt *send_ring;
  struct ring_elt *recv_ring;

  int	timed_out = 0;
  int   pad_time = 0;
  int   need_to_connect;
  int   need_to_accept;
  int   connected;
  int   ret;
  int   temp_recvs;
  
  struct	omni_request_struct	*omni_request;
  struct	omni_response_struct	*omni_response;
  struct	omni_results_struct	*omni_results;
  
  omni_request = 
    (struct omni_request_struct *)netperf_request.content.test_specific_data;
  omni_response = 
    (struct omni_response_struct *)netperf_response.content.test_specific_data;
  omni_results = 
    (struct omni_results_struct *)netperf_response.content.test_specific_data;
  
  if (debug) {
    fprintf(where,"netserver: recv_omni: entered...\n");
    fflush(where);
  }
  
  /* based on what we have been told by the remote netperf, we want to
     setup our endpoint for the "data connection" and let the remote
     netperf know the situation. */

  if (debug) {
    fprintf(where,"recv_omni: setting the response type...\n");
    fflush(where);
  }
  
  netperf_response.content.response_type = OMNI_RESPONSE;
  
  if (debug) {
    fprintf(where,"recv_omni: the response type is set...\n");
    fflush(where);
  }

  /* Grab a socket to listen on, and then listen on it. */
  
  if (debug) {
    fprintf(where,"recv_omni: 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 = omni_request->send_buf_size;
  lsr_size_req = omni_request->recv_buf_size;
  loc_nodelay = omni_request->no_delay;
  loc_rcvavoid = omni_request->so_rcvavoid;
  loc_sndavoid = omni_request->so_sndavoid;

#ifdef WANT_INTERVALS
  interval_usecs = omni_request->interval_usecs;
  interval_wate  = interval_usecs / 1000;
  interval_burst = omni_request->interval_burst;
#else
  interval_usecs = 0;
  interval_wate  = 1;
  interval_burst = 0;
#endif

  connection_test = omni_request->connect_test;
  direction       = omni_request->direction;

  set_hostname_and_port(local_name,
			port_buffer,
			nf_to_af(omni_request->ipfamily),
			omni_request->data_port);

  local_res = complete_addrinfo(local_name,
				local_name,
				port_buffer,
				nf_to_af(omni_request->ipfamily),
				nst_to_hst(omni_request->socket_type),
				omni_request->protocol,
				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);
  }

  /* We now alter the message_ptr variables to be at the desired */
  /* alignments with the desired offsets. */
  
  if (debug) {
    fprintf(where,
	    "recv_omni: requested recv alignment of %d offset %d\n",
	    omni_request->recv_alignment,
	    omni_request->recv_offset);
    fprintf(where,
	    "recv_omni: requested send alignment of %d offset %d\n",
	    omni_request->send_alignment,
	    omni_request->send_offset);
    fflush(where);
  }

  omni_response->send_size = omni_request->send_size;
  omni_response->send_width = omni_request->send_width;
  if (omni_request->direction & NETPERF_XMIT) {
    if (omni_request->response_size > 0) {
      /* request/response_test */
      bytes_to_send = omni_request->response_size;
      if (omni_request->send_width == 0) send_width = 1;
      else send_width = omni_request->send_width;
    }
    else {
      if (omni_request->send_size == -1) {
	if (lss_size > 0) bytes_to_send = lss_size;
	else bytes_to_send = 4096;
      }
      else bytes_to_send = omni_request->send_size;
      /* set the send_width */
      if (omni_request->send_width == 0) {
	send_width = (lss_size/bytes_to_send) + 1;
	if (send_width == 1) send_width++;
      }
      else
	send_width = omni_request->send_width;
    }
    send_ring = allocate_buffer_ring(send_width,
				     bytes_to_send,
				     omni_request->send_alignment,
				     omni_request->send_offset);
				     
    omni_response->send_width = send_width;
    omni_response->send_size = bytes_to_send;
  }

  omni_response->receive_size = omni_request->receive_size;
  omni_response->recv_width = omni_response->recv_width;
  if (omni_request->direction & NETPERF_RECV) {
    if (omni_request->request_size > 0) {
      /* request/response test */
      bytes_to_recv = omni_request->request_size;
      if (omni_request->recv_width == 0) recv_width = 1;
      else recv_width = omni_request->recv_width;
    }
    else {
      if (omni_request->receive_size == -1) {
	if (lsr_size > 0) bytes_to_recv = lsr_size;
	else  bytes_to_recv = 4096;
      }
      else {
	bytes_to_recv = omni_request->receive_size;
      }
      /* set the recv_width */
      if (omni_request->recv_width == 0) {
	recv_width = (lsr_size/bytes_to_recv) + 1;
	if (recv_width == 1) recv_width++;
      }
      else 
	recv_width = omni_request->recv_width;
    }
    recv_ring = allocate_buffer_ring(recv_width,
				     bytes_to_recv,
				     omni_request->recv_alignment,
				     omni_request->recv_offset);
				     
    omni_response->receive_size = bytes_to_recv;
    omni_response->recv_width = recv_width;
  }

#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

  need_to_accept = (omni_request->protocol != IPPROTO_UDP);
  
  /* we need to hang a listen for everything that needs at least one
     accept */
  if (need_to_accept) {
    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. likely as not, the IP
     address will be the wildcard - so we only really need to extract
     the port number. since send_response is going to call htonl on
     all the fields, we want to initially put the port number in there
     in host order. */
  
  omni_response->data_port = 
    (int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
  if (debug) {
    fprintf(where,"telling the remote to call me at %d\n",
	    omni_response->data_port);
    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. */
  
  omni_response->cpu_rate = (float)0.0; 	/* assume no cpu */
  omni_response->measure_cpu = 0;
  if (omni_request->measure_cpu) {
    omni_response->measure_cpu = 1;
    omni_response->cpu_rate = 
      calibrate_local_cpu(omni_request->cpu_rate);
  }
  
  /* before we send the response back to the initiator, pull some of */
  /* the socket parms from the globals */
  omni_response->send_buf_size = lss_size;
  omni_response->recv_buf_size = lsr_size;
  omni_response->no_delay = loc_nodelay;
  omni_response->so_rcvavoid = loc_rcvavoid;
  omni_response->so_sndavoid = loc_sndavoid;
  omni_response->interval_usecs = interval_usecs;
  omni_response->interval_burst = interval_burst;

  find_system_info(&local_system_model,&local_cpu_model,&local_cpu_frequency);
  strncpy(omni_response->system_model,local_system_model,sizeof(omni_response->system_model));
  omni_response->system_model[sizeof(omni_response->system_model)-1] = 0;
  strncpy(omni_response->cpu_model,local_cpu_model,sizeof(omni_response->cpu_model));
  omni_response->cpu_model[sizeof(omni_response->cpu_model)-1] = 0;
  omni_response->cpu_frequency = local_cpu_frequency;

  find_security_info(&local_security_enabled_num,
		     &local_security_type_id,
		     &local_security_specific);
  /* top bits type, bottom bits enabled */
  omni_response->security_info = local_security_type_id << 16;
  omni_response->security_info += local_security_enabled_num & 0xffff;
  strncpy(omni_response->security_string,
	  local_security_specific,
	  sizeof(omni_response->security_string));
  omni_response->security_string[sizeof(omni_response->security_string)-1] = 0;

  send_response_n(OMNI_RESPONSE_CONV_CUTOFF); /* brittle, but functional */

  local_send_calls = 0;
  local_receive_calls = 0;

  addrlen = sizeof(peeraddr_in);
  memset(&peeraddr_in,0,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(omni_request->measure_cpu);

  /* if the test is timed, set a timer of suitable length.  if the
     test is by byte/transaction count, we don't need a timer - or
     rather we rely on the netperf to only ask us to do transaction
     counts over "reliable" protocols.  perhaps at some point we
     should add a check herebouts to verify that... */

  if (omni_request->test_length > 0) {
    times_up = 0;
    units_remaining = 0;
    /* if we are the sender and only sending, then we don't need/want
       the padding, otherwise, we need the padding */ 
    if (!(NETPERF_XMIT_ONLY(omni_request->direction)))
      pad_time = PAD_TIME;
    start_timer(omni_request->test_length + pad_time);
  }
  else {
    times_up = 1;
    units_remaining = omni_request->test_length * -1;
  }

#if defined(WANT_INTERVALS)
  INTERVALS_INIT();
#endif /* WANT_INTERVALS */
  
  
  trans_completed = 0;
  bytes_sent = 0;
  bytes_received = 0;
  connected = 0;

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

    if (need_to_accept) {
      /* 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 ((data_socket=accept(s_listen,
			      (struct sockaddr *)&peeraddr_in,
			      &addrlen)) == INVALID_SOCKET) {
	if (errno == EINTR) {
	  /* the timer popped */
	  times_up = 1; /* ostensibly the signal hander dealt with this?*/
	  timed_out = 1;
	  break;
	}
	fprintf(where,"recv_omni: accept: errno = %d\n",errno);
	fflush(where);
	close(s_listen);
	
	exit(1);
      }
      
      if (debug) {
	fprintf(where,"recv_omni: accepted data connection.\n");
	fflush(where);
      }
      need_to_accept = 0;
      connected = 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(data_socket);

#endif /* KLUDGE_SOCKET_OPTIONS */
  
    }
    else {
      /* I wonder if duping would be better here? we also need to set
	 peeraddr_in so we can send to netperf if this isn't a
	 request/response test or if we are going to connect() the
	 socket */
      if (omni_request->protocol == IPPROTO_UDP) {
	data_socket = s_listen;
	set_sockaddr_family_addr_port(&peeraddr_in,
				      nf_to_af(omni_request->ipfamily),
				      omni_request->ipaddr,
				      omni_request->netperf_port);
      }
    }

    if (need_to_connect) {
      /* initially this will only be used for UDP tests as a TCP or
	 other connection-oriented test will always have us making an
	 accept() call raj 2008-01-11 */
    }
  
#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 = data_socket;
#endif /* WIN32 */

    /* in recv_omni, we check recv first, and _then_ send, otherwise,
       a request/response test will be all messed-up :) and that then
       is why there are two routines to rule them all rather than just
       one :) */
    if ((omni_request->direction & NETPERF_RECV) &&
	!times_up) {
      ret = recv_data(data_socket,
		      recv_ring,
		      bytes_to_recv,
		      (connected) ? NULL : (struct sockaddr *)&peeraddr_in,
		      &addrlen,
		      /* if XMIT also, then this is RR test so waitall */
		      (direction & NETPERF_XMIT) ? NETPERF_WAITALL: 0,
		      &temp_recvs);
      if (ret > 0) {
	/* if this is a recv-only test controlled by byte count we
	   decrement the units_remaining by the bytes received */
	if (!(direction & NETPERF_XMIT) && (units_remaining > 0)) {
	  units_remaining -= ret;
	}
	bytes_received += ret;
	local_receive_calls += temp_recvs;
      }
      else if (ret == 0) {
	/* is this the end of a test, just a zero-byte recv, or
	   something else? that is an exceedingly good question and
	   one for which I don't presently have a good answer, but
	   that won't stop me from guessing :) raj 2008-01-09 */
	fprintf(where,"read zero conn_test %d null_message_ok %d\n",
		connection_test,null_message_ok);
	fflush(where);
	if (!((connection_test) || (null_message_ok))) {
	  /* if it is neither a connection_test nor null_message_ok it
	     must be the end of the test */
	  times_up = 1;
	  break;
	}
	local_receive_calls += temp_recvs;
      }
      else if (ret == -1) {
	/* test timed-out */
	fprintf(where,"YO! TIMESUP!\n");
	fflush(where);
	times_up = 1;
	timed_out = 1;
	break;
      }
      else {
	/* presently at least, -2 and -3 are equally bad on recv */
	/* we need a response message here for the control connection
	   before we exit! */
	exit(1);
      }
      recv_ring = recv_ring->next;
    }

    /* if we should try to send something, then by all means, let us
       try to send something. */
    if ((omni_request->direction & NETPERF_XMIT) &&
	!times_up) {
      ret = send_data(data_socket,
		      send_ring,
		      bytes_to_send,
		      (connected) ? NULL : (struct sockaddr *)&peeraddr_in,
		      addrlen);

      /* the order of these if's will seem a triffle strange, but they
	 are my best guess as to order of probabilty and/or importance
	 to the overhead raj 2008-01-09*/
      if (ret == bytes_to_send) {
	/* if this is a send-only test controlled by byte count we
	   decrement units_remaining by the bytes sent */
	if (!(direction & NETPERF_RECV) && (units_remaining > 0)) {
	  units_remaining -= ret;
	}
	bytes_sent += ret;
	send_ring = send_ring->next;
	local_send_calls++;
      }
      else if (ret == -2) {
	/* what to do here -2 means a non-fatal error - probably
	   ENOBUFS and so our send didn't happen.  in the old code for
	   UDP_STREAM we would just continue in the while loop.  it
	   isn't clear that is what to do here, so we will simply
	   increment the failed_sends stat and fall-through. If this
	   is a UDP_STREAM style of test, the net effect should be the
	   same. if this is a UDP_RR with a really-big burst count, I
	   don't think we were checking for ENOBUFS there anyway and
	   so would have failed.  Here we can just let things
	   slide. */
	failed_sends++;
      }
      else if (ret == 0) {
	/* was this a zero-byte send? if it was, then ostensibly we
	   would hit the ret == bytes_to_send case which means we'd
	   never get here as we are using blocking semantics */
      }
      else if (ret == -1) {
	times_up = 1;
	timed_out = 1;
	break;
      }
      else {
	/* we need a response message back to netperf here before we
	   exit */
	/* NEED RESPONSE; */
	exit(1);
      }

    }

    if (connection_test) {
#ifdef __linux
      /* so, "Linux" with autotuning likes to alter the socket buffer
	 sizes over the life of the connection, but only does so when
	 one takes the defaults at time of socket creation.  if we
	 took those defaults, we should inquire as to what the values
	 ultimately became. raj 2008-01-15 */
      if (lsr_size_req < 0)
	get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
      else
	lsr_size_end = lsr_size;
      if (lss_size_req < 0)
	get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
      else
	lss_size_end = lss_size;
#else
      lsr_size_end = lsr_size;
      lss_size_end = lss_size;
#endif
      ret = close_data_socket(data_socket,NULL,0);
      if (ret == -1) {
	times_up = 1;
	timed_out = 1;
	break;
      }
      else if (ret < 0) {
	perror("netperf: recv_omni: close_data_socket failed");
	fflush(where);
	exit(1);
      }
      /* we will need a new connection to be established */
      need_to_accept = 1;
      connected = 0;
    }

#if defined(WANT_INTERVALS)
    INTERVALS_WAIT();
#endif /* WANT_INTERVALS */

    /* was this a "transaction" test? don't for get that a TCP_CC
       style test will have no xmit or recv :) so, we check for either
       both XMIT and RECV set, or neither XMIT nor RECV set */
    if (NETPERF_IS_RR(omni_request->direction)) {
      trans_completed++;
      if (units_remaining) {
	units_remaining--;
      }
    }
  }

  /* The current iteration loop now exits due to timeout or unit count
     being  reached */
  
  cpu_stop(omni_request->measure_cpu,&elapsed_time);
  
  if (timed_out) {
    /* we ended the test by time, which may have been PAD_TIME seconds
       longer than we wanted to run. so, we want to subtract pad_time
       from the elapsed_time. if we didn't pad the timer pad_time will
       be 0 so we can just subtract it anyway :) */
    if (debug) {
      fprintf(where,"Adjusting elapsed time by %d seconds\n",pad_time);
      fflush(where);
    }
    elapsed_time -= pad_time;
  }

  if (connected) {
#ifdef __linux
    /* so, "Linux" with autotuning likes to alter the socket buffer
       sizes over the life of the connection, but only does so when
       one takes the defaults at time of socket creation.  if we took
       those defaults, we should inquire as to what the values
       ultimately became. raj 2008-01-15 */
    if (lsr_size_req < 0)
      get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
    else
      lsr_size_end = lsr_size;
    if (lss_size_req < 0)
      get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
    else
      lss_size_end = lss_size;
#else
    lsr_size_end = lsr_size;
    lss_size_end = lss_size;
#endif
    close_data_socket(data_socket,NULL,0);
  }
  else {
    close_data_socket(data_socket,(struct sockaddr *)&peeraddr_in,addrlen);
    lsr_size_end = lsr_size;
    lss_size_end = lss_size;
  }

  /* send the results to the sender  */
  
  omni_results->send_calls      = local_send_calls;
  omni_results->bytes_received_lo = bytes_received & 0x00000000FFFFFFFFULL;
  omni_results->bytes_received_hi = (bytes_received & 0xFFFFFFFF00000000ULL) >> 32;
  omni_results->recv_buf_size   = lsr_size_end;
  omni_results->recv_calls      = local_receive_calls;
  omni_results->bytes_sent_lo   = bytes_sent & 0x00000000FFFFFFFFULL;
  omni_results->bytes_sent_hi   = (bytes_sent & 0xFFFFFFFF00000000ULL) >> 32;
  omni_results->send_buf_size   = lss_size_end;
  omni_results->trans_received	= trans_completed;
  omni_results->elapsed_time	= elapsed_time;
  omni_results->cpu_method      = cpu_method;
  omni_results->num_cpus        = lib_num_loc_cpus;
  if (omni_request->measure_cpu) {
    omni_results->cpu_util = calc_cpu_util(elapsed_time);
  }
  omni_results->peak_cpu_util   = (float)lib_local_peak_cpu_util;
  omni_results->peak_cpu_id     = lib_local_peak_cpu_id;
  local_interface_name = 
    find_egress_interface(local_res->ai_addr,(struct sockaddr *)&peeraddr_in);
  strncpy(omni_results->ifname,local_interface_name,16);
  omni_results->ifname[15] = 0;
  local_interface_slot = find_interface_slot(local_interface_name);
  strncpy(omni_results->ifslot,local_interface_slot,16);
  omni_results->ifslot[15] = 0;
  find_interface_ids(local_interface_name,
		     &omni_results->vendor,
		     &omni_results->device,
		     &omni_results->subvendor,
		     &omni_results->subdevice);
  find_driver_info(local_interface_name,
		   omni_results->driver,
		   omni_results->version,
		   omni_results->firmware,
		   omni_results->bus,
		   32);
  if (debug) {
    fprintf(where,
	    "recv_omni: test complete, sending results.\n");
    fflush(where);
  }
  
  send_response_n(OMNI_RESULTS_CONF_CUTOFF);

  /* when we implement this, it will look a little strange, but we do
     it to avoid certain overheads when running aggregates and using
     confidence intervals.  we will post a recv_request() call to get
     the next message or EOF on the control connection.  either the
     netperf will close the control connection, which will tell us we
     are done, or the netperf will send us another "DO_OMNI" message,
     which by definition should be identical to the first DO_OMNI
     message we received.

     in this way we can avoid overheads like allocating the buffer
     rings and the listen socket and the like */
  
}

void
scan_omni_args(int argc, char *argv[])

{

#define OMNI_ARGS "b:cCd:DnNhH:kL:m:M:oOp:P:r:s:S:t:T:u:Vw:W:46"

  extern char	*optarg;	  /* pointer to option string	*/
  
  int		c;
  int           have_uuid = 0;

  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));

  /* default to a STREAM socket type. i wonder if this should be part
     of send_omni or here... */
  socket_type = nst_to_hst(NST_STREAM);
  socket_type_str = hst_to_str(socket_type);

  /* default to TCP. i wonder if this should be here or in
     send_omni? */
#ifdef IPPROTO_TCP
  protocol = IPPROTO_TCP;
#endif

  /* we will check to see if this needs to remain 0 or set to
     something else when we get finished scanning all the argument
     values */
  direction = 0;

  /* default is to be a stream test, so req_size and rsp_size should
     be < 0)  */

  req_size = rsp_size = -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, OMNI_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':
      /* this is a connection test */
      connection_test = 1;
      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':
      /* arbitrarily set the direction variable */
      direction = strtol(optarg,NULL,0);
      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);
	strcpy(remote_data_address,arg1);
      }
      if (arg2[0])
	remote_data_family = parse_address_family(arg2);
      break;
    case 'k':
      csv = 0;
      keyword = 1;
      /* obliterate any previous file name */
      if (human_selection_file) {
	free(human_selection_file);
	human_selection_file = NULL;
      }
      if (csv_selection_file) {
	free(csv_selection_file);
	csv_selection_file = NULL;
      }
      if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
	/* we assume that what follows is the name of a file with the
	   list of desired output values. */
	csv_selection_file = strdup(argv[optind]);
	optind++;
	/* special case - if the file name is "?" then we will emit a
	   list of the available outputs */
	if (strcmp(csv_selection_file,"?") == 0) {
	  dump_netperf_output_list(stdout,1);
	  exit(1);
	}
      }
      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);
	strcpy(local_data_address,arg1);
      }
      if (arg2[0])
	local_data_family = parse_address_family(arg2);
      break;
    case 'm':
      /* set the send size. if we set the local send size it will add
	 XMIT to direction.  if we set the remote send size it will
	 add RECV to the direction.  likely as not this will need some
	 additional throught */
      break_args_explicit(optarg,arg1,arg2);
      if (arg1[0]) {
	send_size = convert(arg1);
	direction |= NETPERF_XMIT;
      }
      if (arg2[0]) {
	remote_send_size_req = convert(arg2);
	direction |= NETPERF_RECV;
      }
      break;
    case 'M':
      /* set the recv sizes.  if we set the local recv size it will
	 add RECV to direction.  if we set the remote recv size it
	 will add XMIT to direction  */
      break_args_explicit(optarg,arg1,arg2);
      if (arg1[0]) {
	remote_recv_size_req = convert(arg1);
	direction |= NETPERF_XMIT;
      }
      if (arg2[0]) {
	recv_size = convert(arg2);
	direction |= NETPERF_RECV;
      }
      break;
    case 'n':
      /* set the local socket type */
      local_connected = 1;
      break;
    case 'N':
      /* set the remote socket type */
      remote_connected = 1;
      break;
    case 'o':
      csv = 1;
      keyword = 0;
      /* obliterate any previous file name */
      if (human_selection_file) {
	free(human_selection_file);
	human_selection_file = NULL;
      }
      if (csv_selection_file) {
	free(csv_selection_file);
	csv_selection_file = NULL;
      }
      if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
	/* we assume that what follows is the name of a file with the
	   list of desired output values. */
	csv_selection_file = strdup(argv[optind]);
	optind++;
	/* special case - if the file name is "?" then we will emit a
	   list of the available outputs */
	if (strcmp(csv_selection_file,"?") == 0) {
	  dump_netperf_output_list(stdout,1);
	  exit(1);
	}
      }
      break;
    case 'O':
      csv = 0;
      keyword = 0;
      /* obliterate any previous file name */
      if (human_selection_file) {
	free(human_selection_file);
	human_selection_file = NULL;
      }
      if (csv_selection_file) {
	free(csv_selection_file);
	csv_selection_file = NULL;
      }
      if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
	/* we assume that what follows is the name of a file with the
	   list of desired output values */
	human_selection_file = strdup(argv[optind]);
	optind++;
	if (strcmp(human_selection_file,"?") == 0) {
	  dump_netperf_output_list(stdout,0);
	  exit(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 'r':
      /* set the request/response sizes. setting request/response
	 sizes implicitly sets direction to XMIT and RECV */ 
      direction |= NETPERF_XMIT;
      direction |= NETPERF_RECV;
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	req_size = convert(arg1);
      if (arg2[0])	
	rsp_size = convert(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 't':
      /* set the socket type */
      socket_type = parse_socket_type(optarg);
      break;
    case 'T':
      /* set the protocol - aka "Transport" */
      protocol = parse_protocol(optarg);
      break;
    case 'u':
      /* use the supplied string as the UUID for this test. at some
	 point we may want to sanity check the string we are given but
	 for now we won't worry about it */
      strncpy(test_uuid,optarg,sizeof(test_uuid));
      /* strncpy may leave us with a string without a null at the end */
      test_uuid[sizeof(test_uuid) - 1] = 0;
      have_uuid = 1;
      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;
    };
  }

  /* generate the UUID for this test if the user has not supplied it */
  if (!have_uuid)
    get_uuid_string(test_uuid,sizeof(test_uuid));


  protocol_str = protocol_to_str(protocol);
  /* ok, if we have gone through all that, and direction is still
     zero, let us see if it needs to be set to something else. */
  if ((0 == direction) && (!connection_test)) direction = NETPERF_XMIT;
  direction_str = direction_to_str(direction);
  /* some other sanity checks we need to make would include stuff when
     the user has set -m and -M such that both XMIT and RECV are set
     and has not set -r. initially we will not allow that.  at some
     point we might allow that if the user has also set -r, but until
     then the code will simply ignore the values from -m and -M when
     -r is set. */

#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

  /* ok, time to sanity check the output units */
  if ('?' == libfmt) {
    /* if this is a RR test then set it to 'x' for transactions */
    if (NETPERF_IS_RR(direction)) {
      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 (!NETPERF_IS_RR(direction)) {
      libfmt = 'm';
    }
  }

  /* this needs to be strdup :) */
  thruput_format_str = strdup(format_units());

  /* so, if there is to be no control connection, we want to have some
     different settings for a few things */

  if (no_control) {

    fprintf(where,"I don't know about no control connection tests yet\n");
    exit(1);

    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);
    }
  }
}

#endif /* WANT_OMNI */