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

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

#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
#if HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#if HAVE_SCHED_H
# include <sched.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 */

#include <assert.h>

#ifndef WIN32
#include <sys/socket.h>
#include <netinet/in.h>

/* it would seem that including both <netinet/tcp.h> and <linux/tcp.h>
   is not a path to happiness and joy when one wishes to grab tcp_info
   stats and not get something like the compiler complaining about
   either redefinitions, or missing tcpi_total_retrans. */
#ifdef HAVE_LINUX_TCP_H
#include <linux/tcp.h>
#else
#include <netinet/tcp.h>
#endif

/* this is to get us the definition of MSG_FASTOPEN. we may need to
   cheat just a litle at first */
#ifdef HAVE_LINUX_SOCKET_H
# include <linux/socket.h>
# ifndef MSG_FASTOPEN
#  warning Using our own value for MSG_FASTOPEN
#  define MSG_FASTOPEN	0x20000000	/* Send data in TCP SYN */
# endif
# ifndef TCP_FASTOPEN
#  warning Using our own value for TCP_FASTOPEN
#  define TCP_FASTOPEN 23
# endif
#endif

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

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

#include "missing\stdint.h"
#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"

/* we only really use this once, but the initial patch to
   src/nettest_bsd.c used it in several places. keep it as a macro
   just for kicks and just in case we do end-up needing to use it
   multiple times. */

#define WAIT_BEFORE_DATA_TRAFFIC() \
{ \
  if (wait_time_secs) \
    sleep(wait_time_secs); \
} \


/* since someone can ask for latency stats, we will always include
   this and do the other other things */
#include "hist.h"

static HIST time_hist;


#ifdef WANT_INTERVALS
int interval_count;
unsigned int interval_wait_microseconds;

/* hoist the timestamps up here so we can use them to factor-out the
   time spent "waiting" */
/* first out timestamp */
#ifdef HAVE_GETHRTIME
static hrtime_t intvl_one;
static hrtime_t intvl_two;
static hrtime_t intvl_wait_start;
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_wait_start;
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_wait_start;
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

#ifndef WANT_SPIN
#ifdef WIN32
#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; \
    interval_wait_microseconds = 0;
#else
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; \
    interval_wait_microseconds = 0; \
    /* 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", \
	      __FUNCTION__, \
	      errno); \
      fflush(where); \
      exit(1); \
    }
#endif /* WIN32 */

#ifdef WIN32
#define INTERVALS_WAIT() \
      /* in this case, the interval count is the count-down counter \
	 to decide to sleep for a little bit */ \
      if ((interval_burst) && (--interval_count == 0)) { \
	/* call WaitForSingleObject and wait for the interval timer to get us \
	   out */ \
	if (debug > 1) { \
	  fprintf(where,"about to suspend\n"); \
	  fflush(where); \
	} \
        HIST_timestamp(&intvl_wait_start); \
    if (WaitForSingleObject(WinTimer, INFINITE) != WAIT_OBJECT_0) { \
        fprintf(where, "WaitForSingleObject failed (%d)\n", GetLastError()); \
	  fflush(where); \
	  exit(1); \
	} \
        HIST_timestamp(&intvl_two); \
        interval_wait_microseconds += \
          delta_micro(&intvl_wait_start,&intvl_two); \
	interval_count = interval_burst; \
      }
#else
#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); \
	} \
        HIST_timestamp(&intvl_wait_start); \
	if (sigsuspend(&signal_set) == EFAULT) { \
	  fprintf(where, \
		  "%s: fault with sigsuspend.\n", \
                  __FUNCTION__); \
	  fflush(where); \
	  exit(1); \
	} \
        HIST_timestamp(&intvl_two); \
        interval_wait_microseconds += \
          delta_micro(&intvl_wait_start,&intvl_two); \
	interval_count = interval_burst; \
      }
#endif /* WIN32 */
#else

#define INTERVALS_INIT() \
      if (interval_burst) { \
	HIST_timestamp(intvl_one_ptr); \
      } \
      interval_wait_microseconds = 0; \
      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)) { \
	/* spin 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_wait_start); \
        do { \
          HIST_timestamp(intvl_two_ptr); } \
        while(delta_micro(intvl_one_ptr,intvl_two_ptr) < interval_usecs); \
        interval_wait_microseconds += \
          delta_micro(&intvl_wait_start,&intvl_two); \
	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

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

/* a boatload of globals while I settle things out */
char *output_selection_spec = 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;

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 dont_give_up = 0;
int use_fastopen = 0;
int use_write = 0;
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 was_legacy = 0;
int legacy = 0;
int implicit_direction = 0;
int explicit_data_address = 0;
int want_defer_accept = 0;

uint64_t      trans_completed = 0;
int64_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_service_demand_double;
double      remote_service_demand_double;
double      transaction_rate = 1.0;
double      rtt_latency = -1.0;
int32_t     transport_mss = -2;
int32_t     local_transport_retrans = -2;
int32_t     remote_transport_retrans = -2;
char        *deprecated_str = "Deprecated";
int         remote_interface_vendor = -2;
int         remote_interface_device = -2;
int         remote_interface_subvendor = -2;
int         remote_interface_subdevice = -2;
int         local_interface_vendor = -2;
int         local_interface_device = -2;
int         local_interface_subvendor = -2;
int         local_interface_subdevice = -2;
int         local_cpu_frequency = 0;
int         remote_cpu_frequency = 0;

int         local_security_type_id;
int         local_security_enabled_num;
int         remote_security_type_id;
int         remote_security_enabled_num;

char        local_cong_control[16] = "";
char        remote_cong_control[16] = "";
char        local_cong_control_req[16] = "";
char        remote_cong_control_req[16] = "";

int         receive_timeout = -1;

/* new statistics based on code diffs from Google, with raj's own
   personal twist added to make them compatible with the omni
   tests... 20100913 */

/* min and max "latency" */
int         min_latency = -1, max_latency = -1;
/* the percentiles */
int         p50_latency = -1, p90_latency = -1, p99_latency = -1;
/* mean and stddev - while the mean is reduntant with the *_RR test we
   keep it because it won't be for other tests */
double      mean_latency = -1.0, stddev_latency = -1.0;

/* default to zero to avoid randomizing */
int local_mask_len = 0;
int remote_mask_len = 0;

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;

int  parallel_connections = 1;

static int socket_debug = 0;

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

enum netperf_output_type {
  NETPERF_TYPE_UNKNOWN,
  NETPERF_TYPE_UINT32,
  NETPERF_TYPE_INT32,
  NETPERF_TYPE_UINT64,
  NETPERF_TYPE_INT64,
  NETPERF_TYPE_CHAR,
  NETPERF_TYPE_FLOAT,
  NETPERF_TYPE_DOUBLE,
};

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

enum netperf_output_name {
  NETPERF_OUTPUT_UNKNOWN,
  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_PERCENT_USER,
  LOCAL_CPU_PERCENT_SYSTEM,
  LOCAL_CPU_PERCENT_IOWAIT,
  LOCAL_CPU_PERCENT_IRQ,
  LOCAL_CPU_PERCENT_SWINTR,
  LOCAL_CPU_METHOD,
  LOCAL_SD,
  REMOTE_CPU_UTIL,
  REMOTE_CPU_PERCENT_USER,
  REMOTE_CPU_PERCENT_SYSTEM,
  REMOTE_CPU_PERCENT_IOWAIT,
  REMOTE_CPU_PERCENT_IRQ,
  REMOTE_CPU_PERCENT_SWINTR,
  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,
  LOCAL_TRANSPORT_RETRANS,
  REMOTE_TRANSPORT_RETRANS,
  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,
  MIN_LATENCY,
  MAX_LATENCY,
  P50_LATENCY,
  P90_LATENCY,
  P99_LATENCY,
  MEAN_LATENCY,
  STDDEV_LATENCY,
  LOCAL_SOCKET_PRIO,
  REMOTE_SOCKET_PRIO,
  LOCAL_SOCKET_TOS,
  REMOTE_SOCKET_TOS,
  LOCAL_CONG_CONTROL,
  REMOTE_CONG_CONTROL,
  LOCAL_FILL_FILE,
  REMOTE_FILL_FILE,
  COMMAND_LINE,    /* COMMAND_LINE should always be "last" */
  OUTPUT_END,
  NETPERF_OUTPUT_MAX
};

/* flags for the output groups, lower 16 bits for remote, upper 16
   bits for local */

#define OMNI_WANT_REM_IFNAME  0X00000001
#define OMNI_WANT_LOC_IFNAME  0X00010000
#define OMNI_WANT_REM_IFSLOT  0X00000002
#define OMNI_WANT_LOC_IFSLOT  0X00020000
#define OMNI_WANT_REM_IFIDS   0X00000004
#define OMNI_WANT_LOC_IFIDS   0X00040000
#define OMNI_WANT_REM_DRVINFO 0X00000008
#define OMNI_WANT_LOC_DRVINFO 0X00080000
#define OMNI_WANT_STATS       0X00100010
#define OMNI_WANT_REM_CONG    0X00000020
#define OMNI_WANT_LOC_CONG    0X00200000

unsigned int desired_output_groups = 0;

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 *format;        /* format to apply to value */
  void *display_value; /* where to find the value */
  enum netperf_output_type output_type; /* what type is the value? */
  int  output_default; /* is it included in the default output */
  unsigned int output_group; /* used to avoid some lookups */
} netperf_output_elt_t;

netperf_output_elt_t netperf_output_source[NETPERF_OUTPUT_MAX];

#define NETPERF_MAX_BLOCKS 4

/* let us simply use one, two-dimensional list, and either use or some
   of the additional dimension depending on the type of output we are
   doing.  this should help simplify matters. raj 20110120 */

enum netperf_output_name output_list[NETPERF_MAX_BLOCKS][NETPERF_OUTPUT_MAX];

/* some things for setting the source IP address on outgoing UDP
   sends. borrows liberally from
   http://stackoverflow.com/questions/3062205/setting-the-source-ip-for-a-udp-socket */

int want_use_pktinfo = 0;
int use_pktinfo = 0;
int have_pktinfo = 0;
#ifdef IP_PKTINFO
struct in_pktinfo in_pktinfo;
#endif

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 if (connection_test) {
    return "Connect|Send|Recv";
  }
  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);
  }
}

/* does this need to become conditional on the presence of the macros
   or might we ass-u-me that we will not be compiled on something so
   old as to not have what we use? raj 20090803 */
static int
is_multicast_addr(struct addrinfo *res) {
  switch(res->ai_family) {
  case AF_INET: {
    /* IPv4 multicast runs from 224.0.0.0 to 239.255.255.255 or
       0xE0000000 to 0xEFFFFFFF. Thankfully though there are macros
       available to make the checks for one */
    struct in_addr bar = ((struct sockaddr_in *)res->ai_addr)->sin_addr;
    /* and here I thought IN_MULTICAST would operate on things in
       network byte order???  raj 20100315 */
    return IN_MULTICAST(ntohl(bar.s_addr));
  }
#if defined(AF_INET6)
  case AF_INET6: {
    struct in6_addr *bar = &(((struct sockaddr_in6 *)res->ai_addr)->sin6_addr);
    return IN6_IS_ADDR_MULTICAST(bar);
  }
#endif
  default:
    fprintf(where,
	    "Unexpected Address Family for Multicast Check %u\n",
	    res->ai_family);
    fflush(where);
    return 0;  /* or should we exit? */
  }
}

static void
set_multicast_ttl(SOCKET sock) {
  int optlen = sizeof(int);

  /* now set/get the TTL */
  if (multicast_ttl >= 0) {
    if (setsockopt(sock,
		   IPPROTO_IP,
#if defined(IP_MULTICAST_TTL)
		   IP_MULTICAST_TTL,
#else
		   IP_TTL,
#endif
		   (const char *)&multicast_ttl,
		   sizeof(multicast_ttl)) == SOCKET_ERROR) {
      fprintf(where,
	      "setsockopt(IP_TTL) failed errno %d\n",
	      errno);
    }
  }
  if (getsockopt(sock,
		 IPPROTO_IP,
		 IP_TTL,
		 (char *)&multicast_ttl,
		 (netperf_socklen_t *)&optlen) < 0) {
    fprintf(where,
	    "getsockopt(IP_TTL) failed errno %d\n",
	    errno);
    multicast_ttl = -2;
  }
}

/* we presume we are only called with something which is actually a
   multicast address. raj 20100315 */
static void
join_multicast_addr(SOCKET sock, struct addrinfo *res) {
  switch(res->ai_family) {
  case AF_INET: {
    struct ip_mreq mreq;
    struct in_addr bar = ((struct sockaddr_in *)res->ai_addr)->sin_addr;
    int optlen = sizeof(int);
    int one    = 1;

    mreq.imr_multiaddr.s_addr=bar.s_addr;
    mreq.imr_interface.s_addr=htonl(INADDR_ANY);
    if (setsockopt(sock,
		   IPPROTO_IP,
		   IP_ADD_MEMBERSHIP,
		   (const char *)&mreq,
		   sizeof(mreq)) == 0) {

      /* let others do the same */
      if (setsockopt(sock,
		     SOL_SOCKET,
		     SO_REUSEADDR,
		     (const char *)&one,
		     sizeof(one)) == SOCKET_ERROR) {
	if (debug) {
	  fprintf(where,
		  "join_multicast_addr SO_REUSADDR failed errno %d\n",
		  errno);
	  fflush(where);
	}
      }

      /* now set/get the TTL */
      if (multicast_ttl >= 0) {
	if (setsockopt(sock,
		       IPPROTO_IP,
		       IP_TTL,
		       (const char *)&multicast_ttl,
		       sizeof(multicast_ttl)) == SOCKET_ERROR) {
	  fprintf(where,
		  "setsockopt(IP_TTL) failed errno %d\n",
		  errno);
	}
      }
      if (getsockopt(sock,
		     IPPROTO_IP,
		     IP_TTL,
		     (char *)&multicast_ttl,
		     (netperf_socklen_t *)&optlen) == SOCKET_ERROR) {
	fprintf(where,
		"getsockopt(IP_TTL) failed errno %d\n",
		errno);
	multicast_ttl = -2;
      }
    }
    else {
      if (debug) {
	fprintf(where,
		"setsockopt(IP_ADD_MEMBERSHIP) failed errno %d\n",
		errno);
	fflush(where);
      }
    }
    break;
  }
  case AF_INET6: {
    fprintf(where,"I do not know how to join an IPv6 multicast group\n");
    break;
  }

  }
  return;
}

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 = (unsigned short)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 = (unsigned short)client_port_min;
  }

  /* set up the data socket */
  set_port_number(local_res, (unsigned short)myport);
}

/* at some point this should become a table lookup... raj 20090813 */
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 LOCAL_TRANSPORT_RETRANS:
    return "LOCAL_TRANSPORT_RETRANS";
  case REMOTE_TRANSPORT_RETRANS:
    return "REMOTE_TRANSPORT_RETRANS";
  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_PERCENT_USER:
    return "LOCAL_CPU_PERCENT_USER";
  case   LOCAL_CPU_PERCENT_SYSTEM:
    return "LOCAL_CPU_PERCENT_SYSTEM";
  case   LOCAL_CPU_PERCENT_IOWAIT:
    return "LOCAL_CPU_PERCENT_IOWAIT";
  case   LOCAL_CPU_PERCENT_IRQ:
    return "LOCAL_CPU_PERCENT_IRQ";
  case   LOCAL_CPU_PERCENT_SWINTR:
    return "LOCAL_CPU_PERCENT_SWINTR";
  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_PERCENT_USER:
    return "REMOTE_CPU_PERCENT_USER";
  case   REMOTE_CPU_PERCENT_SYSTEM:
    return "REMOTE_CPU_PERCENT_SYSTEM";
  case   REMOTE_CPU_PERCENT_IOWAIT:
    return "REMOTE_CPU_PERCENT_IOWAIT";
  case   REMOTE_CPU_PERCENT_IRQ:
    return "REMOTE_CPU_PERCENT_IRQ";
  case   REMOTE_CPU_PERCENT_SWINTR:
    return "REMOTE_CPU_PERCENT_SWINTR";
  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 MIN_LATENCY:
    return "MIN_LATENCY";
  case MAX_LATENCY:
    return "MAX_LATENCY";
  case P50_LATENCY:
    return "P50_LATENCY";
  case P90_LATENCY:
    return "P90_LATENCY";
  case P99_LATENCY:
    return "P99_LATENCY";
  case MEAN_LATENCY:
    return "MEAN_LATENCY";
  case STDDEV_LATENCY:
    return "STDDEV_LATENCY";
  case LOCAL_SOCKET_PRIO:
    return "LOCAL_SOCKET_PRIO";
  case REMOTE_SOCKET_PRIO:
    return "REMOTE_SOCKET_PRIO";
  case LOCAL_SOCKET_TOS:
    return "LOCAL_SOCKET_TOS";
  case REMOTE_SOCKET_TOS:
    return "REMOTE_SOCKET_TOS";
  case LOCAL_CONG_CONTROL:
    return "LOCAL_CONG_CONTROL";
  case REMOTE_CONG_CONTROL:
    return "REMOTE_CONG_CONTROL";
  case LOCAL_FILL_FILE:
    return "LOCAL_FILL_FILE";
  case REMOTE_FILL_FILE:
    return "REMOTE_FILL_FILE";
  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 i,j;

  for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
    fprintf(where,"Output Block %d\n",i + 1);
    for (j = 0; j < NETPERF_OUTPUT_MAX; j++) {
      fprintf(where,"%s ",netperf_output_enum_to_str(output_list[i][j]));
    }
    fprintf(where,"\n");
  }
  fflush(where);
}

void
dump_netperf_output_choices(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"
	    "\tmax_line_len %d tot_line_len %d display_value %p\n"
	    "\tline[0]: |%s|\n"
	    "\tline[1]: |%s|\n"
	    "\tline[2]: |%s|\n"
	    "\tline[3]: |%s|\n"
	    "\tformat: |%s|\n",
	    netperf_output_enum_to_str(netperf_output_source[i].output_name),
	    netperf_output_source[i].max_line_len,
	    netperf_output_source[i].tot_line_len,
	    netperf_output_source[i].display_value,
	    (netperf_output_source[i].line[0] == NULL) ? "" :
	    netperf_output_source[i].line[0],
	    (netperf_output_source[i].line[1] == NULL) ? "" :
	    netperf_output_source[i].line[1],
	    (netperf_output_source[i].line[2] == NULL) ? "" :
	    netperf_output_source[i].line[2],
	    (netperf_output_source[i].line[3] == NULL) ? "" :
	    netperf_output_source[i].line[3],
	    (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_mnenomic(char *candidate) {

  enum netperf_output_name name;
  for (name = OUTPUT_NONE; name < NETPERF_OUTPUT_MAX; name++) {
    if(!strcasecmp(candidate,netperf_output_enum_to_str(name)))
      return name;
  }
  return NETPERF_OUTPUT_UNKNOWN;
}

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
set_output_list_all() {

  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_list[i][j++] = k;
    desired_output_groups |= netperf_output_source[k].output_group;
  }

  /* Line Two LOCAL_CPU_UTIL to TRANSPORT_MSS */
  i = 1;
  j = 0;
  for (k = LOCAL_CPU_UTIL; k <= TRANSPORT_MSS; k++) {
    output_list[i][j++] = k;
    desired_output_groups |= netperf_output_source[k].output_group;
  }

  /* Line Three LOCAL_SEND_THROUGHPUT throught REMOTE_CORK */
  i = 2;
  j = 0;
  for (k = LOCAL_SEND_THROUGHPUT; k <= REMOTE_CORK; k++) {
    output_list[i][j++] = k;
    desired_output_groups |= netperf_output_source[k].output_group;
  }

  /* Line Four LOCAL_SYSNAME through COMMAND_LINE */
  i = 3;
  j = 0;
  for (k = LOCAL_SYSNAME; k <= COMMAND_LINE; k++) {
    output_list[i][j++] = k;
    desired_output_groups |= netperf_output_source[k].output_group;
  }

}

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

  selections = fopen(selection_file,"r");
  if (!selections) {
    fprintf(where,
	    "Could not open output selection file '%s' errno %d\n",
	    selection_file,
	    errno);
    fflush(where);
    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_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_list[line++][j++] = match_string_to_output(name);
      namepos = 0;
      j = 0;
    }
    else if (isprint(c)) {
      name[namepos++] = (char)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_list[line][j] =   match_string_to_output(name);
  }

}

void
parse_output_selection_line(int line, char *list) {

  char *token;
  int j;
  enum netperf_output_name name;

  /* belt and suspenders */
  if (line < 0) {
    fprintf(where,
	    "parse_output_selection_line called with negative line number %d\n",line);
    fflush(where);
    exit(-1);
  }

  /* silently ignore extra lines and only warn if debug is set */
  if (line >= NETPERF_MAX_BLOCKS) {
    if (debug) {
      fprintf(where,
	      "There can be no more than %d output selection lines."
	      " Ignoring output selection line %d |%s|\n",
	      NETPERF_MAX_BLOCKS,
	      line + 1,
	      list);
      fflush(where);
    }
    return;
  }


  j=0;
  token = strtok(list," ,");
  while ((token) && (j < NETPERF_OUTPUT_MAX)) {

    name = match_string_to_output_mnenomic(token);

    if ((name == NETPERF_OUTPUT_UNKNOWN) && (debug)) {
      fprintf(where,"Ignoring unknown output selector %d |%s| on line %d\n",
	      j + 1,
	      token,
	      line +1);
      fflush(where);
    }
    else {
      output_list[line][j] = name;
      desired_output_groups |= netperf_output_source[name].output_group;
      j++;
    }

    token = strtok(NULL," ,");
  }
  if ((token) && (debug)) {
    fprintf(where,
	    "There can be no more than %d output selectors per line. "
	    "Ignoring remaining selectors on line %d\n",
	    NETPERF_OUTPUT_MAX,line +1);
    fflush(where);
  }
}

void
parse_output_selection_direct(char *output_selection) {

  char *source,*line,*remainder,*temp;
  char *f1, *f2, *f3;
  int i,len,done;

  len = strlen(output_selection);

  source = strdup(output_selection);
  line = (char *) malloc(len+1);
  remainder = (char *) malloc(len+1);

  if ((NULL == source) ||
      (NULL == line) ||
      (NULL == remainder)) {
    fprintf(where,"Unable to malloc memory for output selection parsing\n");
    fflush(where);
    exit(-1);
  }

  f1 = source;
  f2 = line;
  f3 = remainder;

  i = 0;
  done = 0;
  do {
    break_args_explicit_sep(source,';',line,remainder);
    if (line[0]) {
      parse_output_selection_line(i,line);
    }
    if (remainder[0]) {
      temp = source;
      source = remainder;
      remainder = temp;
      i++;
      /*
      if (i == NETPERF_MAX_BLOCKS) {
	fprintf(where,
		"Too many output blocks requested, maximum is %d\n",
		NETPERF_MAX_BLOCKS);
	fflush(where);
	exit(-1);
      }
      */
      continue;
    }
    else {
      done = 1;
    }
  } while (!done);

  free(f1);
  free(f2);
  free(f3);

}

/* building blocks for output selection */
#define NETPERF_TPUT "ELAPSED_TIME,THROUGHPUT,THROUGHPUT_UNITS"
#define NETPERF_OUTPUT_STREAM "LSS_SIZE_END,RSR_SIZE_END,LOCAL_SEND_SIZE"
#define NETPERF_OUTPUT_MAERTS "RSS_SIZE_END,LSR_SIZE_END,REMOTE_SEND_SIZE"
#define NETPERF_CPU "LOCAL_CPU_UTIL,LOCAL_CPU_PERCENT_USER,LOCAL_CPU_PERCENT_SYSTEM,LOCAL_CPU_PERCENT_IOWAIT,LOCAL_CPU_PERCENT_IRQ,LOCAL_CPU_PERCENT_SWINTR,LOCAL_CPU_METHOD,REMOTE_CPU_UTIL,REMOTE_CPU_PERCENT_USER,REMOTE_CPU_PERCENT_SYSTEM,REMOTE_CPU_PERCENT_IOWAIT,REMOTE_CPU_PERCENT_IRQ,REMOTE_CPU_PERCENT_SWINTR,REMOTE_CPU_METHOD,LOCAL_SD,REMOTE_SD,SD_UNITS"
#define NETPERF_RR "LSS_SIZE_END,LSR_SIZE_END,RSR_SIZE_END,RSS_SIZE_END,REQUEST_SIZE,RESPONSE_SIZE"

void
set_output_list_by_test() {

  char *stream_no_cpu = NETPERF_OUTPUT_STREAM "," NETPERF_TPUT;
  char *stream_cpu = NETPERF_OUTPUT_STREAM "," NETPERF_TPUT "," NETPERF_CPU;
  char *maerts_no_cpu = NETPERF_OUTPUT_MAERTS "," NETPERF_TPUT;
  char *maerts_cpu =  NETPERF_OUTPUT_MAERTS "," NETPERF_TPUT "," NETPERF_CPU;
  char *rr_no_cpu = NETPERF_RR "," NETPERF_TPUT;
  char *rr_cpu = NETPERF_RR "," NETPERF_TPUT "," NETPERF_CPU;

  if (debug) {
    fprintf(where,"%s setting the output list by test\n",
	    __FUNCTION__);
    fflush(where);
  }

  if (NETPERF_XMIT_ONLY(direction)) {
    if (!(local_cpu_usage || remote_cpu_usage))
      parse_output_selection_direct(stream_no_cpu);
    else
      parse_output_selection_direct(stream_cpu);
  }
  else if (NETPERF_RECV_ONLY(direction)) {
    if (!(local_cpu_usage || remote_cpu_usage))
      parse_output_selection_direct(maerts_no_cpu);
    else
      parse_output_selection_direct(maerts_cpu);
  }
  else if (NETPERF_CC(direction)) {
    if (!(local_cpu_usage || remote_cpu_usage))
      parse_output_selection_direct(rr_no_cpu);
    else
      parse_output_selection_direct(rr_cpu);
  }
  else if (NETPERF_IS_RR(direction)) {
    if (!(local_cpu_usage || remote_cpu_usage))
      parse_output_selection_direct(rr_no_cpu);
    else
      parse_output_selection_direct(rr_cpu);
  }
  else {
    /* no idea */
    if (debug) {
      fprintf(where,"Cannot determine default test output, using mins\n");
      fflush(where);
    }
    parse_output_selection_direct(NETPERF_TPUT "," NETPERF_CPU);
  }
}

void
parse_output_selection(char *output_selection) {

  if (debug) {
    fprintf(where,"%s is parsing the output selection '%s'\n",
	    __FUNCTION__,
	    output_selection);
    fflush(where);
  }

  /* is it the magic keyword? */
  if (strcasecmp(output_selection,"all") == 0) {
    set_output_list_all();
  }
  /* do not forget the case when the output_selection is a single
     mnemonic without any separators... */
  else if (strchr(output_selection,',') ||
	   strchr(output_selection,';') ||
	   (match_string_to_output_mnenomic(output_selection) !=
	    NETPERF_OUTPUT_UNKNOWN)) {
    parse_output_selection_direct(output_selection);
  }
  else {
    parse_output_selection_file(output_selection);
  }
  if (debug > 2) {
    dump_netperf_output_list(stderr);
  }
  return;
}

static void
set_output_elt(enum netperf_output_name name,
	       char *line0, char *line1, char *line2, char *line3,
	       char *format,
	       void *value,
	       unsigned int out_default,
	       unsigned int group,
	       enum netperf_output_type type) {

  netperf_output_source[name].output_name = name;
  netperf_output_source[name].line[0] = line0;
  netperf_output_source[name].line[1] = line1;
  netperf_output_source[name].line[2] = line2;
  netperf_output_source[name].line[3] = line3;
  netperf_output_source[name].format = format;
  netperf_output_source[name].display_value = value;
  netperf_output_source[name].output_default = out_default;
  netperf_output_source[name].output_group = group;
  netperf_output_source[name].max_line_len = NETPERF_LINE_MAX(name);
  netperf_output_source[name].tot_line_len = NETPERF_LINE_TOT(name);
  netperf_output_source[name].output_type = type;
}

void
print_omni_init_list() {

  int i;

  if (debug) {
    fprintf(where,"%s called\n",
	    __FUNCTION__);
  }

  /* belts and suspenders everyone... */
  for (i = NETPERF_OUTPUT_UNKNOWN; 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].format = "";
    netperf_output_source[i].display_value = NULL;
    netperf_output_source[i].output_default = 1;
    netperf_output_source[i].output_group = 0;
    netperf_output_source[i].output_type = NETPERF_TYPE_UNKNOWN;
  }

  set_output_elt(OUTPUT_NONE, " ", "", "", "", "%s", &" ",1, 0,
		 NETPERF_TYPE_CHAR);

  set_output_elt(COMMAND_LINE, "Command","Line","","","\"%s\"",
		 command_line,1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(UUID, "Test", "UUID", "", "", "%s", test_uuid, 1, 0,
		 NETPERF_TYPE_CHAR);

  set_output_elt(RESULT_BRAND, "Result", "Tag", "", "", "\"%s\"",
		 result_brand, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(SOCKET_TYPE, "Socket", "Type", "", "", "%s",
		 socket_type_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(DIRECTION, "Direction", "", "", "", "%s",
		 direction_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(PROTOCOL, "Protocol", "", "", "", "%s",
		 protocol_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(ELAPSED_TIME, "Elapsed", "Time", "(sec)", "", "%.2f",
		 &elapsed_time_double, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(SOURCE_PORT, "Source", "Port", "", "", "%s",
		 local_data_port, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(SOURCE_ADDR, "Source", "Address", "", "", "%s",
		 local_data_address, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(SOURCE_FAMILY, "Source", "Family", "", "", "%d",
		 &local_data_family, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(DEST_PORT, "Destination", "Port", "", "", "%s",
		 remote_data_port, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(DEST_ADDR, "Destination", "Address", "", "", "%s",
		 remote_data_address, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(DEST_FAMILY, "Destination", "Family", "", "", "%d",
		 &remote_data_family, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(THROUGHPUT, "Throughput", "", "", "", "%.2f",
		 &thruput, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_SEND_THROUGHPUT, "Local", "Send", "Throughput", "",
		 "%.2f", &local_send_thruput, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_RECV_THROUGHPUT, "Local", "Recv", "Throughput", "",
		 "%.2f", &local_recv_thruput, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_SEND_THROUGHPUT, "Remote", "Send", "Throughput", "",
		 "%.2f", &remote_send_thruput, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_RECV_THROUGHPUT, "Remote", "Recv", "Throughput", "",
		 "%.2f", &remote_recv_thruput, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(THROUGHPUT_UNITS, "Throughput", "Units", "", "", "%s/s",
		 thruput_format_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(CONFIDENCE_LEVEL, "Confidence", "Level", "Percent", "", "%d",
		 &confidence_level, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(CONFIDENCE_INTERVAL, "Confidence", "Width", "Target", "",
		 "%f", &interval_pct, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(CONFIDENCE_ITERATION, "Confidence", "Iterations", "Run", "",
		 "%d", &confidence_iteration, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(THROUGHPUT_CONFID, "Throughput", "Confidence", "Width (%)",
		 "", "%.3f", &result_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_CPU_CONFID, "Local", "CPU", "Confidence", "Width (%)",
		 "%.3f", &loc_cpu_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_CPU_CONFID, "Remote", "CPU", "Confidence", "Width (%)",
		 "%.3f", &rem_cpu_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(RT_LATENCY, "Round", "Trip", "Latency", "usec/tran", "%.3f",
		 &rtt_latency, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(TRANSACTION_RATE, "Transaction", "Rate", "Tran/s", "", "%.3f",
		 &transaction_rate, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(TRANSPORT_MSS, "Transport", "MSS", "bytes", "", "%d",
		 &transport_mss, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_TRANSPORT_RETRANS, "Local", "Transport",
		 "Retransmissions", "", "%d", &local_transport_retrans, 1, 0,
		 NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_TRANSPORT_RETRANS, "Remote", "Transport",
		 "Retransmissions", "", "%d", &remote_transport_retrans, 1, 0,
		 NETPERF_TYPE_INT32);

  set_output_elt(REQUEST_SIZE, "Request", "Size", "Bytes", "", "%d",
		 &req_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RESPONSE_SIZE, "Response", "Size", "Bytes", "", "%d",
		 &rsp_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(BURST_SIZE, "Initial", "Burst", "Requests", "", "%d",
		 &first_burst_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSS_SIZE_REQ, "Local", "Send Socket", "Size", "Requested",
		 "%d", &lss_size_req, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSS_SIZE, "Local", "Send Socket", "Size", "Initial", "%d",
		 &lss_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSS_SIZE_END, "Local", "Send Socket", "Size", "Final", "%d",
		 &lss_size_end, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSR_SIZE_REQ, "Local", "Recv Socket", "Size", "Requested",
		 "%d", &lsr_size_req, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSR_SIZE, "Local", "Recv Socket", "Size", "Initial", "%d",
		 &lsr_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LSR_SIZE_END, "Local", "Recv Socket", "Size", "Final", "%d",
		 &lsr_size_end, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SEND_SIZE, "Local", "Send", "Size", "", "%d",
		 &send_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_SIZE, "Local", "Recv", "Size", "", "%d",
		 &recv_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SEND_CALLS, "Local", "Send", "Calls", "", "%"PRIu64,
		 &local_send_calls, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(LOCAL_RECV_CALLS, "Local", "Recv", "Calls", "", "%"PRIu64,
		 &local_receive_calls, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(LOCAL_BYTES_PER_RECV, "Local", "Bytes", "Per", "Recv", "%.2f",
		 &bytes_per_recv, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_BYTES_PER_SEND, "Local", "Bytes", "Per", "Send", "%.2f",
		 &bytes_per_send, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_BYTES_RECVD, "Local", "Bytes", "Received", "", "%"PRIu64,
		 &bytes_received, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(LOCAL_BYTES_SENT, "Local", "Bytes", "Sent", "", "%"PRIu64,
		 &bytes_sent, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(LOCAL_BYTES_XFERD, "Local", "Bytes", "Xferred", "", "%.0f",
		 &bytes_xferd, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_SEND_WIDTH, "Local", "Send", "Width", "", "%d",
		 &send_width, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_WIDTH, "Local", "Recv", "Width", "", "%d",
		 &recv_width, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SEND_OFFSET, "Local", "Send", "Offset", "", "%d",
		 &local_send_offset, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_OFFSET, "Local", "Recv", "Offset", "", "%d",
		 &local_recv_offset, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_ALIGN, "Local", "Recv", "Alignment", "", "%d",
		 &local_recv_align, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SEND_ALIGN, "Local", "Send", "Alignment", "", "%d",
		 &local_send_align, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SEND_DIRTY_COUNT, "Local", "Send", "Dirty", "Count",
		 "%d", &loc_dirty_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_DIRTY_COUNT, "Local", "Recv", "Dirty", "Count",
		 "%d", &loc_dirty_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_RECV_CLEAN_COUNT, "Local", "Recv", "Clean", "Count",
		 "%d", &loc_clean_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_CPU_UTIL, "Local", "CPU", "Util", "%", "%.2f",
		 &local_cpu_utilization, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PERCENT_USER, "Local", "CPU", "User", "%", "%.2f",
		 &lib_local_cpu_stats.cpu_user, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PERCENT_SYSTEM,
                 "Local", "CPU", "System", "%", "%.2f",
		 &lib_local_cpu_stats.cpu_system, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PERCENT_IOWAIT,
                 "Local", "CPU", "I/O", "%", "%.2f",
		 &lib_local_cpu_stats.cpu_iowait, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PERCENT_IRQ,
                 "Local", "CPU", "IRQ", "%", "%.2f",
		 &lib_local_cpu_stats.cpu_irq, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PERCENT_SWINTR,
                 "Local", "CPU", "swintr", "%", "%.2f",
		 &lib_local_cpu_stats.cpu_swintr, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PEAK_UTIL, "Local", "Peak", "Per CPU", "Util %",
		 "%.2f", &lib_local_cpu_stats.peak_cpu_util, 1, 0,
                 NETPERF_TYPE_FLOAT);

  set_output_elt(LOCAL_CPU_PEAK_ID, "Local", "Peak", "Per CPU", "ID", "%d",
		 &lib_local_cpu_stats.peak_cpu_id, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_CPU_BIND, "Local", "CPU", "Bind", "", "%d",
		 &local_proc_affinity, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SD, "Local", "Service", "Demand", "", "%.3f",
		 &local_service_demand_double, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(SD_UNITS, "Service", "Demand", "Units", "", "%s",
		 sd_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_CPU_METHOD, "Local", "CPU", "Util", "Method", "%c",
		 &local_cpu_method, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_CPU_COUNT, "Local", "CPU", "Count", "", "%d",
		 &lib_num_loc_cpus, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_NODELAY, "Local", "NODELAY", "", "", "%d",
		 &loc_nodelay, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_CORK, "Local", "Cork", "", "", "%d",
		 &loc_tcpcork, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSS_SIZE_REQ, "Remote", "Send Socket", "Size", "Requested",
		 "%d", &rss_size_req, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSS_SIZE, "Remote", "Send Socket", "Size", "Initial", "%d",
		 &rss_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSS_SIZE_END, "Remote", "Send Socket", "Size", "Final", "%d",
		 &rss_size_end, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSR_SIZE_REQ, "Remote", "Recv Socket", "Size", "Requested",
		 "%d", &rsr_size_req, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSR_SIZE, "Remote", "Recv Socket", "Size", "Initial", "%d",
		 &rsr_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(RSR_SIZE_END, "Remote", "Recv Socket", "Size", "Final", "%d",
		 &rsr_size_end, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SEND_SIZE, "Remote", "Send", "Size", "", "%d",
		 &remote_send_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_SIZE, "Remote", "Recv", "Size", "", "%d",
		 &remote_recv_size, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SEND_CALLS, "Remote", "Send", "Calls", "", "%"PRIu64,
		 &remote_send_calls, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(REMOTE_RECV_CALLS, "Remote", "Recv", "Calls", "", "%"PRIu64,
		 &remote_receive_calls, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(REMOTE_BYTES_PER_RECV, "Remote", "Bytes", "Per", "Recv",
		 "%.2f", &remote_bytes_per_recv, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_BYTES_PER_SEND, "Remote", "Bytes", "Per", "Send",
		 "%.2f", &remote_bytes_per_send, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_BYTES_RECVD, "Remote", "Bytes", "Received", "",
		 "%"PRIu64, &remote_bytes_received, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(REMOTE_BYTES_SENT, "Remote", "Bytes", "Sent", "", "%"PRIu64,
		 &remote_bytes_sent, 1, 0, NETPERF_TYPE_UINT64);

  set_output_elt(REMOTE_BYTES_XFERD, "Remote", "Bytes", "Xferred", "", "%.0f",
		 &remote_bytes_xferd, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_SEND_WIDTH, "Remote", "Send", "Width", "", "%d",
		 &remote_send_width, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_WIDTH, "Remote", "Recv", "Width", "", "%d",
		 &remote_recv_width, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SEND_OFFSET, "Remote", "Send", "Offset", "", "%d",
		 &remote_send_offset, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_OFFSET, "Remote", "Recv", "Offset", "", "%d",
		 &remote_recv_offset, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_ALIGN, "Remote", "Recv", "Alignment", "", "%d",
		 &remote_recv_align, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SEND_ALIGN, "Remote", "Send", "Alignment", "", "%d",
		 &remote_send_align, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SEND_DIRTY_COUNT, "Remote", "Send", "Dirty", "Count",
		 "%d", &rem_dirty_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_DIRTY_COUNT, "Remote", "Recv", "Dirty", "Count",
		 "%d", &rem_dirty_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_RECV_CLEAN_COUNT, "Remote", "Recv", "Clean", "Count",
		 "%d", &rem_clean_count, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_CPU_UTIL, "Remote", "CPU", "Util", "%", "%.2f",
		 &remote_cpu_utilization, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PERCENT_USER, "Remote", "CPU", "User", "%", "%.2f",
		 &lib_remote_cpu_stats.cpu_user, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PERCENT_SYSTEM,
                 "Remote", "CPU", "System", "%", "%.2f",
		 &lib_remote_cpu_stats.cpu_system, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PERCENT_IOWAIT,
                 "Remote", "CPU", "I/O", "%", "%.2f",
		 &lib_remote_cpu_stats.cpu_iowait, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PERCENT_IRQ,
                 "Remote", "CPU", "IRQ", "%", "%.2f",
		 &lib_remote_cpu_stats.cpu_irq, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PERCENT_SWINTR,
                 "Remote", "CPU", "swintr", "%", "%.2f",
		 &lib_remote_cpu_stats.cpu_swintr, 1, 0, NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PEAK_UTIL, "Remote", "Peak", "Per CPU", "Util %",
		 "%.2f", &lib_remote_cpu_stats.peak_cpu_util, 1, 0,
                 NETPERF_TYPE_FLOAT);

  set_output_elt(REMOTE_CPU_PEAK_ID, "Remote", "Peak", "Per CPU", "ID", "%d",
		 &lib_remote_cpu_stats.peak_cpu_id, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_CPU_BIND, "Remote", "CPU", "Bind", "", "%d",
		 &remote_proc_affinity, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SD, "Remote", "Service", "Demand", "", "%.3f",
		 &remote_service_demand_double, 1, 0, NETPERF_TYPE_DOUBLE);

  set_output_elt(REMOTE_CPU_METHOD, "Remote", "CPU", "Util", "Method", "%c",
		 &remote_cpu_method, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_CPU_COUNT, "Remote", "CPU", "Count", "", "%d",
		 &lib_num_rem_cpus, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_NODELAY, "Remote", "NODELAY", "", "", "%d",
		 &rem_nodelay, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_CORK, "Remote", "Cork", "", "", "%d",
		 &rem_tcpcork, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_DRIVER_NAME, "Local", "Driver", "Name", "", "%s",
		 deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_DRIVER_VERSION, "Local", "Driver", "Version", "", "%s",
		 deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_DRIVER_FIRMWARE, "Local", "Driver", "Firmware", "",
		 "%s", deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_DRIVER_BUS, "Local", "Driver", "Bus", "", "%s",
		 deprecated_str, 1, OMNI_WANT_LOC_DRVINFO, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_DRIVER_NAME, "Remote", "Driver", "Name", "", "%s",
		 deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_DRIVER_VERSION, "Remote", "Driver", "Version", "",
		 "%s", deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_DRIVER_FIRMWARE, "Remote", "Driver", "Firmware", "",
		 "%s", deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_DRIVER_BUS, "Remote", "Driver", "Bus", "", "%s",
		 deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_INTERFACE_SUBDEVICE, "Local", "Interface", "Subdevice",
		 "", "0x%.4x", &local_interface_subdevice, 1,
		 OMNI_WANT_LOC_IFIDS, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_INTERFACE_DEVICE, "Local", "Interface", "Device", "",
		 "0x%.4x", &local_interface_device, 1, OMNI_WANT_LOC_IFIDS,
		 NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_INTERFACE_SUBVENDOR, "Local", "Interface", "Subvendor",
		 "", "0x%.4x", &local_interface_subvendor, 1,
		 OMNI_WANT_LOC_IFIDS, NETPERF_TYPE_UINT32);

  set_output_elt(LOCAL_INTERFACE_VENDOR, "Local", "Interface", "Vendor", "",
		 "0x%.4x", &local_interface_vendor, 1, OMNI_WANT_LOC_IFIDS,
		 NETPERF_TYPE_UINT32);

  set_output_elt(REMOTE_INTERFACE_SUBDEVICE, "Remote", "Interface",
		 "Subdevice", "", "0x%.4x", &remote_interface_subdevice, 1,
		 OMNI_WANT_REM_IFIDS, NETPERF_TYPE_UINT32);

  set_output_elt(REMOTE_INTERFACE_DEVICE, "Remote", "Interface", "Device", "",
		 "0x%.4x", &remote_interface_device, 1, OMNI_WANT_REM_IFIDS,
		 NETPERF_TYPE_UINT32);

  set_output_elt(REMOTE_INTERFACE_SUBVENDOR, "Remote", "Interface",
		 "Subvendor", "", "0x%.4x", &remote_interface_subvendor, 1,
		 OMNI_WANT_REM_IFIDS, NETPERF_TYPE_UINT32);

  set_output_elt(REMOTE_INTERFACE_VENDOR, "Remote", "Interface", "Vendor", "",
		 "0x%.4x", &remote_interface_vendor, 1, OMNI_WANT_REM_IFIDS,
		 NETPERF_TYPE_UINT32);

  set_output_elt(LOCAL_INTERFACE_NAME, "Local", "Interface", "Name", "", "%s",
		 deprecated_str, 1, OMNI_WANT_LOC_IFNAME,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_INTERFACE_NAME, "Remote", "Interface", "Name", "",
		 "%s", deprecated_str, 1, OMNI_WANT_REM_IFNAME,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_INTERFACE_SLOT, "Local", "Interface", "Slot", "", "%s",
		 deprecated_str, 1, OMNI_WANT_LOC_IFSLOT,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_INTERFACE_SLOT,  "Remote",  "Interface",  "Slot",  "",
		 "%s",  deprecated_str, 1, OMNI_WANT_REM_IFSLOT,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_MACHINE, "Remote", "Machine", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_VERSION, "Remote", "Version", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_RELEASE, "Remote", "Release", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_SYSNAME, "Remote", "Sysname", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_MACHINE, "Local", "Machine", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_VERSION, "Local", "Version", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_RELEASE, "Local", "Release", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_SYSNAME, "Local", "Sysname", "", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_INTERVAL_USECS, "Remote", "Interval", "Usecs", "",
		 "%d", &remote_interval_usecs, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_INTERVAL_BURST, "Remote", "Interval", "Burst", "",
		 "%d", &remote_interval_burst, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SECURITY_ENABLED, "Local", "OS", "Security", "Enabled",
		 "%s", deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_SECURITY_TYPE, "Local", "OS", "Security", "Type", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_SECURITY_SPECIFIC, "Local", "OS", "Security",
		 "Specific", "%s", deprecated_str, 1, 0,
		 NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_SECURITY_ENABLED_NUM, "Local", "OS", "Security",
		 "Enabled Num", "%d", &local_security_enabled_num, 1, 0,
		 NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SECURITY_TYPE_ID, "Local", "OS", "Security", "Type ID",
		 "%d", &local_security_type_id, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SECURITY_ENABLED, "Remote", "OS", "Security",
		 "Enabled", "%s", deprecated_str, 1, 0,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_SECURITY_TYPE, "Remote", "OS", "Security", "Type",
		 "%s", deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_SECURITY_SPECIFIC, "Remote", "OS", "Security",
		 "Specific", "%s", deprecated_str, 1, 0,
		 NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_SECURITY_ENABLED_NUM, "Remote", "OS", "Security",
		 "Enabled", "%d", &remote_security_enabled_num, 1, 0,
		 NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SECURITY_TYPE_ID, "Remote", "OS", "Security", "Type",
		 "%d", &remote_security_type_id, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_INTERVAL_USECS, "Local", "Interval", "Usecs", "", "%d",
		 &interval_usecs, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_INTERVAL_BURST, "Local", "Interval", "Burst", "", "%d",
		 &interval_burst, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SYSTEM_MODEL, "Remote", "System", "Model", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_CPU_MODEL, "Remote", "CPU", "Model", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_CPU_FREQUENCY, "Remote", "CPU", "Frequency", "MHz",
		 "%d", &remote_cpu_frequency, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SYSTEM_MODEL, "Local", "System", "Model", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_CPU_MODEL, "Local", "CPU", "Model", "", "%s",
		 deprecated_str, 1, 0, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_CPU_FREQUENCY, "Local", "CPU", "Frequency", "MHz", "%d",
		 &local_cpu_frequency, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(MIN_LATENCY, "Minimum", "Latency", "Microseconds", "", "%d",
		 &min_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);

  set_output_elt(MAX_LATENCY, "Maximum", "Latency", "Microseconds", "", "%d",
		 &max_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);

  set_output_elt(P50_LATENCY, "50th", "Percentile", "Latency", "Microseconds",
		 "%d", &p50_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);

  set_output_elt(P90_LATENCY, "90th", "Percentile", "Latency", "Microseconds",
		 "%d", &p90_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);

  set_output_elt(P99_LATENCY, "99th", "Percentile", "Latency", "Microseconds",
		 "%d", &p99_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);

  set_output_elt(MEAN_LATENCY, "Mean", "Latency", "Microseconds", "", "%.2f",
		 &mean_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_DOUBLE);

  set_output_elt(STDDEV_LATENCY, "Stddev", "Latency", "Microseconds", "",
		 "%.2f", &stddev_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_DOUBLE);

  set_output_elt(LOCAL_SOCKET_PRIO, "Local", "Socket", "Priority", "", "%d",
		 &local_socket_prio, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SOCKET_PRIO, "Remote", "Socket", "Priority", "", "%d"
		 , &remote_socket_prio, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_SOCKET_TOS, "Local", "Socket", "TOS", "", "0x%.2x",
		 &local_socket_tos, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(REMOTE_SOCKET_TOS, "Remote", "Socket", "TOS", "", "0x%.2x",
		 &remote_socket_tos, 1, 0, NETPERF_TYPE_INT32);

  set_output_elt(LOCAL_CONG_CONTROL, "Local", "Congestion", "Control",
		 "Algorithm", "%s", local_cong_control, 0,
		 OMNI_WANT_LOC_CONG, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_CONG_CONTROL, "Remote", "Congestion", "Control",
		 "Algorithm", "%s", remote_cong_control, 0,
		 OMNI_WANT_REM_CONG, NETPERF_TYPE_CHAR);

  set_output_elt(LOCAL_FILL_FILE, "Local", "Fill", "File", "", "%s",
		 local_fill_file, 0, 0, NETPERF_TYPE_CHAR);

  set_output_elt(REMOTE_FILL_FILE, "Remote", "Fill", "File", "", "%s",
		 remote_fill_file, 0, 0, NETPERF_TYPE_CHAR);

  set_output_elt(OUTPUT_END, "This", "Is", "The", "End", "%s",
		 NULL, 0, 0, NETPERF_TYPE_CHAR);

}

void
print_omni_init() {

  int i,j;

  if (debug) {
    fprintf(where,"%s entered\n",
	    __FUNCTION__);
    fflush(where);
  }

  /* why is this before the if you ask? because some of the output
     specifiers are char * rather than char[] and when I wanted to
     start setting output_group flags I was needing to call
     print_omni_init() before the char * 's were malloced, which meant
     the netperf_output_source got NULL pointers.  there is
     undoubtedly a cleaner way to do all this. raj 20110629 */

  print_omni_init_list();

  if (printing_initialized) return;

  printing_initialized = 1;


  /* belts and suspenders */
  for (j = 0; j < NETPERF_MAX_BLOCKS; j++)
    for (i = 0; i < NETPERF_OUTPUT_MAX; i++)
      output_list[j][i] = OUTPUT_END;


  if (output_selection_spec) {
      parse_output_selection(output_selection_spec);
  }
  else {
      set_output_list_by_test();
  }

}

/* why? because one cannot simply pass a pointer to snprintf - well
   except when it is expecting one... */
int
my_snprintf(char *buffer, size_t size, netperf_output_elt_t *output_elt)
{
  switch (output_elt->output_type) {
  case NETPERF_TYPE_CHAR:
    return snprintf(buffer, size,
		    output_elt->format,
		    (char *)output_elt->display_value);
    break;
  case NETPERF_TYPE_INT32:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(int *)(output_elt->display_value));
    break;
  case NETPERF_TYPE_UINT32:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(unsigned int *)(output_elt->display_value));
    break;
  case NETPERF_TYPE_INT64:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(long long *)(output_elt->display_value));
    break;
  case NETPERF_TYPE_UINT64:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(unsigned long long *)(output_elt->display_value));
    break;
  case NETPERF_TYPE_FLOAT:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(float *)(output_elt->display_value));
    break;
  case NETPERF_TYPE_DOUBLE:
    return snprintf(buffer, size,
		    output_elt->format,
		    *(double *)(output_elt->display_value));
    break;
  default:
    fprintf(stderr,
	    "Unknown/unsupported output_elt output_type of %d\n",
	    output_elt->output_type);
    fflush(stderr);
    exit(-1);
  }
}

void
print_omni_csv()
{

  int i,j,k,buflen,vallen;

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

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

      if (vallen >
	  netperf_output_source[output_list[i][j]].tot_line_len)
	netperf_output_source[output_list[i][j]].tot_line_len = vallen;

      buflen +=
	netperf_output_source[output_list[i][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 */
  h1 = hdr1;
  v1 = val1;
  for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
    for (j = 0;
	 ((j < NETPERF_OUTPUT_MAX) &&
	  (output_list[i][j] != OUTPUT_END));
	 j++) {
      int len;
      len = 0;
      if (print_headers) {
	for (k = 0; ((k < 4) &&
		     (NULL !=
		      netperf_output_source[output_list[i][j]].line[k]) &&
		     (strcmp("",netperf_output_source[output_list[i][j]].line[k]))); k++) {

	  len = sprintf(h1,
			"%s",
			netperf_output_source[output_list[i][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_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_list[i][j]].display_value != NULL)) {
	/* tot_line_len is bogus here, but should be "OK" ? */
	len = my_snprintf(v1,
			  netperf_output_source[output_list[i][j]].tot_line_len,
			  &(netperf_output_source[output_list[i][j]]));

	/* 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_list[0][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 i,j;
  char tmpval[1024];
  int vallen;

  for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
    for (j = 0;
	 ((j < NETPERF_OUTPUT_MAX) &&
	  (output_list[i][j] != OUTPUT_END));
	 j++) {
      if ((netperf_output_source[output_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_list[i][j]].display_value != NULL)) {
	vallen =
	  my_snprintf(tmpval,
		      1024,
		      &(netperf_output_source[output_list[i][j]]));
	if (vallen == -1) {
	  snprintf(tmpval,
		   1024,
		   "my_snprintf failed with format %s\n",
		   netperf_output_source[output_list[i][j]].format);
	}
	fprintf(where,
		"%s=%s\n",netperf_output_enum_to_str(output_list[i][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_list[i][j] != OUTPUT_END));
	 j++) {
      if ((netperf_output_source[output_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_list[i][j]].display_value !=
	   NULL))
	/* need to count the \n */
	vallen = my_snprintf(tmpval,
			     1024,
			     &(netperf_output_source[output_list[i][j]])) + 1;
      else
	vallen = 0;

      if (vallen >
	  netperf_output_source[output_list[i][j]].max_line_len)
	netperf_output_source[output_list[i][j]].max_line_len = vallen;

      buflen +=
	netperf_output_source[output_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_list[i][j] != OUTPUT_END));
	 j++) {
      if (print_headers) {
	for (k = 0; k < 4; k++) {
	  memcpy(h[k],
		 netperf_output_source[output_list[i][j]].line[k],
		 strlen(netperf_output_source[output_list[i][j]].line[k]));
	}
      }
      if ((netperf_output_source[output_list[i][j]].format != NULL) &&
	  (netperf_output_source[output_list[i][j]].display_value != NULL)) {
	int len;
	len = my_snprintf(v1,
			  netperf_output_source[output_list[i][j]].max_line_len,
			  &(netperf_output_source[output_list[i][j]]));
	/* 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_list[i][j]].max_line_len + 1;
      }
      v1 += netperf_output_source[output_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_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);

  switch (netperf_output_mode) {
  case CSV:
    print_omni_csv();
    break;
  case KEYVAL:
    print_omni_keyword();
    break;
  case HUMAN:
    print_omni_human();
    break;
  default:
    fprintf(where,"Yo Rick! There is a bug in netperf_output_mode!\n");
    fflush(where);
    exit(-1);
  }

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

static
int send_pktinfo(SOCKET data_socket, char *buffer, int len, struct sockaddr *destination, int destlen) {
#ifdef IP_PKTINFO
  struct msghdr msg;
  struct iovec iovec[1];
  char msg_control[512];
  struct cmsghdr *cmsg;
  int cmsg_space = 0;

  iovec[0].iov_base = buffer;
  iovec[0].iov_len = len;
  msg.msg_name = destination;
  msg.msg_namelen = destlen;
  msg.msg_iov = iovec;
  msg.msg_iovlen = 1;
  msg.msg_control = msg_control;
  msg.msg_controllen = sizeof(msg_control);
  msg.msg_flags = 0;

  cmsg = CMSG_FIRSTHDR(&msg);
  if (have_pktinfo) {
    cmsg->cmsg_level = IPPROTO_IP;
    cmsg->cmsg_type = IP_PKTINFO;
    cmsg->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));
    *(struct in_pktinfo*)CMSG_DATA(cmsg) = in_pktinfo;
    cmsg_space += CMSG_SPACE(sizeof(in_pktinfo));
  }
  msg.msg_controllen = cmsg_space;
  return sendmsg(data_socket, &msg, 0);
#else
  return -1;
#endif /* IP_PKTINFO */
}


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

  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 > 2) {
    fprintf(where,
	    "%s sock %d, ring elt %p, bytes %d, dest %p, len %d\n",
	    __FUNCTION__,
	    data_socket,
	    send_ring,
	    bytes_to_send,
	    destination,
	    destlen);
    fflush(where);
  }

  if (destination) {
    if (have_pktinfo) {
      len = send_pktinfo(data_socket,
			 send_ring->buffer_ptr,
			 bytes_to_send,
			 destination,
			 destlen);
    }
    else {
      len = sendto(data_socket,
		   send_ring->buffer_ptr,
		   bytes_to_send,
#if defined(MSG_FASTOPEN)
		   (use_fastopen && protocol == IPPROTO_TCP) ? MSG_FASTOPEN : 0,
#else
		   0,
#endif
		   destination,
		   destlen);
    }
  }
  else {
    if (!use_write) {
      len = send(data_socket,
		 send_ring->buffer_ptr,
		 bytes_to_send,
		 0);
    }
    else {
#ifndef WIN32
      len = write(data_socket,
		  send_ring->buffer_ptr,
		  bytes_to_send);
#else
      fprintf(where,"I'm sorry Dave I cannot write() under Windows\n");
      fflush(where);
      return -3;
#endif
    }
  }
  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,"%s: data send error: %s (errno %d)\n",
	      __FUNCTION__, strerror(errno), errno);
      return -3;
    }
  }
  return len;
}

#if defined(__linux)
static int
recv_data_no_copy(SOCKET data_socket, struct ring_elt *recv_ring, uint32_t bytes_to_recv, struct sockaddr *source, netperf_socklen_t *sourcelen, uint32_t flags, uint32_t *num_receives) {

#ifndef SPLICE_F_MOVE
# define SPLICE_F_MOVE 0x01
#endif
#ifndef SPLICE_F_NONBLOCK
# define SPLICE_F_NONBLOCK 0x02
#endif

  static int pfd[2] = {-1, -1};
  static int fdnull = -1;


  char *temp_message_ptr;
  int bytes_left;
  int bytes_recvd;
  int my_recvs;
  int my_flags = SPLICE_F_MOVE | SPLICE_F_NONBLOCK; /* values
						       suggested by
						       Eric Dumazet */
  int ret;

  if (pfd[0] == -1) {
    if (pipe(pfd)) {
      fprintf(where,
	      "%s pipe call failed with errno %d '%s'\n",
	      __FUNCTION__,
	      errno,
	      strerror(errno));
      return -4;  /* this will cause recv_data to do things the
		     old-fashioned way for the test */
    }
    if ((fdnull = open("/dev/null",O_WRONLY)) == -1) {
      fprintf(where,
	      "%s open call failed with errno %d '%s'\n",
	      __FUNCTION__,
	      errno,
	      strerror(errno));
      return -4;
    }
  }    

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

  if (debug > 1) {
    fprintf(where,
	    "%s sock %d, ring elt %p, bytes %d, source %p, srclen %d, flags %x, num_recv %p\n",
	    __FUNCTION__,
	    data_socket,
	    recv_ring,
	    bytes_to_recv,
	    source,
	    (source != NULL) ? *sourcelen : -1,
	    flags,
	    num_receives);
    fflush(where);
  }
  do {

    bytes_recvd = splice(data_socket,
			 NULL,
			 pfd[1],
			 NULL,
			 bytes_left,
			 my_flags);
    
    
    if (bytes_recvd > 0) {
      /* per Eric Dumazet, we should just let this second splice call
	 move as many bytes as it can and not worry about how much.
	 this should make the call more robust when made on a system
	 under memory pressure */
      splice(pfd[0], NULL, fdnull, NULL, 1 << 30, my_flags);
      bytes_left -= bytes_recvd;
    }
    else {
      break;
    }
    my_recvs++; /* should the pair of splices count as one? */
  } 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;

}

#endif

static
int recv_pktinfo(SOCKET data_socket, char *message_ptr, int bytes_to_recv,  int my_flags, struct sockaddr *source, netperf_socklen_t *sourcelen) {

#ifdef IP_PKTINFO
  struct iovec  my_iovec;
  struct msghdr my_header;
  struct cmsghdr *cmsg;
  struct in_pktinfo *pktinfo;

  char control_buf[512];
  int onoff = 1;
  int ret;

  my_iovec.iov_base = message_ptr;
  my_iovec.iov_len = bytes_to_recv;

  my_header.msg_name = source;
  my_header.msg_namelen = *sourcelen;
  my_header.msg_iov = &my_iovec;
  my_header.msg_iovlen = 1;
  my_header.msg_control = control_buf;
  my_header.msg_controllen = sizeof(control_buf);

  /* not going to bother checking, if it doesn't work we are no
     worse-off than we were before. we are going to ignore IPv6 for
     the time being */
  setsockopt(data_socket, IPPROTO_IP, IP_PKTINFO, &onoff, sizeof(onoff));
  
  ret = recvmsg(data_socket, &my_header, 0);

  if (ret >= 0) {
    struct sockaddr_in me;
    struct sockaddr_in clear;
    netperf_socklen_t melen = sizeof(me);
    for (cmsg = CMSG_FIRSTHDR(&my_header);
	 cmsg != NULL;
	 cmsg = CMSG_NXTHDR(&my_header, cmsg)) {
      if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
	in_pktinfo = *(struct in_pktinfo *)CMSG_DATA(cmsg);
	have_pktinfo = 1;
      }
    }
  }

  onoff = 0;
  setsockopt(data_socket, IPPROTO_IP, IP_PKTINFO, &onoff, sizeof(onoff));

  return ret;
#else
  return -1;
#endif
}


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

  char *temp_message_ptr;
  int bytes_left;
  int bytes_recvd;
  int my_recvs;
  int my_flags = 0; /* will we one day want to set MSG_WAITALL? */

#if defined(__linux)
  int ret;
  if (loc_rcvavoid == 1) {
    ret = recv_data_no_copy(data_socket, recv_ring, bytes_to_recv, source, sourcelen, flags, num_receives);
    if (ret != -4)
      return ret;
    else
      loc_rcvavoid = 0;
  }
#endif

  /* 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,
	    "%s sock %d, ring elt %p, bytes %d, source %p, srclen %d, flags %x, num_recv %p\n",
	    __FUNCTION__,
	    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. */
      if (use_pktinfo) {
	bytes_recvd = recv_pktinfo(data_socket,
				   temp_message_ptr,
				   bytes_left,
				   my_flags,
				   source,
				   sourcelen);
	use_pktinfo = 0;
      }
      else {
	bytes_recvd = recvfrom(data_socket,
			       temp_message_ptr,
			       bytes_left,
			       my_flags,
			       source,
			       sourcelen);
      }
    }
    else {
      /* just call recv */
      bytes_recvd = recv(data_socket,
			 temp_message_ptr,
			 bytes_left,
			 my_flags);
    }
    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;
      }
    if (SOCKET_EAGAIN(bytes_recvd) ||
	SOCKET_EWOULDBLOCK(bytes_recvd)) {
      return -2;
    }
    /* 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 protocol)
{

  int ret;
  char buffer[4];

  if (debug) {
    fprintf(where,
	    "%s sock %d peer %p peerlen %d protocol %d\n",
	    __FUNCTION__,
	    data_socket,
	    peer,
	    peerlen,
	    protocol);
    fflush(where);
  }

  if (protocol == IPPROTO_UDP) {
    /* try to give the remote a signal. what this means if we ever
       wanted to actually send zero-length messages remains to be seen
       :)  */
    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,
	    "%s sock %d init %d do_close %d protocol %d\n",
	    __FUNCTION__,
	    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 */

  /* this needs to be revisited for the netperf receiving case when
     the test is terminated by a Ctrl-C.  raj 2012-01-24 */

  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. of course, we *may* never
       receive anything from the remote which means we probably really
       aught to have a select here but until we are once bitten we
       will remain twice bold. */
    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;
}

#ifdef HAVE_LINUX_TCP_H
static void
dump_tcp_info(struct tcp_info *tcp_info)
{

  fprintf(stderr,
	  "tcpi_rto %d tcpi_ato %d tcpi_pmtu %d tcpi_rcv_ssthresh %d\n"
	  "tcpi_rtt %d tcpi_rttvar %d tcpi_snd_ssthresh %d tpci_snd_cwnd %d\n"
	  "tcpi_reordering %d tcpi_total_retrans %d\n",
	  tcp_info->tcpi_rto,
	  tcp_info->tcpi_ato,
	  tcp_info->tcpi_pmtu,
	  tcp_info->tcpi_rcv_ssthresh,
	  tcp_info->tcpi_rtt,
	  tcp_info->tcpi_rttvar,
	  tcp_info->tcpi_snd_ssthresh,
	  tcp_info->tcpi_snd_cwnd,
	  tcp_info->tcpi_reordering,
	  tcp_info->tcpi_total_retrans);
  
  return;
}

#endif

static int
get_transport_retrans(SOCKET socket, int protocol) {

#ifdef HAVE_LINUX_TCP_H
  struct tcp_info tcp_info;

  int ret;
  netperf_socklen_t infosize;

  if (protocol != IPPROTO_TCP)
    return -1;

  infosize = sizeof(struct tcp_info);

  if ((ret = getsockopt(socket,protocol,TCP_INFO,&tcp_info,&infosize)) < 0) {
    if (debug) {
      fprintf(where,
	      "%s: getsockopt errno %d %s\n",
	      __FUNCTION__,
	      errno,
	      strerror(errno));
      fflush(where);
    }
    return -1;
  }
  else {

    /* we assume that if we have LINUX_TCP_H we also have getenv */
    if (debug > 1 || getenv("DUMP_TCP_INFO")) {
      dump_tcp_info(&tcp_info);
    }
    return tcp_info.tcpi_total_retrans;
  }


#else
  return -1;
#endif
}


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,
	    "%s: getsockopt: errno %d\n",
	    __FUNCTION__,
	    errno);
    fflush(where);
    *mss = -1;
  }

}

static void
get_transport_cong_control(SOCKET socket, int protocol, char cong_control[], int len)
{
#ifdef TCP_CONGESTION
  int my_len = len;
  if (protocol != IPPROTO_TCP) {
    strncpy(cong_control,"TCP Only",len);
  }
  else if (getsockopt(socket,
		      protocol, TCP_CONGESTION, cong_control, &my_len) ==
	   SOCKET_ERROR) {
    snprintf(cong_control,len,"%d errno",errno);
  }
#else
  strncpy(cong_control,"Unavailable",len);
#endif
  cong_control[len-1] = '\0';
}

static void
set_transport_cong_control(SOCKET socket, int protocol, char cong_control[], int len)
{
#ifdef TCP_CONGESTION
  if (protocol == IPPROTO_TCP) {
    /* if it fails, we'll pick that up via the subsequent "get" */
    setsockopt(socket, protocol, TCP_CONGESTION, cong_control, len);
  }
#endif
}

static void
set_receive_timeout(SOCKET sock, int timeout) 
{
#ifdef SO_RCVTIMEO
#ifndef WIN32
  struct timeval foo;

  foo.tv_sec = timeout;
  foo.tv_usec = 0;

  if (setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,&foo,sizeof(foo)) < 0) {
    if (debug) {
      fprintf(where,"Note - attempt to set a receive timeout on the data socket failed with errno %d (%s)\n",
	      errno,
	      strerror(errno));
      fflush(where);
    }
  }
#endif
#endif
}

static SOCKET
omni_create_data_socket(struct addrinfo *res)
{
  SOCKET temp_socket;

  temp_socket = create_data_socket(res);

  if (temp_socket != SOCKET_ERROR) {
    if (local_cong_control_req[0] != '\0') {
      set_transport_cong_control(temp_socket,
				 res->ai_protocol,
				 local_cong_control_req,
				 sizeof(local_cong_control_req));
    }

    if ((res->ai_protocol == IPPROTO_UDP) &&
	(receive_timeout != -1)) {
      set_receive_timeout(temp_socket, receive_timeout);
    }
      
    if (socket_debug) {
      int one = 1;
      setsockopt(temp_socket, 
		 SOL_SOCKET,
		 SO_DEBUG,
		 &one,
		 sizeof(one));
    }
  }
  return temp_socket;
}
/* choosing the default send size is a trifle more complicated than it
   used to be as we have to account for different protocol limits */

#define UDP_LENGTH_MAX (0xFFFF - 28)

static int
choose_send_size(int lss, int protocol) {

  int send_size;

  if (lss > 0) {
    send_size = lss_size;

    /* we will assume that everyone has IPPROTO_UDP and thus avoid an
       issue with Windows using an enum */
    if ((protocol == IPPROTO_UDP) && (send_size > UDP_LENGTH_MAX))
      send_size = UDP_LENGTH_MAX;

  }
  else {
    send_size = 4096;
  }
  return send_size;
}

/* 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);
}
#if defined(__linux)
/*
 * Linux has this odd behavior where if the socket buffers are larger
 * than a device's txqueuelen, the kernel will silently drop transmits
 * which would not fit into the tx queue, and not pass an ENOBUFS
 * error back to the application.  As a result, a UDP stream test can
 * report absurd transmit bandwidths (like 20Gb/s on a 1GbE NIC).
 * This behavior can be avoided if you request extended error
 * reporting on the socket.  This is done by setting the IP_RECVERR
 * socket option at the IP level.
 */
static void
enable_enobufs(int s)
{
  struct protoent *pr;
  int on = 1;
  
  if ((pr = getprotobyname("ip")) == NULL) {
    fprintf(where, "%s failed: getprotobyname\n",__FUNCTION__);
    fflush(where);
    return;
  }
  if (setsockopt(s, pr->p_proto, IP_RECVERR, (char *)&on, sizeof(on)) < 0) {
    fprintf(where, "%s failed: setsockopt (errno %d)\n",__FUNCTION__,errno);
    fflush(where);
    return;
  }
}
#endif

void
set_omni_request_flags(struct omni_request_struct *omni_request) {

      /* we have no else clauses here because we previously set flags
	 to zero above raj 20090803 */
      if (rem_nodelay)
	omni_request->flags |= OMNI_NO_DELAY;

      if (remote_use_sendfile)
	omni_request->flags |= OMNI_USE_SENDFILE;

      if (connection_test)
	omni_request->flags |= OMNI_CONNECT_TEST;

      if (remote_checksum_off)
	omni_request->flags |= OMNI_CHECKSUM_OFF;

      if (remote_cpu_usage)
	omni_request->flags |= OMNI_MEASURE_CPU;

      if (routing_allowed)
	omni_request->flags |= OMNI_ROUTING_ALLOWED;

      if (desired_output_groups & OMNI_WANT_REM_IFNAME)
	omni_request->flags |= OMNI_WANT_IFNAME;

      if (desired_output_groups & OMNI_WANT_REM_IFSLOT)
	omni_request->flags |= OMNI_WANT_IFSLOT;

      if (desired_output_groups & OMNI_WANT_REM_IFIDS)
	omni_request->flags |= OMNI_WANT_IFIDS;

      if (desired_output_groups & OMNI_WANT_REM_DRVINFO)
	omni_request->flags |= OMNI_WANT_DRVINFO;

      if (desired_output_groups & OMNI_WANT_REM_CONG)
	omni_request->flags |= OMNI_WANT_REM_CONG;

      if (use_fastopen)
	omni_request->flags |= OMNI_FASTOPEN;

      if (want_use_pktinfo)
	omni_request->flags |= OMNI_USE_PKTINFO;

      if (want_defer_accept)
	omni_request->flags |= OMNI_WANT_DEFER_ACCEPT;

}


/* 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. raj 2008-01-07 */

void
send_omni_inner(char remote_host[], unsigned int legacy_caller, char header_str[])
{

  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);
  netperf_socklen_t       my_addr_len = sizeof(my_addr);

  SOCKET	data_socket;
  int           need_socket;

  uint32_t   temp_recvs;
  char  tmpfmt;

  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
  int requests_outstanding = 0;
#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;


  if (keep_histogram) {
    if (first_burst_size > 0)
      time_hist = HIST_new_n(first_burst_size + 1);
    else
      time_hist = HIST_new_n(1);
  }

  /* 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(header_str,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;

    /* since we are tracking the number of outstanding requests for
       timestamping purposes, and since the previous iteration of
       using confidence intervals may not have completed all of them,
       we now need to forget about them or we will mistakenly fill our
       tracking array. raj 2011-03-14 */
    if (keep_histogram) {
      HIST_purge(time_hist);
    }

#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;
#endif

    /* if the command-line included requests to randomize the IP
       addresses, then honor it.  of course, this may not work all that
       well for some tests... raj 20101129 */
    if (local_mask_len)
      random_ip_address(local_res, local_mask_len);
    if (remote_mask_len)
      random_ip_address(remote_res, remote_mask_len);

    data_socket = omni_create_data_socket(local_res);

    if (data_socket == INVALID_SOCKET) {
      perror("netperf: send_omni: unable to create data socket");
      exit(1);
    }
#if defined(__linux)
    /* we really only need this for a UDP_STREAM test. we particularly
       do not want it for a CC or CRR test. raj 2012-08-06 */
    if ((protocol == IPPROTO_UDP) &&
	NETPERF_XMIT_ONLY(direction)) {
      enable_enobufs(data_socket);
    }
#endif
    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) {
      if (is_multicast_addr(remote_res)) {
	set_multicast_ttl(data_socket);
      }

      if (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) {
	    send_size = choose_send_size(lss_size,protocol);
	  }
	  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,
		  "%s: %d entry send_ring obtained...\n",
		  __FUNCTION__,
		  send_width);
	}
      }
    }

    if (direction & NETPERF_RECV) {
      /* do we need to join a multicast group? */
      if (is_multicast_addr(local_res)) {
	join_multicast_addr(data_socket, local_res);
      }

      /* do we need to allocate a recv_ring? */
      if (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,
		  "%s: %d entry recv_ring obtained...\n",
		  __FUNCTION__,
		  recv_width);
	}
      }
    }

    if (!no_control) {

      /* 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->flags                  = 0;
      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             = send_width;
      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             = recv_width;
      omni_request->response_size	   = rsp_size;
      omni_request->socket_prio            = remote_socket_prio;
      omni_request->socket_tos             = remote_socket_tos;

      set_omni_request_flags(omni_request);

      /* perhaps this should be made conditional on
	 remote_cong_control_req[0] not being NULL? */
      strncpy(omni_request->cong_control,
	      remote_cong_control_req,
	      sizeof(omni_request->cong_control));
      omni_request->cong_control[sizeof(omni_request->cong_control) - 1] =
	'\0';

      if (want_keepalive)
	omni_request->flags |= OMNI_WANT_KEEPALIVE;

      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->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->netperf_ip,
					  &(omni_request->netperf_port));
      ret = get_sockaddr_family_addr_port((struct sockaddr_storage *)remote_res->ai_addr,
					  nf_to_af(omni_request->ipfamily),
					  omni_request->netserver_ip,
					  &(omni_request->data_port));
      /* if the user didn't explicitly set the remote data address we
	 don't want to pass along the one we picked implicitly, or a
	 netserver sitting behind a (BLETCH) NAT will be asked to try
	 to bind to the "public" IP. */
      if (!explicit_data_address) {
	omni_request->netserver_ip[0] = 0;
	omni_request->netserver_ip[1] = 0;
	omni_request->netserver_ip[2] = 0;
	omni_request->netserver_ip[3] = 0;
      }
      if (debug > 1) {
	fprintf(where,"netperf: %s: requesting OMNI test\n",__FUNCTION__);
      }

      strncpy(omni_request->fill_file,
	      remote_fill_file,
	      sizeof(omni_request->fill_file));

      send_request_n(OMNI_REQUEST_CONV_CUTOFF);


      /* 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->flags & OMNI_NO_DELAY;
	remote_use_sendfile = omni_response->flags & OMNI_USE_SENDFILE;
	remote_cpu_usage    = omni_response->flags & OMNI_MEASURE_CPU;
	remote_cpu_rate     = omni_response->cpu_rate;
	remote_send_width   = omni_response->send_width;
	remote_recv_width   = omni_response->recv_width;
	remote_socket_prio  = omni_response->socket_prio;
	remote_socket_tos   = omni_response->socket_tos;

	/* 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);
	}
      }
      else {
	Set_errno(netperf_response.content.serv_errno);
	fprintf(where,
		"netperf: remote error %d",
		netperf_response.content.serv_errno);
	perror("");
	fflush(where);
	exit(-1);
      }

    }

#ifdef WANT_DEMO
    /* 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) || local_connected;

    /* possibly wait just a moment before actually starting - used
       mainly when one is doing many many many concurrent netperf
       tests */
    WAIT_BEFORE_DATA_TRAFFIC();

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

    /* enable a test_time of 0 to mean just keep running until
       something other than alarm() generates a signal. raj
       2012-02-01 */
    if ((test_time) || ((test_trans == 0) && (test_bytes == 0))) {
      /* 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)) &&
	  ((test_trans == 0) && (test_bytes == 0)))
	    pad_time = 0;
      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) {
      demo_first_timestamp();
    }
#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)) {

      /* we need to be careful about when we snap a timestamp
	 depending on the test parameters. this one *should* cover
	 everything but the burst request/response test - famous last
	 words of course. raj 20110111 */

      if (keep_histogram) {
	HIST_timestamp_start(time_hist);
      }


    again:

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

	data_socket = omni_create_data_socket(local_res);

	if (data_socket == INVALID_SOCKET) {
	  perror("netperf: send_omni: unable to create data socket");
	  exit(1);
	}
	need_socket = 0;
#if defined(__linux)
	if ((protocol == IPPROTO_UDP) &&
	    (direction & NETPERF_XMIT)) {
	  enable_enobufs(data_socket);
	}
#endif
      }

      /* only connect if and when we need to */
      if (need_to_connect && !use_fastopen) {
	/* assign to data_socket since connect_data_socket returns
	   SOCKET and not int thanks to Windows. */
	ret = connect_data_socket(data_socket,remote_res,dont_give_up);
	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 */
	  if (debug) {
	    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);
	  /* yes Virginia, a goto.  perhaps one day we will rewrite
	     the code to avoid it but for now, a goto... raj */
	  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
      /* Long ago and far away, on just about any *nix, one could
	 avoid having multiple requests bundled into the same TCP
	 segment simply by setting TCP_NODELAY and perhaps not trying
	 to have more outstanding at one time than our guesstimate as
	 to the TCP congestion window.  In that way one could use a
	 burst mode TCP_RR test as part of trying to measure maximum
	 packets per second (PPS) on a system or through a NIC (well,
	 assuming there weren't many retransmissions anyway) These
	 days with Linux the dominant *nix and with it having made it
	 virtually impossible to do any longer, it is no longer worth
	 it to try the application-layer backflips.  So, I am removing
	 them.  At some point we'll simply have to enhance this code
	 to deal with multiple connections at one time, each with just
	 the one transaction in flight for our PPS testing.  Multiple
	 netperfs, each with one connection and one transaction in
	 flight rapidly becomes a context-switching benchmark rather
	 than "networking".  raj 2015-04-20 */

      while ((first_burst_size > 0) &&
	     (requests_outstanding < first_burst_size) &&
	     (NETPERF_IS_RR(direction)) &&
	     (!connection_test)) {
	if (debug > 1) {
	  fprintf(where,
		  "injecting, req_outstanding %d burst %d\n",
		  requests_outstanding,
		  first_burst_size);
	}

	if ((ret = send_data(data_socket,
			     send_ring,
			     bytes_to_send,
			     (connected) ? NULL : remote_res->ai_addr,
			     remote_res->ai_addrlen,
			     protocol)) != bytes_to_send) {
	  /* in theory, we should never hit the end of the test in the
	     first burst.  however, in practice I have indeed seen
	     some ENOBUFS happen in some aggregate tests.  so we need
	     to be a bit more sophisticated in how we handle it. raj
	     20130516 */
	  if (ret != -2) {
	    perror("send_omni: initial burst data send error");
	    exit(-1);
	  }
	  failed_sends++;
	}
	else {
	  local_send_calls += 1;
	  requests_outstanding += 1;
	}

	/* yes, it seems a trifle odd having this *after* the send()
	   just above, but really this is for the next send() or
	   recv() call below or in the iteration of this loop, and the
	   first HIST_timestamp_start() call at the top of the
	   outermost loop will be for the first send() call here in
	   the burst code.  clear ain't it?-) raj 20110111 */

	if (keep_histogram) {
	  HIST_timestamp_start(time_hist);
	}
      }

#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,
			protocol);
	/* 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

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

      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 if (rret == -2) {
	  /* we timed-out on a data receive.  this is only allowed for
	     a UDP_RR test.  we want to set things up so we start
	     ramping up again like we were at the beginning. if we
	     actually timeout it means that all has been lost.  or at
	     least we assume so */
	  if (debug) {
	    fprintf(where,"Timeout receiving resonse from remote\n");
	    fflush(where);
	  }
#ifdef WANT_FIRST_BURST
	  if (first_burst_size) {
	    requests_outstanding = 0;
	  }
#endif
	  if (keep_histogram) {
	    HIST_purge(time_hist);
	  }
#ifdef WANT_DEMO
	  /* "start over" on a demo interval. we will forget about
	  everything that happened in the demo interval up to the
	  timeout and begin fresh. */
	  demo_reset(); 
#endif /* WANT_DEMO */

	  continue;
	}
	else {
	  /* anything else is bad */
	  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;
#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 */
	/* however annoying having to do this might be, it really
	   shouldn't be done over and over again. instead we will
	   assume it does not change, which is fine since we would
	   have only reported one of them anyway. raj 20100917 */
	if ((lsr_size_req < 0) && (-1 == lsr_size_end))
	  get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
	else
	  lsr_size_end = lsr_size;
	if ((lss_size_req < 0) && (-1 == lss_size_end))
	  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.  However, the next time around the loop
	     will already be picking the next port number */
	  need_to_connect = 1;
	  connected = 0;
	  need_socket = 1;
	}
	else if (ret == -1) {
	  times_up = 1;
	  timed_out = 1;
	  break;
	}
	else {
	  perror("netperf: send_omni: disconnect_data_socket failed");
	  exit(1);
	}
      }


      if (keep_histogram) {
	HIST_timestamp_stop_add(time_hist);
      }

#ifdef WANT_DEMO
      if (NETPERF_IS_RR(direction)) {
	if (libfmt == 'x') {
	  demo_interval_tick(1);
	}
	else {
	  demo_interval_tick(req_size + rsp_size);
	}
      }
      else if (NETPERF_XMIT_ONLY(direction)) {
	demo_interval_tick(bytes_to_send);
      }
      else {
	demo_interval_tick(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 defined(WANT_DEMO)
    /* if we were in demo mode this will ensure one final interim
       result, which, naturally might be a bit early :) */
    demo_interval_final();
#endif

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


    /* 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
      if ((desired_output_groups & OMNI_WANT_LOC_CONG) &&
	  (local_cong_control[0] == '\0')) {
	get_transport_cong_control(data_socket,
				   local_res->ai_protocol,
				   local_cong_control,
				   sizeof(local_cong_control));
      }

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

    /* 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_CONV_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);
	lib_num_rem_cpus = omni_result->num_cpus;
	lib_remote_cpu_stats.cpu_util = omni_result->cpu_util;
	lib_remote_cpu_stats.cpu_user = omni_result->cpu_percent_user;
	lib_remote_cpu_stats.cpu_system = omni_result->cpu_percent_system;
	lib_remote_cpu_stats.cpu_iowait = omni_result->cpu_percent_iowait;
	lib_remote_cpu_stats.cpu_irq = omni_result->cpu_percent_irq;
	lib_remote_cpu_stats.cpu_swintr = omni_result->cpu_percent_swintr;
	lib_remote_cpu_stats.peak_cpu_util = omni_result->peak_cpu_util;
	lib_remote_cpu_stats.peak_cpu_id = omni_result->peak_cpu_id;
	/* 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... */
	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 = (double) 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;

	remote_transport_retrans = omni_result->transport_retrans;
	/* what was the congestion control? */
	if (desired_output_groups & OMNI_WANT_REM_CONG) {
	  strncpy(remote_cong_control,
		  omni_result->cong_control,
		  sizeof(remote_cong_control));
	  remote_cong_control[sizeof(remote_cong_control) - 1] = '\0';
	}
      }
      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 {
      /* when we are sending, in a no_control test, we have to
	 ass-u-me that everything we sent was received, otherwise, we
	 will report a transfer rate of zero. */
      remote_bytes_xferd = (double) bytes_sent;
    }

    /* 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  = (double) 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((double)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)) {
      float rtt_elapsed_time = elapsed_time;

#ifdef WANT_INTERVALS
      /* if the test was paced, we need to subtract the time we were
	 sitting paced from the time we use to calculate the average
	 rtt_latency. Of course, won't really know how long we were
	 sitting unless we bracket the sit with timing calls, which
	 will be additional overhead affecting CPU utilization.  but,
	 there is no such thing as a free lunch is there :) raj
	 20110121 */
      if (interval_burst) {
	rtt_elapsed_time -= (float)(interval_wait_microseconds / 1000000.0);
      }
#endif /* WANT_INTERVALS */

      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/rtt_elapsed_time)) *
	 (double)1000000.0) *
	(double) (1 + ((first_burst_size > 0) ? first_burst_size : 0));
      }
      else {
	rtt_latency = ((double)1.0/(trans_completed/rtt_elapsed_time)) *
	  (double)1000000.0;
      }
      tmpfmt = libfmt;
      libfmt = 'x';
      transaction_rate = calc_thruput((double)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;

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

#if defined(WANT_INTERVALS)
#ifdef WIN32
  stop_itimer();
#endif
#endif /* WANT_INTERVALS */

/* 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_service_demand_double = (double)local_service_demand;
  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 */
  tmpfmt = libfmt;
  if ('x' == libfmt) {
    libfmt = 'm';
  }
  local_send_thruput = calc_thruput((double)bytes_sent);
  local_recv_thruput = calc_thruput((double)bytes_received);
  remote_send_thruput = calc_thruput((double)remote_bytes_sent);
  remote_recv_thruput = calc_thruput((double)remote_bytes_received);

  libfmt = tmpfmt;

  /* were we tracking possibly expensive statistics? */
  if (keep_statistics) {
    HIST_get_stats(time_hist,
		   &min_latency,
		   &max_latency,
		   &mean_latency,
		   &stddev_latency);
    p50_latency = HIST_get_percentile(time_hist, 0.50);
    p90_latency = HIST_get_percentile(time_hist, 0.90);
    p99_latency = HIST_get_percentile(time_hist, 0.99);

  }

  /* if we are running a legacy test we do not do the nifty new omni
     output stuff */
  if (!legacy) {
    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_list[0][1] = OUTPUT_END;
   for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
     output_list[0][0] = i;
     print_omni_csv();
   }
 }
#endif

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

#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");
    HIST_report(time_hist);
    fflush(where);
#endif /* WANT_HISTOGRAM */

  }

}


void
send_omni(char remote_host[])
{
  char name_buf[32];
  snprintf(name_buf,sizeof(name_buf),"OMNI %s TEST",direction_str);
  name_buf[31] = '\0';
  send_omni_inner(remote_host, 0, name_buf);
}

#if defined(WIN32)
#if !defined(InetNtop)
/* +*+ Why isn't this in the winsock headers yet? */
const char *
inet_ntop(int af, const void *src, char *dst, size_t size);
#endif
#endif

static void
set_hostname_and_port_2(void *addr, char *hostname, char *portstr, int family, int port)
{

  inet_ntop(family, addr, hostname, BUFSIZ);

  sprintf(portstr, "%u", port);

}


/* the name is something of a misnomer since this test could send, or
   receive, or both, but it matches the historical netperf routine
   naming convention for what runs in the netserver context. */
void
recv_omni()
{

  struct addrinfo *local_res;
  char local_name[BUFSIZ];
  char port_buffer[PORTBUFSIZE];

  struct sockaddr_storage myaddr_in, peeraddr_in;
  int peeraddr_set = 0;
  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 = 0;
  int   need_to_accept;
  int   connected;
  int   ret;
  uint32_t   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: %s: entered...\n",__FUNCTION__);
    fflush(where);
  }

  /* netserver has no good way of knowing where the conversion cutoff
     point is, so we have to fix it after the fact */
  fixup_request_n(OMNI_REQUEST_CONV_CUTOFF);

  /* thus fixed-up, we can extract the requested congestion control
     algorithm */
  strncpy(local_cong_control_req,
	  omni_request->cong_control,
	  sizeof(local_cong_control_req));

  /* 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,"%s: setting the response type...\n",__FUNCTION__);
    fflush(where);
  }

  netperf_response.content.response_type = OMNI_RESPONSE;

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

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

  if (debug) {
    fprintf(where,"%s: grabbing a socket...\n",__FUNCTION__);
    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->flags) & OMNI_NO_DELAY;
  loc_rcvavoid    = omni_request->so_rcvavoid;
  loc_sndavoid    = omni_request->so_sndavoid;
  routing_allowed = (omni_request->flags) & OMNI_ROUTING_ALLOWED;
  want_keepalive  = (omni_request->flags) & OMNI_WANT_KEEPALIVE;
  local_socket_prio = omni_request->socket_prio;
  local_socket_tos  = omni_request->socket_tos;
  want_defer_accept = omni_request->flags & OMNI_WANT_DEFER_ACCEPT;

#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->flags & OMNI_CONNECT_TEST;
#ifdef TCP_FASTOPEN
  use_fastopen = omni_request->flags & OMNI_FASTOPEN;
#endif
  direction       = omni_request->direction;
  use_pktinfo = (omni_request->flags) & OMNI_USE_PKTINFO;

  /* let's be quite certain the fill file string is null terminated */
  omni_request->fill_file[sizeof(omni_request->fill_file) - 1] = '\0';
  strncpy(local_fill_file,
	  omni_request->fill_file,
	  sizeof(local_fill_file));

  /* kludgy, because I have no way at present to say how many bytes
     needed to be swapped around for the request from which this is
     pulled, and it is probably all wrong for IPv6 :( */
  switch (nf_to_af(omni_request->ipfamily)) {
  case AF_INET6:
    /* yes indeed it is, do nothing, bz */
    break;
  case AF_INET:
  default:
    for (ret=0; ret < 4; ret++) {
      omni_request->netserver_ip[ret] = htonl(omni_request->netserver_ip[ret]);
      omni_request->netperf_ip[ret] = htonl(omni_request->netperf_ip[ret]);
    }
    break;
  }

  set_hostname_and_port_2(omni_request->netserver_ip,
			  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 = omni_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"
	    "recv_omni: requested send alignment of %d offset %d\n",
	    omni_request->recv_alignment,
	    omni_request->recv_offset,
	    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;
  omni_response->socket_prio = local_socket_prio;
  omni_response->socket_tos = local_socket_tos;

  if (omni_request->direction & NETPERF_XMIT) {
#ifdef fo
    /* do we need to set multicast ttl? */
    if (is_multicast_addr(remote_res)) {
      /* yes, s_listen - for a UDP test we will be copying it to
	 data_socket but that hasn't happened yet. raj 20100315 */
      set_multicast_ttl(s_listen);
    }
#endif

    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) {
	bytes_to_send = choose_send_size(lss_size,omni_request->protocol);
      }
      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_request->recv_width;
  if (omni_request->direction & NETPERF_RECV) {

    /* do we need to join a multicast group? */
    if (is_multicast_addr(local_res)) {
      /* yes, s_listen - for a UDP test we will be copying it to
	 data_socket but that hasn't happened yet. raj 20100315 */
      join_multicast_addr(s_listen, local_res);
    }

    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. the age-old constant of 5 is probably OK for our purposes
     but does not necessarily represent best practice */
  if (need_to_accept) {
    int backlog = 5;
#ifdef TCP_FASTOPEN
    /* one of these days I will have to go find-out what the backlog
       is supposed to be here.  until then, I'll just set it to five
       like the listen() call does - it is classic, and was what was
       used in the online example I found */
    if (use_fastopen &&
	(setsockopt(s_listen,IPPROTO_TCP, TCP_FASTOPEN, &backlog, sizeof(backlog)) ==
	 SOCKET_ERROR)) {
      netperf_response.content.serv_errno = errno;
      close(s_listen);
      send_response();
      if (debug) {
	fprintf(where,"netperfserver: %s could not fastopen\n",__FUNCTION__);
	fflush(where);
      }
      exit(1);
    }
#endif /* TCP_FASTOPEN */
#ifdef TCP_DEFER_ACCEPT
    if (want_defer_accept &&
	(setsockopt(s_listen, IPPROTO_TCP, TCP_DEFER_ACCEPT, &backlog, sizeof(backlog)) == SOCKET_ERROR)) {
      netperf_response.content.serv_errno = errno;
      close(s_listen);
      send_response();
      if (debug) {
	fprintf(where,
		"netperfserver: %s could not defer accept\n",__FUNCTION__);
	fflush(where);
      }
      exit(1);
    }
#endif /* TCP_DEFER_ACCEPT */
    if (listen(s_listen, backlog) == SOCKET_ERROR) {
      netperf_response.content.serv_errno = errno;
      close(s_listen);
      send_response();
      if (debug) {
	fprintf(where,"netperfserver: %s could not listen\n",__FUNCTION__);
	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->flags &= ~OMNI_MEASURE_CPU;
  if (omni_request->flags & OMNI_MEASURE_CPU) {
    omni_response->flags |= OMNI_MEASURE_CPU;
    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;
  if (loc_nodelay)
    omni_response->flags |= OMNI_NO_DELAY;
  else
    omni_response->flags &= ~OMNI_NO_DELAY;

  omni_response->so_rcvavoid = loc_rcvavoid;
  omni_response->so_sndavoid = loc_sndavoid;
  omni_response->interval_usecs = interval_usecs;
  omni_response->interval_burst = interval_burst;

  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->flags & OMNI_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;
	test_time=omni_request->test_length;
    /* 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)) && 
	(omni_request->test_length > 0))
      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;
	}
	netperf_response.content.serv_errno = errno;
	send_response();
	fprintf(where,"%s: accept: errno = %d\n",__FUNCTION__,errno);
	fflush(where);
	close(s_listen);

	exit(-1);
      }

      if (debug) {
	fprintf(where,"%s: accepted data connection.\n",__FUNCTION__);
	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, but we only need to do it once. */
      if ((omni_request->protocol == IPPROTO_UDP) &&
	  (!peeraddr_set)) {
	peeraddr_set = 1;
	data_socket = s_listen;
	set_sockaddr_family_addr_port(&peeraddr_in,
				      nf_to_af(omni_request->ipfamily),
				      omni_request->netperf_ip,
				      omni_request->netperf_port);
      }
    }

#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) || (units_remaining > 0))) {
      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 */
	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 */
	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! */
	netperf_response.content.serv_errno = errno;
	send_response();
	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) || (units_remaining > 0))) {
      
      /* there used to be some code here looking sched_yield() until
	 there was no more queued, unsent data on the socket but
	 frankly, I've no idea what that was all about so I have
	 removed it. It may have been part of a kludge to try to avoid
	 coalescing requests and responses */

      if (omni_request->protocol == IPPROTO_UDP && need_to_connect &&
          !connected) {
        if (connect(data_socket,
                    (struct sockaddr*)&peeraddr_in,
                    addrlen) == INVALID_SOCKET) {
	  netperf_response.content.serv_errno = errno;
	  send_response();
	  close(data_socket);
	  exit(-1);
        }
        connected = 1;
      }
      
      ret = send_data(data_socket,
		      send_ring,
		      bytes_to_send,
		      (connected) ? NULL : (struct sockaddr *)&peeraddr_in,
		      addrlen,
		      omni_request->protocol);

      /* 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; */
	netperf_response.content.serv_errno = errno;
	send_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 */
      /* but as annoying as it is to have to make these calls, don't
	 penalize linux by calling them over and over again. instead
	 we will simply ass-u-me that it will become the same value
	 over and over again. raj 20100917 */
      if ((lsr_size_req < 0) && (-1 == lsr_size_end))
	get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
      else
	lsr_size_end = lsr_size;
      if ((lss_size_req < 0) && (-1 == lss_size_end))
	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,omni_request->protocol);
      if (ret == -1) {
	times_up = 1;
	timed_out = 1;
	break;
      }
      else if (ret < 0) {
	netperf_response.content.serv_errno = errno;
	send_response();
	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 */
  stop_timer();
  cpu_stop(omni_request->flags & OMNI_MEASURE_CPU,&elapsed_time);
  close(s_listen);

#if defined(WANT_INTERVALS)
#ifdef WIN32
  stop_itimer();
#endif
#endif /* WANT_INTERVALS */

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

  remote_transport_retrans = get_transport_retrans(data_socket,
						   omni_request->protocol);

  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
    if (omni_request->flags & OMNI_WANT_REM_CONG) {
      get_transport_cong_control(data_socket,
				 local_res->ai_protocol,
				 omni_results->cong_control,
				 sizeof(omni_results->cong_control));
    }
    else {
      strncpy(omni_results->cong_control,"",sizeof(omni_results->cong_control));
    }


    close_data_socket(data_socket,NULL,0,omni_request->protocol);
  }
  else {
    close_data_socket(data_socket,(struct sockaddr *)&peeraddr_in,addrlen,omni_request->protocol);
    lsr_size_end = lsr_size;
    lss_size_end = lss_size;
  }

  /* send the results to the sender  */

  omni_results->send_calls      = (uint32_t) 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      = (uint32_t) 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	= (uint32_t) trans_completed;
  omni_results->elapsed_time	= elapsed_time;
  omni_results->transport_retrans = remote_transport_retrans;
  omni_results->cpu_method      = cpu_method;
  omni_results->num_cpus        = lib_num_loc_cpus;
  if (omni_request->flags & OMNI_MEASURE_CPU) {
    omni_results->cpu_util            = calc_cpu_util(elapsed_time);
    omni_results->cpu_percent_user    = lib_local_cpu_stats.cpu_user;
    omni_results->cpu_percent_system  = lib_local_cpu_stats.cpu_system;
    omni_results->cpu_percent_iowait  = lib_local_cpu_stats.cpu_iowait;
    omni_results->cpu_percent_irq     = lib_local_cpu_stats.cpu_irq;
    omni_results->cpu_percent_swintr  = lib_local_cpu_stats.cpu_swintr;
    omni_results->peak_cpu_util       = lib_local_cpu_stats.peak_cpu_util;
    omni_results->peak_cpu_id         = lib_local_cpu_stats.peak_cpu_id;
  }

#if defined(WANT_INTERVALS)
#ifdef WIN32
  stop_itimer();
#endif
#endif /* WANT_INTERVALS */

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

  send_response_n(OMNI_RESULTS_CONV_CUTOFF);

}


#ifdef WANT_MIGRATION
void
send_tcp_stream(char remote_host[])
{

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

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

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

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

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

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

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

  char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";

  send_omni_inner(remote_host, legacy, "MIGRATED TCP STREAM TEST");


  if (legacy) {

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

    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  remote_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  cpu_title,
		  format_units(),
		  local_cpu_method,
		  remote_cpu_method);
	}

	fprintf(where,
		cpu_fmt_1,		/* the format string */
		rsr_size,		/* remote recvbuf size */
		lss_size,		/* local sendbuf size */
		send_size,	        /* how large were the sends */
		elapsed_time,		/* how long was the test */
		thruput, 		/* what was the xfer rate */
		local_cpu_utilization,	/* local cpu */
		remote_cpu_utilization,	/* remote cpu */
		local_service_demand,	/* local service demand */
		remote_service_demand,	/* remote service demand */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      }
    }
    else {
      /* The tester did not wish to measure service demand. */

      switch (verbosity) {
      case 0:
	fprintf(where,
		tput_fmt_0,
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,tput_title,format_units());
	}
	fprintf(where,
		tput_fmt_1,		/* the format string */
		rsr_size, 		/* remote recvbuf size */
		lss_size, 		/* local sendbuf size */
		send_size,	        /* how large were the sends */
		elapsed_time, 		/* how long did it take */
		thruput,                /* how fast did it go */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      }
    }

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

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

      /* this stuff needs to be worked-out in the presence of confidence */
      /* intervals and multiple iterations of the test... raj 11/94 */

      fprintf(where,
	      ksink_fmt,
	      "Bytes",
	      "Bytes",
	      "Bytes",
	      local_send_align,
	      remote_recv_align,
	      local_send_offset,
	      remote_recv_offset,
	      bytes_sent,
	      bytes_sent / (double)local_send_calls,
	      local_send_calls,
	      bytes_sent / (double)remote_receive_calls,
	      remote_receive_calls);
      fprintf(where,
	      ksink_fmt2,
	      transport_mss);
#ifdef WANT_HISTOGRAM
      fprintf(where,"\n\nHistogram of time spent in send() call.\n");
      HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
      fflush(where);
    }

  }
}

void
send_tcp_maerts(char remote_host[])
{

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

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

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

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

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

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

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

  char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";

  send_omni_inner(remote_host, legacy, "MIGRATED TCP MAERTS TEST");


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

  if (legacy) {

    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  remote_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  cpu_title,
		  format_units(),
		  local_cpu_method,
		  remote_cpu_method);
	}

	fprintf(where,
		cpu_fmt_1,		/* the format string */
		rsr_size,		/* remote recvbuf size */
		lss_size,		/* local sendbuf size */
		remote_send_size,	/* how large were the recvs */
		elapsed_time,		/* how long was the test */
		thruput, 		/* what was the xfer rate */
		local_cpu_utilization,	/* local cpu */
		remote_cpu_utilization,	/* remote cpu */
		local_service_demand,	/* local service demand */
		remote_service_demand,	/* remote service demand */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      }
    }
    else {
      /* The tester did not wish to measure service demand. */

      switch (verbosity) {
      case 0:
	fprintf(where,
		tput_fmt_0,
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,tput_title,format_units());
	}
	fprintf(where,
		tput_fmt_1,		/* the format string */
		lsr_size, 		/* local recvbuf size */
		rss_size, 		/* remot sendbuf size */
		remote_send_size,	/* how large were the recvs */
		elapsed_time, 		/* how long did it take */
		thruput,                /* how fast did it go */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      }
    }

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

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

      /* this stuff needs to be worked-out in the presence of confidence */
      /* intervals and multiple iterations of the test... raj 11/94 */

      fprintf(where,
	      ksink_fmt,
	      "Bytes",
	      "Bytes",
	      "Bytes",
	      local_recv_align,
	      remote_recv_align,
	      local_recv_offset,
	      remote_recv_offset,
	      bytes_received,
	      bytes_received / (double)local_receive_calls,
	      local_receive_calls,
	      remote_bytes_sent / (double)remote_send_calls,
	      remote_send_calls);
      fprintf(where,
	      ksink_fmt2,
	      transport_mss);

#ifdef WANT_HISTOGRAM
      fprintf(where,"\n\nHistogram of time spent in recv() call.\n");
      HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
      fflush(where);
    }
  }
}


void
send_tcp_rr(char remote_host[]) {

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

  char *tput_title_band = "\
Local /Remote\n\
Socket Size   Request  Resp.   Elapsed  \n\
Send   Recv   Size     Size    Time     Throughput \n\
bytes  Bytes  bytes    bytes   secs.    %s/sec   \n\n";

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

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

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

  char *cpu_title_tput = "\
Local /Remote\n\
Socket Size   Request Resp.  Elapsed Tput     CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    %-8.8s local  remote local   remote\n\
bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/KB   us/KB\n\n";

  char *cpu_title_latency = "\
Local /Remote\n\
Socket Size   Request Resp.  Elapsed Latency  CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    usecs    local  remote local   remote\n\
bytes  bytes  bytes   bytes  secs.   per tran %% %c    %% %c    us/Tr   us/Tr\n\n";

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

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

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

  char *ksink_fmt = "\
Alignment      Offset         RoundTrip  Trans    Throughput\n\
Local  Remote  Local  Remote  Latency    Rate     %-8.8s/s\n\
Send   Recv    Send   Recv    usec/Tran  per sec  Outbound   Inbound\n\
%5d  %5d   %5d  %5d   %-6.3f   %-6.3f %-6.3f    %-6.3f\n";

  send_omni_inner(remote_host, legacy, "MIGRATED TCP REQUEST/RESPONSE TEST");

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

    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  remote_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);
	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  if ('x' == libfmt) {
	    fprintf(where,
		    cpu_title,
		    local_cpu_method,
		    remote_cpu_method);
	  }
	  else {
	    fprintf(where,
		    cpu_title_tput,
		    format_units(),
		    local_cpu_method,
		    remote_cpu_method);
	  }
	}

	fprintf(where,
		cpu_fmt_1_line_1,		/* the format string */
		lss_size,		/* local sendbuf size */
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* guess */
		elapsed_time,		/* how long was the test */
		thruput,
		local_cpu_utilization,	/* local cpu */
		remote_cpu_utilization,	/* remote cpu */
		local_service_demand,	/* local service demand */
		remote_service_demand,	/* remote service demand */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	fprintf(where,
		cpu_fmt_1_line_2,
		rss_size,
		rsr_size);
	break;
      }
    }
    else {
      /* The tester did not wish to measure service demand. */

      switch (verbosity) {
      case 0:
	fprintf(where,
		tput_fmt_0,
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  ('x' == libfmt) ? tput_title : tput_title_band,
		  format_units());
	}

	fprintf(where,
		tput_fmt_1_line_1,	/* the format string */
		lss_size,
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* how large were the responses */
		elapsed_time, 		/* how long did it take */
		/* are we trans or do we need to convert to bytes then
		   bits? at this point, thruput is in our "confident"
		   transactions per second. we can convert to a
		   bidirectional bitrate by multiplying that by the sum
		   of the req_size and rsp_size.  we pass that to
		   calc_thruput_interval_omni with an elapsed time of
		   1.0 s to get it converted to [kmg]bits/s or
		   [KMG]Bytes/s */
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	fprintf(where,
		tput_fmt_1_line_2,
		rss_size, 		/* remote recvbuf size */
		rsr_size);

	break;
      }
    }

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

    /* how to handle the verbose information in the presence of */
    /* confidence intervals is yet to be determined... raj 11/94 */
    if (verbosity > 1) {
      /* The user wanted to know it all, so we will give it to him. */
      /* This information will include as much as we can find about */
      /* TCP statistics, the alignments of the sends and receives */
      /* and all that sort of rot... */

      /* normally, you might think that if we were messing about with
	 the value of libfmt we would need to put it back again, but
	 since this is basically the last thing we are going to do with
	 it, it does not matter.  so there :) raj 2007-06-08 */
      /* if the user was asking for transactions, then we report
	 megabits per second for the unidirectional throughput,
	 otherwise we use the desired units. */
      if ('x' == libfmt) {
	libfmt = 'm';
      }

      fprintf(where,
	      ksink_fmt,
	      format_units(),
	      local_send_align,
	      remote_recv_offset,
	      local_send_offset,
	      remote_recv_offset,
	      /* if the user has enable burst mode, we have to remember
		 to account for that in the number of transactions
		 outstanding at any one time. otherwise we will
		 underreport the latency of individual
		 transactions. learned from saf by raj 2007-06-08  */
	      (((double)1.0/transaction_rate)*(double)1000000.0) *
	      (double) (1 + ((first_burst_size > 0) ? first_burst_size : 0)),
	      transaction_rate,
	      calc_thruput_interval_omni(transaction_rate * (double)req_size,
					 1.0),
	      calc_thruput_interval_omni(transaction_rate * (double)rsp_size,
					 1.0));

#ifdef WANT_HISTOGRAM
      fprintf(where,"\nHistogram of request/response times\n");
      HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
      fflush(where);
    }
  }
}


void
send_tcp_conn_rr(char remote_host[])
{

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

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

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

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

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

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

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

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

  send_omni_inner(remote_host,
		  legacy,
		  "MIGRATED TCP Connect/Request/Response TEST");

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

  if (legacy) {
    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method);
	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  remote_cpu_method);
	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  cpu_title,
		  local_cpu_method,
		  remote_cpu_method);
	}

	fprintf(where,
		cpu_fmt_1_line_1,	/* the format string */
		lss_size,		/* local sendbuf size */
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* guess */
		elapsed_time,		/* how long was the test */
		thruput,
		local_cpu_utilization,	/* local cpu */
		remote_cpu_utilization,	/* remote cpu */
		local_service_demand,	/* local service demand */
		remote_service_demand);	/* remote service demand */
	fprintf(where,
		cpu_fmt_1_line_2,
		rss_size,
		rsr_size);
	break;
      }
    }
    else {
      /* The tester did not wish to measure service demand. */

      switch (verbosity) {
      case 0:
	fprintf(where,
		tput_fmt_0,
		thruput);
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,tput_title,format_units());
	}

	fprintf(where,
		tput_fmt_1_line_1,	/* the format string */
		lss_size,
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* how large were the responses */
		elapsed_time, 		/* how long did it take */
		thruput);
	fprintf(where,
		tput_fmt_1_line_2,
		rss_size, 		/* remote recvbuf size */
		rsr_size);

	break;
      }
    }

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

    /* how to handle the verbose information in the presence of */
    /* confidence intervals is yet to be determined... raj 11/94 */
    if (verbosity > 1) {
      /* The user wanted to know it all, so we will give it to him. */
      /* This information will include as much as we can find about */
      /* TCP statistics, the alignments of the sends and receives */
      /* and all that sort of rot... */

      fprintf(where,
	      ksink_fmt,
	      local_send_align,
	      remote_recv_align,
	      local_send_offset,
	      remote_recv_offset);

#ifdef WANT_HISTOGRAM
      fprintf(where,"\nHistogram of request/response times\n");
      HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
      fflush(where);
    }
  }
}

void
send_udp_stream(char remote_host[])
{
  /**********************************************************************/
  /*									*/
  /*               	UDP Unidirectional Send Test                    */
  /*									*/
  /**********************************************************************/

  char *tput_title = "\
Socket  Message  Elapsed      Messages                \n\
Size    Size     Time         Okay Errors   Throughput\n\
bytes   bytes    secs            #      #   %s/sec\n\n";

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

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


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

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

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


  send_omni_inner(remote_host, legacy, "MIGRATED UDP STREAM TEST");

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


    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method);
	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  local_cpu_method);
	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  cpu_title,
		  format_units(),
		  local_cpu_method,
		  remote_cpu_method);
	}

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

#ifdef WANT_HISTOGRAM
    if (verbosity > 1) {
      fprintf(where,"\nHistogram of time spent in send() call\n");
      HIST_report(time_hist);
    }
#endif /* WANT_HISTOGRAM */
    fflush(where);
  }
}

void
send_udp_rr(char remote_host[])
{

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

  char *tput_title_band = "\
Local /Remote\n\
Socket Size   Request  Resp.   Elapsed  \n\
Send   Recv   Size     Size    Time     Throughput \n\
bytes  Bytes  bytes    bytes   secs.    %s/sec   \n\n";

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

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

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

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

  char *cpu_title_tput = "\
Local /Remote\n\
Socket Size   Request Resp.  Elapsed Tput     CPU    CPU    S.dem   S.dem\n\
Send   Recv   Size    Size   Time    %-8.8s local  remote local   remote\n\
bytes  bytes  bytes   bytes  secs.   per sec  %% %c    %% %c    us/KB   us/KB\n\n";

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

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

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

  send_omni_inner(remote_host, legacy, "MIGRATED UDP REQUEST/RESPONSE TEST");

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

    if (confidence < 0) {
      /* we did not hit confidence, but were we asked to look for it? */
      if (iteration_max > 1) {
	display_confidence();
      }
    }

    if (local_cpu_usage || remote_cpu_usage) {

      switch (verbosity) {
      case 0:
	if (local_cpu_usage) {
	  fprintf(where,
		  cpu_fmt_0,
		  local_service_demand,
		  local_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);

	}
	else {
	  fprintf(where,
		  cpu_fmt_0,
		  remote_service_demand,
		  remote_cpu_method,
		  ((print_headers) ||
		   (result_brand == NULL)) ? "" : result_brand);

	}
	break;
      case 1:
      case 2:
	if (print_headers) {
	  if ('x' == libfmt) {
	    fprintf(where,
		    cpu_title,
		    local_cpu_method,
		    remote_cpu_method);
	  }
	  else {
	    fprintf(where,
		    cpu_title_tput,
		    format_units(),
		    local_cpu_method,
		    remote_cpu_method);
	  }
	}

	fprintf(where,
		cpu_fmt_1_line_1,		/* the format string */
		lss_size,		/* local sendbuf size */
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* guess */
		elapsed_time,		/* how long was the test */
		thruput,
		local_cpu_utilization,	/* local cpu */
		remote_cpu_utilization,	/* remote cpu */
		local_service_demand,	/* local service demand */
		remote_service_demand,	/* remote service demand */
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	fprintf(where,
		cpu_fmt_1_line_2,
		rss_size,
		rsr_size);
	break;
      }
    }
    else {
      /* The tester did not wish to measure service demand. */
      switch (verbosity) {
      case 0:
	fprintf(where,
		tput_fmt_0,
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	break;
      case 1:
      case 2:
	if (print_headers) {
	  fprintf(where,
		  ('x' == libfmt) ? tput_title : tput_title_band,
		  format_units());
	}

	fprintf(where,
		tput_fmt_1_line_1,	/* the format string */
		lss_size,
		lsr_size,
		req_size,		/* how large were the requests */
		rsp_size,		/* how large were the responses */
		elapsed_time, 		/* how long did it take */
		thruput,
		((print_headers) ||
		 (result_brand == NULL)) ? "" : result_brand);
	fprintf(where,
		tput_fmt_1_line_2,
		rss_size, 		/* remote recvbuf size */
		rsr_size);

	break;
      }
    }

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

    /* how to handle the verbose information in the presence of */
    /* confidence intervals is yet to be determined... raj 11/94 */

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

#ifdef WANT_HISTOGRAM
      fprintf(where,"\nHistogram of request/reponse times.\n");
      HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
    }
    fflush(where);
  }
}


#endif /* WANT_MIGRATION */


/* using legacy test names will cause certain default settings to be
   made before we scan the test-specific arguments.  raj 2010-07-20 */
static void
set_omni_defaults_by_legacy_testname() {

  /* the uber defaults are for a unidirectional test using TCP */
  protocol = IPPROTO_TCP;
  socket_type = SOCK_STREAM;
  connection_test = 0;
  req_size = rsp_size = -1;
  was_legacy = 1;
  legacy = 1;
  implicit_direction = 0;  /* do we allow certain options to
			      implicitly affect the test direction? */
  if (strcasecmp(test_name,"TCP_STREAM") == 0) {
    direction = NETPERF_XMIT;
  }
  else if (strcasecmp(test_name,"TCP_MAERTS") == 0) {
    direction = NETPERF_RECV;
  }
  else if (strcasecmp(test_name,"TCP_RR") == 0) {
    req_size = rsp_size = 1;
    direction = 0;
    direction |= NETPERF_XMIT;
    direction |= NETPERF_RECV;
  }
  else if (strcasecmp(test_name,"UDP_STREAM") == 0) {
     protocol = IPPROTO_UDP;
    socket_type = SOCK_DGRAM;
  }
  else if (strcasecmp(test_name,"UDP_RR") == 0) {
     protocol = IPPROTO_UDP;
    socket_type = SOCK_DGRAM;
    direction = 0;
    direction |= NETPERF_XMIT;
    direction |= NETPERF_RECV;
    req_size = rsp_size = 1;
  }
  else if (strcasecmp(test_name,"TCP_CC") == 0) {
    direction = 0;
    connection_test = 1;
  }
  else if (strcasecmp(test_name,"TCP_CRR") == 0) {
    direction = 0;
    direction |= NETPERF_XMIT;
    direction |= NETPERF_RECV;
    req_size = rsp_size = 1;
    connection_test = 1;
  }
  else if (strcasecmp(test_name,"omni") == 0) {
    /* there is not much to do here but clear the legacy flag */
    was_legacy = 0;
    legacy = 0;
    implicit_direction = 1;
  }
  socket_type_str = hst_to_str(socket_type);
}

char omni_usage[] = "\n\
Usage: netperf [global options] -- [test options] \n\
\n\
OMNI and Migrated BSD Sockets Test Options:\n\
    -b number         Send number requests at start of _RR tests\n\
    -c                Explicitly declare this a connection test such as\n\
                      TCP_CRR or TCP_CC\n\
    -C                Set TCP_CORK when available\n\
    -d direction      Explicitly set test direction based on bitwise OR\n\
                      of 0x2 for transmit and 0x4 for receive. Default:\n\
                      based on test type\n\
    -D [L][,R]        Set TCP_NODELAY locally and/or remotely (TCP_*)\n\
    -h                Display this text\n\
    -H name[/mask],fam  Use name (or IP) and family as target of data connection\n\
                      A mask value will cause randomization of the IP used\n\
    -k [file]         Generate keyval output optionally based on file\n\
                      Use filename of '?' to get the list of choices\n\
    -K loc[,rem]      Set the local and/or remote congestion control\n\
                      algorithm to use on those platforms where it can\n\
                      be set.\n\
    -L name[/mask],fam  Use name (or IP) and family as source of data connection\n\
                      A mask value will cause randomization of the IP used\n\
    -m local,remote   Set the send size for _STREAM/_MAERTS tests\n\
    -M local,remote   Set the recv size for _STREAM/_MAERTS tests\n\
    -n                Use the connected socket for UDP locally\n\
    -N                Use the connected socket for UDP remotely\n\
    -o [file]         Generate CSV output optionally based on file\n\
                      Use filename of '?' to get the list of choices\n\
    -O [file]         Generate classic-style output based on file\n\
                      Use filename of '?' to get the list of choices\n\
    -p min[,max]      Set the min/max port numbers for TCP_CRR, TCP_TRR\n\
    -P local[,remote] Set the local/remote port for the data socket\n\
    -r req,[rsp]      Set request/response sizes (TCP_RR, UDP_RR)\n\
    -R 0/1            Allow routing of traffic on data connection.\n\
                      Default: 0 (off) for UDP_STREAM, 1 (on) otherwise\n\
    -s send[,recv]    Set local socket send/recv buffer sizes\n\
    -S send[,recv]    Set remote socket send/recv buffer sizes\n\
    -t type           Explicitly set socket type. Default is implicit\n\
                      based on other settings\n\
    -T protocol       Explicitly set data connection protocol. Default is\n\
                      implicit based on other settings\n\
    -u uuid           Use the supplied string as the UUID for this test.\n\
    -4                Use AF_INET (eg IPv4) on both ends of the data conn\n\
    -6                Use AF_INET6 (eg IPv6) on both ends of the data conn\n\
\n\
For those options taking two parms, at least one must be specified;\n\
specifying one value without a comma will set both parms to that\n\
value, specifying a value with a leading comma will set just the second\n\
parm, a value with a trailing comma will set just the first. To set\n\
each parm to unique values, specify both and separate them with a\n\
comma.\n";

void
print_omni_usage()
{

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

}


void
scan_omni_args(int argc, char *argv[])

{

#define OMNI_ARGS "aBb:cCd:De:FgG:hH:i:Ij:kK:l:L:m:M:nNoOp:P:r:R:s:S:t:T:u:UVw:W:46"

  extern char	*optarg;	  /* pointer to option string	*/

  int		c;
  int           have_uuid = 0;
  int           have_R_option = 0;

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

  if (debug) {
    int i;
    printf("%s called with the following argument vector\n",
	   __FUNCTION__);
    for (i = 0; i< argc; i++) {
      printf("%s ",argv[i]);
    }
    printf("\n");
  }

  /* double-check struct sizes */
  {
    const union netperf_request_struct * u = (const union netperf_request_struct *)0;
    if (debug) {
      fprintf(where, "sizeof(omni_request_struct)=%d/%d\n",
              (int)sizeof(struct omni_request_struct),
              (int)sizeof(u->content.test_specific_data));
      fprintf(where, "sizeof(omni_response_struct)=%d/%d\n",
              (int)sizeof(struct omni_response_struct),
              (int)sizeof(u->content.test_specific_data));
      fprintf(where, "sizeof(omni_results_struct)=%d/%d\n",
              (int)sizeof(struct omni_results_struct),
              (int)sizeof(u->content.test_specific_data));
    }
    assert(sizeof(struct omni_request_struct)
           <= sizeof(u->content.test_specific_data));
    assert(sizeof(struct omni_response_struct)
           <= sizeof(u->content.test_specific_data));
    assert(sizeof(struct omni_results_struct)
           <= sizeof(u->content.test_specific_data));
  }

  strncpy(local_data_port,"0",sizeof(local_data_port));
  strncpy(remote_data_port,"0",sizeof(remote_data_port));

  /* this will handle setting default settings based on test name */
  set_omni_defaults_by_legacy_testname();

  /* 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_omni_usage();
      exit(1);
    case 'a':
      want_defer_accept = 1;
      break;
    case 'B':
      want_use_pktinfo = 1;
      break;
    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, but only for an
	 actual omni test and then disable implicit setting of
	 direction */
      if (!was_legacy) {
	direction = parse_direction(optarg);
	implicit_direction = 0;
      }
      break;
    case 'D':
      /* set the TCP nodelay flag */
      loc_nodelay = 1;
      rem_nodelay = 1;
      break;
    case 'F':
#if defined(MSG_FASTOPEN)
      use_fastopen = 1;
#else
      printf("WARNING: TCP FASTOPEN not available on this platform!\n");
#endif
      break;
    case 'e':
      /* set the rEceive timeout */
      receive_timeout = atoi(optarg);
      break;
    case 'g':
      /* enable SO_DEBUG, or at least make the attempt, on the data socket */
      socket_debug = 1;
      break;
    case 'G':
      /* set the value for a tcp_maxseG call*/
      transport_mss_req = atoi(optarg);
      break;
    case 'H':
      break_args_explicit_sep(optarg,',',arg1,arg2);
      if (arg1[0]) {
	/* check to see if there was a width, which we would want to
	   be arg3. for simplicities sake, we will assume the width
	   must follow the address and not the address family - ie
	   1.2.3.4/24,inet.  This means we can just pass optarg again
	   as the source rather than have to shuffle arg values. */
	break_args_explicit_sep(optarg,'/',arg1,arg3);
	if (arg1[0]) {
	  remote_data_address = malloc(strlen(arg1)+1);
	  strcpy(remote_data_address,arg1);
	  explicit_data_address = 1;
	}
	if (arg3[0]) {
	  remote_mask_len = convert(arg3);
	}
      }
      if (arg2[0]) {
	remote_data_family = parse_address_family(arg2);
      }
      break;
    case 'i':
      fprintf(stderr,"The support for check_interval has been removed because the contributing editor no longer knew what it was for\n");
      fflush(stderr);
      break;
    case 'I':
      use_write = 1;
      break;
    case 'j':
      parallel_connections = atoi(optarg);
      break;
    case 'k':
      netperf_output_mode = KEYVAL;
      legacy = 0;
      /* obliterate any previous file name */
      if (output_selection_spec) {
	free(output_selection_spec);
	output_selection_spec = 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. */
	output_selection_spec = strdup(argv[optind]);
	optind++;
	/* special case - if the file name is "?" then we will emit a
	   list of the available outputs */
	if (strcmp(output_selection_spec,"?") == 0) {
	  dump_netperf_output_choices(stdout,1);
	  exit(1);
	}
      }
      break;
    case 'K':
      /* "Kongestion Kontrol */
      break_args(optarg,arg1,arg2);
      if (arg1[0])
	strncpy(local_cong_control_req,arg1,sizeof(local_cong_control_req));
      if (arg2[2])
	strncpy(remote_cong_control_req,arg2,sizeof(remote_cong_control_req));
      break;
    case 'l':
      multicast_ttl = atoi(optarg);
      break;
    case 'L':
      break_args_explicit_sep(optarg,',',arg1,arg2);
      if (arg1[0]) {
	/* check to see if there was a width, which we would want to
	   be arg3. for simplicities sake, we will assume the width
	   must follow the address and not the address family - ie
	   1.2.3.4/24,inet.  This means we can just pass optarg again
	   as the source rather than have to shuffle arg values. */
	break_args_explicit_sep(optarg,'/',arg1,arg3);
	if (arg1[0]) {
	  local_data_address = malloc(strlen(arg1)+1);
	  strcpy(local_data_address,arg1);
	}
	if (arg3[0]) {
	  local_mask_len = convert(arg3);
	}
      }
      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);
	if (implicit_direction)
	  direction |= NETPERF_XMIT;
      }
      if (arg2[0]) {
	remote_send_size_req = convert(arg2);
	if (implicit_direction)
	  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);
	if (implicit_direction)
	  direction |= NETPERF_XMIT;
      }
      if (arg2[0]) {
	recv_size = convert(arg2);
	if (implicit_direction)
	  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':
      netperf_output_mode = CSV;
      legacy = 0;
      /* obliterate any previous file name */
      if (output_selection_spec) {
	free(output_selection_spec);
	output_selection_spec = NULL;
      }
      if (output_selection_spec) {
	free(output_selection_spec);
	output_selection_spec = 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. */
	output_selection_spec = strdup(argv[optind]);
	optind++;
	/* special case - if the file name is "?" then we will emit a
	   list of the available outputs */
	if (strcmp(output_selection_spec,"?") == 0) {
	  dump_netperf_output_choices(stdout,1);
	  exit(1);
	}
      }
      break;
    case 'O':
      netperf_output_mode = HUMAN;
      legacy = 0;
      /* obliterate any previous file name */
      if (output_selection_spec) {
	free(output_selection_spec);
	output_selection_spec = 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 */
	output_selection_spec = strdup(argv[optind]);
	optind++;
	if (strcmp(output_selection_spec,"?") == 0) {
	  dump_netperf_output_choices(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 */
      if (implicit_direction) {
	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 'R':
      routing_allowed = atoi(optarg);
      have_R_option = 1;
      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 'U':
      /* we don't want to give-up on the failure of a connect() call */
      dont_give_up = 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... */
      loc_sndavoid = 1;
      loc_rcvavoid = 1;
      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);

  /* to cover the backside of blithering idiots who run unidirectional
     UDP tests on test setups where they might trash their corporate
     WAN, we grudgingly provide a safety latch. unless explicitly
     enabled, UDP_STREAM/UDP_MAERTS sockets will not allow themselves
     to be routed via a gateway. raj 20091026 */

  if ((!have_R_option) &&
      (protocol == IPPROTO_UDP) &&
      (!NETPERF_IS_RR(direction))) {
    routing_allowed = 0;
  }

  /* 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_HISTOGRAM)
  if (verbosity > 1) keep_histogram = 1;
#endif

  /* did the user use -d 6 but not set -r? */
  if (NETPERF_IS_RR(direction) && !NETPERF_CC(direction)) {
    if (req_size == -1)
      req_size = 1;
    if (rsp_size == -1)
      rsp_size = 1;
  }

  /* 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) {
    if (strcmp(remote_data_port,"0") == 0) {
      /* we need to select either the discard port, echo port or
	 chargen port dedepending on the test direction. raj
	 20101220 */
      if (NETPERF_XMIT_ONLY(direction)) {
	strncpy(remote_data_port,"discard",sizeof(remote_data_port));
	recv_size = -1;
      }
      else if (NETPERF_RECV_ONLY(direction)) {
	strncpy(remote_data_port,"chargen",sizeof(remote_data_port));
	send_size = -1;
      }
      else if (NETPERF_IS_RR(direction) || NETPERF_CC(direction)) {
	strncpy(remote_data_port,"echo",sizeof(remote_data_port));
	rsp_size = req_size;
      }
      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;

  }
  /* so, did the user request a few things implicitly via output selection? */
  if (!legacy)
    print_omni_init();

  if (desired_output_groups & OMNI_WANT_STATS) {
    keep_statistics = 1;
    keep_histogram = 1;
  }

}

#endif /* WANT_OMNI */