t_spocket.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_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 "spocket_tester.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>

HOOPLE_STARTUP_CODE;

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

typedef byte ip_address_holder[4];

//hmmm: get into a library; same func as in t_bcast_spocket
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 < 6) {
    LOG("\
This program takes five command line arguments to begin operation.\n\
These arguments (in order) are:\n\
\tIP address\t\tIn the form w.x.y.z\n\
\tPort number\t\tAs a short integer\n\
\tTester role\t\tEither \"client\" or \"server\"\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 client and server have equal send sizes;\n\
this 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 address.
  parse_address(argv[1], ip_address);

  LOG(isprintf("\tParsed an IP address: \"%d.%d.%d.%d\".",
      (int)ip_address[0], (int)ip_address[1], (int)ip_address[2],
      (int)ip_address[3]));

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

  // parse the third parameter: the role for this tester.
  bool client;
  istring arg3 = argv[3];
  arg3.to_lower();
  if (arg3 == "client") client = true;
  else if (arg3 == "server") client = false;
  else {
    LOG("The tester role (client/server) is malformed.  Exiting.");
    return 4;
  }
  if (client) LOG("\tTester role is \"client\".");
  else LOG("\tTester role is \"server\".");

  // parse the fourth parameter: the size of the sends.
  int send_size = 0;
  if (sscanf(argv[4], "%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 fifth parameter: the number of sends.
  int send_count = 0;
  if (sscanf(argv[5], "%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), "", port);

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

  // choose the appropriate action based on our role.
  bool outcome;
  if (client)
    outcome = tester.connect();
  else
    outcome = tester.accept();
  if (!outcome) {
    const char *action = client? "connect" : "accept";
    LOG(istring("Failed to ") + action + " on the tester.");
    return 10;
  }

  // so, we're connected.  try sending the test packages out.
  testing_statistics stats;  // to be filled by the tester.
  outcome = tester.perform_test(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;
}

---