balcli.cpp

/*
   Cabal - balcli
   Short description

   $Id: balcli.cpp,v 1.3 2004/03/29 14:47:55 jonnymind Exp $
---------------------------------------------
   Begin      : lun mar 29 2004 02:17:23
   Author     : Giancarlo Niccolai <gc@niccolai.ws>, (C) 2004

   Last modified because:

*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/
   
// currently we use a very relaxed modality of direct socket rw;
// clients can use channels/lines as server does, but I am in a hurry...

#include "balser.h"
#include <list>

#define DEFAULT_PORT       2051
#define DEFAULT_IP         "127.0.0.1"

using namespace std;
using namespace Cabal;

class pkt_account 
{
public:
   pkt_account( MSECS t, int l )
   {
      arr_time = t;
      length = l;
   }
   
   MSECS arr_time;
   int length;
};

list< pkt_account> accountList;

void calcBandwidth( double &immediate, double &mean )
{
   double totalSec = 0.0;
   double totalTime = 0.0;
   double totalData = 0.0;
   
   list< pkt_account>::iterator iter = accountList.begin();
   MSECS now = iter->arr_time;
   
   int size = 0;
   while( iter != accountList.end() )
   {   
      if ( iter->arr_time > now - 1000 ) {
         totalSec += iter->length;
      }
      totalData += iter->length;
      // I should get only the last one, but I am lazy :-)
      totalTime = iter->arr_time;
      iter++;
      size++;
   }
   
   immediate = totalSec;
   if ( (now - totalTime) > 0 ) 
      mean = totalData / ( now - totalTime ) * (size-1)/(size) *1000.0;
   else
      mean = 0;
}

void communicate( UDPSocket &skt, unsigned long userId, Address &remote, PACKET *pkt )
{
   MSECS lastTime;
   
   do { // at first loop, process connection packet
      lastTime = Net::timeOfDay();
      // finally, we can account a correct packet.
      accountList.push_front( pkt_account( lastTime, sizeof( PACKET ) ) ); // we only get this length
      // and write the means
      double instant, mean;
      calcBandwidth( instant, mean );
      cout << "\r" << instant << "b/sec " << mean << "b/sec ";
      
      unsigned char check = static_cast<unsigned char>( pkt->id );
      bool correct = true;
      for( int pos = 0; pos < sizeof( pkt->data ); pos ++ )
      {
         if ( static_cast<unsigned char>(pkt->data[pos]) != check ) {
            correct = false;
            break;
         }
      }
            
      // if not correct, ask fro resend.
      CLI_REQ *req = reinterpret_cast<CLI_REQ *>(pkt->data);
      if ( ! correct )
      {
         req->type = REQ_TYPE_RESEND;
         req->value = pkt->id;
         // display bandwidth
         cout <<"!" <<flush;
      }
      else {
         req->type = REQ_TYPE_ACK;
         req->value = pkt->id;
      }
      
      for ( int i = 0; i < accountList.size(); i ++ )
         // display bandwidth
         cout <<"#";
      
      cout << flush;
      
      //lower timeout to send
      skt.timeout( 250 );
      int retval = 0;
      // insist
      // echoes using the pakcet provided timestamp.
      retval = skt.sendTo( pkt, CLIENT_REP_SIZE, remote );
      if ( retval <= 0 ) {
         cout << "Error on socket " << skt.osError() << ": " <<
               Net::errorDescription( skt.osError() ) << endl;
            return;
      }
      
      skt.timeout( 2500 );
      while ( lastTime + 2500 > Net::timeOfDay() ) 
      {
         retval = skt.recv( pkt, 1500 );
         if ( retval > 0 ) {
            if ( skt.remote() != remote ) {
               cout << "Received unexpected traffic from " << remote.ip() << ":" << remote.port() << endl;
            }
            else if ( retval != sizeof( PACKET ) || pkt->userId != userId ) {
               cout << "Received spurious " << retval << " bytes from " << remote.ip() << ":" << remote.port() << endl;
            }
            else 
               break;
         }
         else if (retval < 0 )
         {
            cout << "Error on socket " << skt.osError() << ": " <<
               Net::errorDescription( skt.osError() ) << endl;
            return;
         }
      }
      
      if ( retval == 0 ) {
         cout << "Server transmission timed out " << endl;
         return;
      }      
   } while( pkt->id != END_CONNECT );
      
}
         
         
      
      
int main ( int argc, char *argv[] )
{
   int n_port;
   char *c_ip;

   if ( argc == 3 ) {
      c_ip = argv[1];
      n_port = atoi( argv[2] );
   }
   else if ( argc == 2 ) {
      c_ip = DEFAULT_IP;
      n_port = atoi( argv[1] );
   }
   else {
      c_ip = DEFAULT_IP;
      n_port = DEFAULT_PORT;
   }

   
   try {
      bool connected;
      char buffer[1500];
      PACKET *pkt = reinterpret_cast< PACKET *>( buffer );
      
      Net::init();
      UDPSocket skt;
      Address remote( c_ip, n_port ), incoming;
      
      skt.timeout( 2500 );
      cout << "Sending UDP connection request." << endl;
      pkt->userId = START_CONNECT;
      
      connected = false;
      
      for ( int tries = 0; tries < 3; tries ++ ) 
      {
         if ( skt.sendTo( pkt, CLIENT_REP_SIZE, remote ) != CLIENT_REP_SIZE )
         {
            cout << "Error on first send " << skt.osError() << ": " <<
               Net::errorDescription( skt.osError() ) << endl;
            break;
         }
         
         int recvd = skt.recvFrom( pkt, 1500, incoming );
         if ( recvd < 0 ) {
            cout << "Error on first recv " << skt.osError() << ": " <<
               Net::errorDescription( skt.osError() ) << endl;
            break;
         }
         else if ( recvd == 0 ) {
            cout << "Timedout wihile waiting. Resending." << endl;
            continue;
         }
         else if ( recvd < sizeof( PACKET ) )
         {
            cout << "Received spurious data." <<endl;
         }
         else if ( incoming != remote ) {
            cout << "Received different traffic source: " << incoming.ip() << endl;
         }
         else {
            cout << "Begin of transmissions." << endl;
            connected = true;
            break;
         }
            
      }
      
      if ( connected )
      {
         communicate( skt, pkt->userId, remote, pkt );
      }
      
      skt.close();
      cout << endl << "Done" << endl;
      Net::exit();
   }
   catch (Error e ) {
      cout << e <<"\n";
   }

   return 0;
}

/* end of balcli */

---