channel.cpp

/*
   CABAL - CAched BAlanced LAN
   Test for cached channel based server

   (single thread version)

   $Id: channel.cpp,v 1.3 2004/03/26 22:45:11 jonnymind Exp $
---------------------------------------------
   Begin      :
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#include <cabal.h>

// This is just a test: we are using a rough way to use windows or unix timings.
#include <time.h>
#include <stdlib.h>

#define DEFAULT_PORT       2051

using namespace std;
using namespace Cabal;

/**********************************************************************
* To demonstrate caching abilities, we need a recetption class. Very
* basic here:
***********************************************************************/
class DflReception: public Reception
{
   int m_number;
   Line *m_line;

public:
   DflReception( const int number, Line *line ) {
      m_number = number;
      m_line = line;
   }

   virtual void init( Socket *skt ) { 
      cout << "Receiver " << m_number << " waiting " << skt->remote_ip() <<":" << skt->remote_port() << endl;
   }
      
   virtual bool receive( Socket *skt );
   
   virtual void terminate( Socket *skt );
   
};

 
void DflReception::terminate( Socket *skt )
{
   cout << "Receiver "<< m_number << " is destroyed";
   // possibly, this is because of an error on the socket.
   if ( skt->osError() != 0 )
      cout << " because of socket error " << skt->osError();
   // or because the socket has been cleanly closed.
   else if ( skt->closed() )
      cout << " because of socket closed by other side";
   
   cout << "." << endl;
   
   // destroy all the connections with the client;
   // notice, if this has been done in receive with the quit command,
   // this code does nothing (delete 0 is ansi c++)
   delete m_line;
   m_line = 0; // overkill but you never know...
}
         
bool DflReception::receive( Socket *skt )
{
   char buffer[1501];   
   int length = skt->recv( buffer, 1500 );

   cout << "R" << m_number <<": received " << length << " bytes from " <<
         skt->remote_ip() << endl;

   buffer[length] = '\0';
   cout << "Data: " << buffer << endl;

   if ( strncmp( "quit", buffer,4 ) == 0 || length == 0) {
      // destroy all the connections with the client
      cout << "R" << m_number <<": terminating on request/disconnection " <<endl;
      delete m_line;
      m_line = 0;
      return false;
   }
      
   return true;
}


/**********************************************************************
* We also need a transmission class to provide client with some random
* fuzz.... as we were transmitting them...
***********************************************************************/

class DflTransmit: public Transmission
{
   int m_number;
   int m_timeout;
   int m_greeting;
   Connection *m_con;
public:
   DflTransmit( int number, int to ) {
      m_number = number;
      m_timeout = to;
      m_greeting = 0;
   }

   virtual void init( Connection *con ) { cout << "Transmission " << m_number << " started" << endl; }
   virtual bool transmit( Connection *con );
   virtual void terminate( Connection *con ) {
      cout << "Transmission " << m_number << " terminated on socket status " << con->socket()->osError() <<endl;
   }
   
};

bool DflTransmit::transmit( Connection * con )
{

   char buffer[256];
   Socket *skt = con->socket();

   if ( skt->osError() ) {
      cout << "Transmitter found error " << skt->osError() << " on socket" << endl;
      return false; // self-destruction
   }
   
   // or because the socket has been cleanly closed.
   if ( skt->closed() ) 
   {
      cout << "Transmitter found socket closed." <<endl;
      return false;
   }

   // ready to send data:
   if ( m_greeting == 0 ) {
      sprintf( buffer, "Welcome in CABAL demo\r\n" );
      m_greeting++;
   }
   else
      sprintf( buffer, "A random string from %d: %d\r\n", m_number, rand() );
      
   int len = strlen( buffer );
   len = skt->send( buffer, len );
   
   if ( len > 0 ) {
      // all fine, rescheduling
      con->account( len );
      con->schedule( m_timeout * 1000 );
      return true;
   }
   else {
      cout << "Transmitter had error in sending: " << skt->osError() << " on socket" << endl;
      return false; // self-destruction
   }
}

/*******************************************************************
* Main procedure: create a server that accepts incoming connections
* and produces a cacher for each new socket.
* Cachers are destroyed as remote connections are closed.
********************************************************************/

int main ( int argc, char *argv[] )
{
   Net::init();
   int n_port;
   Channel *channel;

   if ( argc > 1 ) {
      n_port = atoi( argv[1] );
   }
   else {
      n_port = DEFAULT_PORT;
   }

   srand( static_cast<long>(time(0)) );

   // creates a channel for our server socket;
   channel = new Channel();

   try {
      ServerSocket ss( "0.0.0.0", n_port );
      Socket *s;

      cout << "Server waiting on port "<< n_port << endl;
      // setting timeout to 0 (don't stop, immediate timeout)
      ss.timeout( 0 );
      int num = 0;

      while ( true ) {

         s = ss.accept();

         // has a new connection come on board?
         while ( s != NULL ) {
            cout << "Connection from: " << s->remote_ip() << ":" <<
                  s->remote_port() << "\n";

            Line *line = new Line(0);            
            
            num++;
            DflTransmit *trans = new DflTransmit( num, 2 + rand()/(RAND_MAX/5));
            DflReception *rec = new DflReception( num, line );

            s->channel( channel, rec );
            Connection *con = new Connection( s, trans );
            line->set( "default", con );
            // immediately prepare to send the first message
            con->schedule( 0 );
            // releasing MY reference to the socket; now the channel is the owner.
            s->decref();
            
            //s = ss.accept();  // continue accepting.ù
            s = NULL;
         }

         // sleep 1/4th of seconds
         bool res = channel->process( 250 );
         // and continue while there is data to be processed
         while( res ) res = channel->process( 0 );
      }

   }
   catch (Error e ) {
      cout << e <<"\n";
   }
   Net::exit();

   return 0;
}

---