octopi/library/tests_sockets/spocket_tester.cpp

   1 /*****************************************************************************\
   2 *                                                                             *
   3 *  Name   : spocket_tester                                                    *
   4 *  Author : Chris Koeritz                                                     *
   5 *                                                                             *
   6 *******************************************************************************
   7 * Copyright (c) 2000-$now By Author.  This program is free software; you can  *
   8 * redistribute it and/or modify it under the terms of the GNU General Public  *
   9 * License as published by the Free Software Foundation; either version 2 of   *
  10 * the License or (at your option) any later version.  This is online at:      *
  11 *     http://www.fsf.org/copyleft/gpl.html                                    *
  12 * Please send any updates to: fred@gruntose.com                               *
  13 \*****************************************************************************/
  14
  15 #include "spocket_tester.h"
  16
  17 #include <basis/byte_array.h>
  18 #include <basis/functions.h>
  19 #include <basis/astring.h>
  20 #include <loggers/critical_events.h>
  21 #include <loggers/program_wide_logger.h>
  22 #include <mathematics/chaos.h>
  23 #include <sockets/internet_address.h>
  24 #include <sockets/raw_socket.h>
  25 #include <sockets/spocket.h>
  26 #include <sockets/tcpip_definitions.h>
  27 #include <sockets/tcpip_stack.h>
  28 #include <timely/time_control.h>
  29 #include <timely/time_stamp.h>
  30
  31 #include <errno.h>
  32
  33 using namespace basis;
  34 using namespace loggers;
  35 using namespace mathematics;
  36 using namespace sockets;
  37 using namespace structures;
  38 using namespace textual;
  39 using namespace timely;
  40
  41 #define LOG(to_print) EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
  42
  43 const int MAXIMUM_WINSOCK_MTU = 100000;
  44   // the largest chunk of bytes we will receive at one time.
  45
  46 const int MAXIMUM_TRANSFER_WAIT = 40 * SECOND_ms;
  47   // the longest amount of time we wait in trying to receive data.
  48
  49 static abyte receive_buffer[MAXIMUM_WINSOCK_MTU + 1];
  50   // used for dumping received data into.
  51
  52 const int PAUSE_TIME = 200;
  53   // the snooze interval when we encounter socket underflow or overflow.
  54
  55 //#define DEBUG_SPOCKET_TESTER
  56   // uncomment for noisy version.
  57
  58 spocket_tester::spocket_tester(const internet_address &where)
  59 : _where(new internet_address(where)),
  60   _stack(new tcpip_stack),
  61   _socket(NIL),
  62   _root_server(NIL),
  63   _raw(new raw_socket)
  64 {
  65 }
  66
  67 spocket_tester::~spocket_tester()
  68 {
  69   WHACK(_socket);
  70   WHACK(_root_server);
  71   WHACK(_stack);
  72   WHACK(_where);
  73   WHACK(_raw);
  74 }
  75
  76 bool spocket_tester::connect()
  77 {
  78   if (!_socket) {
  79     _socket = new spocket(*_where);
  80   }
  81   outcome ret = spocket::NO_CONNECTION;
  82   while (true) {
  83     ret = _socket->connect();
  84     if (ret == spocket::OKAY) break;
  85     if (ret != spocket::NO_CONNECTION) break;
  86     time_control::sleep_ms(100);
  87   }
  88   return ret == spocket::OKAY;
  89 }
  90
  91 bool spocket_tester::accept(bool wait)
  92 {
  93   if (!_root_server) {
  94     _root_server = new spocket(*_where);
  95   }
  96   if (_socket) {
  97     LOG("already have a socket for accept!");
  98     return true;
  99   }
 100   outcome ret = spocket::NO_CONNECTION;
 101   while (true) {
 102     ret = _root_server->accept(_socket, false);
 103     if (ret == spocket::OKAY) break;
 104     if (ret != spocket::NO_CONNECTION) break;
 105     if (!wait) return true;  // we tried to accept at least once.
 106     time_control::sleep_ms(100);  // snooze to avoid slamming with accepts.
 107   }
 108
 109   return ret == spocket::OKAY;
 110 }
 111
 112 bool spocket_tester::do_a_send(abyte *buffer, int size,
 113     testing_statistics &stats)
 114 {
 115   time_stamp start_time;
 116   int len_sent;
 117   time_stamp when_to_leave(MAXIMUM_TRANSFER_WAIT);
 118   outcome worked;
 119
 120 #ifdef DEBUG_SPOCKET_TESTER
 121   LOG("into do a send");
 122 #endif
 123
 124   while (time_stamp() < when_to_leave) {
 125     worked = _socket->send(buffer, size, len_sent);
 126     if (worked == spocket::NONE_READY) {
 127 ////      time_control::sleep_ms(PAUSE_TIME);
 128       _socket->await_writable(PAUSE_TIME);
 129       continue;
 130     } else if (worked == spocket::PARTIAL) {
 131 //danger danger if we get wrong info.
 132       buffer += len_sent;
 133       size -= len_sent;
 134       stats.bytes_sent += len_sent;
 135 ///      time_control::sleep_ms(PAUSE_TIME);
 136       _socket->await_writable(PAUSE_TIME);
 137       continue;
 138     } else break;
 139   }
 140 #ifdef DEBUG_SPOCKET_TESTER
 141   LOG("got out of loop");
 142 #endif
 143
 144   stats.send_time += int(time_stamp().value() - start_time.value());
 145   stats.bytes_sent += len_sent;
 146
 147   if ( (worked != spocket::OKAY) && (worked != spocket::PARTIAL) ) {
 148     LOG(astring("No data went out on the socket: ")
 149         + spocket::outcome_name(worked));
 150     return false;
 151   }
 152   if (len_sent != size) {
 153     LOG(a_sprintf("partial send on socket, %d bytes instead of %d, recurse.",
 154         len_sent, size));
 155     return do_a_send(buffer + len_sent, size - len_sent, stats);
 156   }
 157
 158   time_stamp end_time;
 159 //  int time_taken = int(end_time.value() - start_time.value());
 160
 161   return true;
 162 }
 163
 164 bool spocket_tester::do_a_receive(int size_expected, testing_statistics &stats)
 165 {
 166   time_stamp start_time;
 167
 168 #ifdef DEBUG_SPOCKET_TESTER
 169   LOG("into do a rcv");
 170 #endif
 171
 172   time_stamp when_to_leave(MAXIMUM_TRANSFER_WAIT);
 173   int full_length = 0;
 174   while ( (full_length < size_expected) && (time_stamp() < when_to_leave) ) {
 175     time_stamp start_of_receive;
 176     int len = MAXIMUM_WINSOCK_MTU;
 177     outcome ret = _socket->receive(receive_buffer, len);
 178     if (ret != spocket::OKAY) {
 179       if (ret == spocket::NONE_READY) {
 180 if (len != 0) LOG(a_sprintf("supposedly nothing was received (%d bytes)", len));
 181         _socket->await_readable(PAUSE_TIME);
 182         continue;
 183       } else break;
 184     }
 185     // reset our time if we've gotten good data.
 186     if (ret == spocket::OKAY)
 187       when_to_leave.reset(MAXIMUM_TRANSFER_WAIT);
 188
 189     int receive_duration = int(time_stamp().value()
 190         - start_of_receive.value());
 191     stats.receive_time += receive_duration;
 192
 193 #ifdef DEBUG_SPOCKET_TESTER
 194     LOG(a_sprintf("did recv, len=%d", len));
 195 #endif
 196
 197     if (!len) {
 198       LOG("Our socket has been disconnected.");
 199       return false;
 200     } else if (len < 0) {
 201       if (errno == SOCK_EWOULDBLOCK) continue;  // no data.
 202       LOG(astring("The receive failed with an error ")
 203           + critical_events::system_error_text(errno));
 204       return false;
 205     }
 206     full_length += len;
 207     stats.bytes_received += len;
 208   }
 209
 210   if (full_length != size_expected)
 211     LOG(a_sprintf("Did not get the full size expected (wanted %d and "
 212         "got %d bytes).", size_expected, full_length));
 213
 214   return true;
 215 }
 216
 217 bool spocket_tester::perform_test(int size, int count,
 218     testing_statistics &stats)
 219 {
 220   // the statics are used to generate our random buffer for sending.
 221   static abyte garbage_buffer[MAXIMUM_WINSOCK_MTU + 1];
 222   static bool garbage_initialized = false;
 223   chaos randomizer;
 224
 225   // if our static buffer full of random stuff was never initialized, we do
 226   // so now.  this supports efficiently re-using the tester if desired.
 227   if (!garbage_initialized) {
 228     // note the less than or equal; we know we have one more byte to fill.
 229     for (int i = 0; i <= MAXIMUM_WINSOCK_MTU; i++)
 230       garbage_buffer[i] = randomizer.inclusive(0, 255);
 231     garbage_initialized = true;
 232   }
 233
 234   // reset the statistical package.
 235   stats.total_runs = 0;
 236   stats.send_time = 0;
 237   stats.receive_time = 0;
 238   stats.bytes_sent = 0;
 239   stats.bytes_received = 0;
 240
 241   // check that they aren't trying to do too big of a send.
 242   if (size > MAXIMUM_WINSOCK_MTU) {
 243     LOG("The size is over our limit.  To fix this, edit the "
 244         "send_data function.");
 245     return false;
 246   }
 247
 248   // check that our socket is usable.
 249   if (!_socket) {
 250     LOG("One cannot send data on an uninitialized tester!");
 251     return false;
 252   }
 253
 254   int runs_completed = 0;
 255     // counts up how many times we've done our test cycle.
 256
 257   while (runs_completed < count) {
 258 #ifdef DEBUG_SPOCKET_TESTER
 259     LOG(a_sprintf("iter %d", runs_completed));
 260 #endif
 261     if (_socket->client()) {
 262       // we're doing the client side routine here.
 263       time_stamp trip_start;
 264 #ifdef DEBUG_SPOCKET_TESTER
 265       LOG("client about to send");
 266 #endif
 267       if (!do_a_send(garbage_buffer, size, stats)) {
 268         LOG("We failed on a send.  Now quitting.");
 269         return false;
 270       }
 271 #ifdef DEBUG_SPOCKET_TESTER
 272       LOG("client about to rcv");
 273 #endif
 274       if (!do_a_receive(size, stats)) {
 275         LOG("We failed on a receive.  Now quitting.");
 276         return false;
 277       }
 278       stats.round_trip_time += int(time_stamp().value() - trip_start.value());
 279     } else {
 280       // we're doing the server side routine here.
 281       time_stamp trip_start;
 282 #ifdef DEBUG_SPOCKET_TESTER
 283       LOG("server about to rcv");
 284 #endif
 285       if (!do_a_receive(size, stats)) {
 286         LOG("We failed on a receive.  Now quitting.");
 287         return false;
 288       }
 289 #ifdef DEBUG_SPOCKET_TESTER
 290       LOG("server about to send");
 291 #endif
 292       if (!do_a_send(garbage_buffer, size, stats)) {
 293         LOG("We failed on a send.  Now quitting.");
 294         return false;
 295       }
 296       stats.round_trip_time += int(time_stamp().value() - trip_start.value());
 297     }
 298
 299     runs_completed++;  // finished a run.
 300     stats.total_runs++;  // count it in the overall stats too.
 301     if ( !(runs_completed % 10) )
 302       LOG(a_sprintf("Completed test #%d.", runs_completed));
 303   }
 304
 305   return true;
 306 }
 307