t_ucast_spocket.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_ucast_spocket                                                *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    This is the "main" program for our sockets tester.  It parses command    *
*  line parameters and starts up the tester class.                            *
*                                                                             *
*******************************************************************************
* Copyright (c) 2001-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "bcast_spocketer.h"

#include <basis/byte_array.h>
#include <basis/istring.h>
#include <loggers/file_logger.h>
#include <data_struct/static_memory_gremlin.h>
#include <sockets/address.h>

#include <stdio.h>
#include <string.h>

const int INITIAL_DELAY = 10;  // number of seconds before starting sends.

HOOPLE_STARTUP_CODE;

#define LOG(s) program_wide_logger().log(s)

typedef byte ip_address_holder[4];

//hmmm: extract this to function in sockets.
bool parse_address(const istring &input, ip_address_holder &ip_address)
{
  int index = 0;  // current storage position in our array.
  int current_byte = 0;
  const char *last_period = 0;  // helps check for non-empty numbers.
  bool got_digit = false;
  for (const char *address = input.s(); *address; address++) {
    if ( (*address <= '9') && (*address >= '0') ) {
      current_byte *= 10;  // shift over.
      current_byte += *address - '0';  // add in current character.
      got_digit = true;
    } else if (*address == '.') {
      got_digit = false;
      if (last_period + 1 == address) {
        LOG("The IP address entry has an empty digit.  Exiting.");
        return false;
      }
      last_period = address;  // set our last period location.
      if (current_byte > 255) {
        LOG("The IP address entry has an illegal byte.  Exiting.");
        return false;
      }
      ip_address[index] = byte(current_byte);  // store current byte.
      current_byte = 0;  // reset.
      index++;  // next place in array.
      if (index > 3) break;
        // stop if there are too many periods, but keep accumulated address.
    } else {
      LOG("The IP address entry has illegal characters.  Exiting.");
      return false;
    }
  }
  // catch the case where we ran out of chars before adding the last byte.
  if ( (index == 3) && got_digit) {
    if (current_byte > 255) {
      LOG("The IP address entry has an illegal byte.  Exiting.");
      return false;
    }
    ip_address[index] = current_byte;
  } else if (index < 4) {
    LOG("The IP address entry is too short.  Exiting.");
    return false;
  }
  return true;
}

int main(int argc, char *argv[])
{
  SET_DEFAULT_COMBO_LOGGER;

  if (argc < 7) {
    LOG("\
This program takes six command line arguments to begin operation.\n\
These arguments (in order) are:\n\
\tIP address for src\tIn the form w.x.y.z\n\
\tIP address for dest\tIn the form w.x.y.z\n\
\tReceive Port number\tAs a short integer\n\
\tSending Port number\tAs a short integer\n\
\tSend size\t\tThe size of the data to exchange.\n\
\tSend count\t\tThe number of \"packets\" to exchange.\n\
Note: it is expected that the testers have equal send sizes; this\n\
allows the receiver to know when it's gotten all the data that's\n\
expected during a cycle.");
    return 1;
  }

  ip_address_holder ip_address;  // accumulates the source address.

  if (!parse_address(argv[1], ip_address)) {
    LOG("failed to parse source address.");
    return 9283;
  }

  LOG(isprintf("\tParsed a source of: \"%d.%d.%d.%d\".",
      (int)ip_address[0], (int)ip_address[1], (int)ip_address[2],
      (int)ip_address[3]));

  ip_address_holder dest_addr;  // where to send stuff to.

  if (!parse_address(argv[2], dest_addr)) {
    LOG("failed to parse dest address.");
    return 9283;
  }

  LOG(isprintf("\tParsed a destination of: \"%d.%d.%d.%d\".",
      (int)dest_addr[0], (int)dest_addr[1], (int)dest_addr[2],
      (int)dest_addr[3]));

  // parse the third parameter: the port.
  int rcv_port = 0;
  if (sscanf(argv[3], "%d", &rcv_port) < 1) {
    LOG("The port entry is malformed.  Exiting.");
    return 3;
  }
  LOG(isprintf("\tGot a receive port of %d.", rcv_port));

  // parse the fourth parameter: the port.
  int send_port = 0;
  if (sscanf(argv[4], "%d", &send_port) < 1) {
    LOG("The port entry is malformed.  Exiting.");
    return 3;
  }
  LOG(isprintf("\tGot a send port of %d.", send_port));

  // parse the fifth parameter: the size of the sends.
  int send_size = 0;
  if (sscanf(argv[5], "%d", &send_size) < 1) {
    LOG("The send size entry is malformed.  Exiting.");
    return 5;
  }
  LOG(isprintf("\tGot a send size of %d.", send_size));

  // parse the sixth parameter: the number of sends.
  int send_count = 0;
  if (sscanf(argv[6], "%d", &send_count) < 1) {
    LOG("The send count entry is malformed.  Exiting.");
    return 5;
  }
  LOG(isprintf("\tGot a send count of %d.", send_count));

  // package our parameters in a form the tester likes.
  internet_address to_pass(byte_array(4, ip_address), "", rcv_port);
  internet_address dest(byte_array(4, dest_addr), "", send_port);

  // now, construct our tester object.
  broadcast_spocket_tester tester(to_pass, true);

  // choose the appropriate action based on our role.
  bool outcome = tester.connect();
  if (!outcome) {
    LOG(istring("Failed to connect on the tester."));
    return 10;
  }

  LOG(isprintf("you now have %d seconds; get other side ready.",
      INITIAL_DELAY));
  portable::sleep_ms(INITIAL_DELAY * SECOND_ms);
  LOG("starting test");

  // so, we're connected.  try sending the test packages out.
  testing_statistics stats;  // to be filled by the tester.
  outcome = tester.perform_test(dest, send_size, send_count * 2, stats);
    // multiply send_count since we count each side as one.
  if (!outcome) {
    LOG("Failed out of send_data; maybe other side terminated.");
  }

  stats.total_runs /= 2;  // cut down to the real number of tests.

  if (!stats.total_runs)
    stats.total_runs = 1;

  // now report on the stats that we get from the data sending.
  LOG(isprintf("Report for %d completed test cycles.", stats.total_runs));
  LOG("");
  LOG("\t\tsend stats\t\treceive stats");
  LOG("\t\t----------\t\t-------------");
  LOG(isprintf("bytes\t\t%d\t\t\t%d", stats.bytes_sent,
      stats.bytes_received));
  LOG(isprintf("time\t\t%d\t\t\t%d", stats.send_time, stats.receive_time));
  LOG(isprintf("avg. bytes\t%d\t\t\t%d", stats.bytes_sent
      / stats.total_runs / 2, stats.bytes_received / stats.total_runs / 2));
  LOG("");
  LOG(isprintf("round trip time: %d ms", stats.round_trip_time));
//hmmm: use the bandwidth measurer object!!!
  double bandwidth = double(stats.bytes_sent + stats.bytes_received)
      / stats.round_trip_time / 1024.0 * 1000.0;
  LOG(isprintf("bandwidth overall: %f K/s", bandwidth));

  return 0;
}

---