SocketHandler.cpp

Ugrás a fájl dokumentációjához.

/*
    mySocket, SocketHandler
    Copyright (C) 2006  Kornel Csernai <csko@csko.hu>

    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 program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
#include <SocketHandler.h>
#include <ListenServer.h>
#include <RealSocket.h>
#include <ConnectSocket.h>
#include <IncomingSocket.h>
#include <Errors.h>
#include <StringLib.h>

using namespace StringLib;

// Constructor
SocketHandler::SocketHandler(){

  socknum = 0;
  maxFD = 0;
  
  l_write = new DoubleLinkedList<RealSocket*>();
  l_read = new DoubleLinkedList<Socket*>();

  }

// Destructor
SocketHandler::~SocketHandler(){

  delete l_write;
  delete l_read;

  }

// Do the socket cycling
void SocketHandler::Handle(){

  if(!HaveSockets()) return; // we ain't got no sockets

  fd_set tmp_read, tmp_write, tmp_except;
  FD_ZERO(&tmp_except);
  FD_ZERO(&tmp_read);
  FD_ZERO(&tmp_write);

  int i;

  // modified every time
  tv.tv_sec  = 0;
  tv.tv_usec = 500;

  RealSocket* real;

  for(i=0; i<l_write->size(); i++){

    real = dynamic_cast<RealSocket*>(l_write->get(i));
    if(!real) throw SocketException(CAST_FAILED);
    
    if(real -> GetWriteLen() > 0){

      FD_SET(real->GetSock(), &tmp_write);

      }

    FD_SET(real->GetSock(), &tmp_except);

  
    }

  for(i=0; i<l_read->size(); i++){

    FD_SET(l_read->get(i)->GetSock(), &tmp_except);
    FD_SET(l_read->get(i)->GetSock(), &tmp_read);
  
    }

  Socket* sock;
  ListenServer* listenserver;
  ConnectSocket* connectsocket;
  
  int size; // nubsag, remove-nal bugozhat

  int ret = select(maxFD + 1, &tmp_read, &tmp_write, &tmp_except, &tv);

  if(ret == -1){

    throw SocketHandlerException(SELECT_FAILED);

    }else if(ret > 0){

    size = l_read->size();
    // is there an exception?
    for(i=0; i<size; i++){

      if(FD_ISSET(l_read->get(i)->GetSock(), &tmp_except)){ // found exception

        real = dynamic_cast<RealSocket*>(l_read->get(i));

          if(real and (connectsocket = dynamic_cast<ConnectSocket*>(l_read->get(i)))
                     and connectsocket -> IsConnected() ){ // see if is it a connected RealSocket

          l_read->get(i) -> OnReadError();

          Remove(connectsocket);
          i--;

          FD_CLR(connectsocket->GetSock(), &tmp_except);
          FD_CLR(connectsocket->GetSock(), &tmp_read);
          FD_CLR(connectsocket->GetSock(), &tmp_write);

          }else if(listenserver = dynamic_cast<ListenServer*>(l_read->get(i))){ // see if it is a ListenServer
          
          listenserver -> OnAcceptFailed();

          Remove(listenserver);
          i--;

          FD_CLR(listenserver->GetSock(), &tmp_except);
          FD_CLR(listenserver->GetSock(), &tmp_read);
          
          }/*else if(dynamic_cast<IncomingSocket*>(l_read->get(i))){
          
          cout << l_read->get(i) << " inkomingszokit! " << endl;
//        sock -> OnConnectionError();
          
          }*/else if(connectsocket and !connectsocket->IsConnected()){ // never happens, yet

          connectsocket -> OnConnectionError();

          }
      
        }    

      }
    
    
    // can we write anywhere?
    size = l_write->size();
    for(i=0; i<size; i++){
    
      real = dynamic_cast<RealSocket*>(l_write->get(i));
//      if(!real) throw SocketException(CAST_FAILED);
      if(!real) continue;
    
      if(real -> GetWriteLen() > 0 and FD_ISSET(real -> GetSock(), &tmp_write)){
   
        real -> OnWrite();
      
        }
    
      }
    
    size = l_read->size();
    // can we read anything?
    for(i=0; i<size; i++){
    
      if(l_read->get(i) == NULL) {
      
        i++;
        continue;
        
        }
    
      if(FD_ISSET(l_read->get(i)->GetSock(), &tmp_read)){ // there's something to read
      
        if(real = dynamic_cast<RealSocket*>(l_read->get(i))){

          try {

            real -> OnRead();
          
            }

          catch(SocketException){
        
            Remove(connectsocket);
            i--;

            FD_CLR(connectsocket->GetSock(), &tmp_except);
            FD_CLR(connectsocket->GetSock(), &tmp_read);
            FD_CLR(connectsocket->GetSock(), &tmp_write);
        
            }

      }else if(listenserver = dynamic_cast<ListenServer*>(l_read->get(i))){

          try {

            listenserver -> OnAccept();
            i++;
            
            }

          catch(SocketException){
        
            listenserver -> OnAcceptFailed();

            }

          }
          
        }
    
      }

    }

  }

// Do we have any sockets?
bool SocketHandler::HaveSockets(){

  return socknum > 0;

  }

// Add Socket* to cycle
void SocketHandler::Add(Socket* sock){

  l_read -> add(sock);

  
  RealSocket* real = dynamic_cast<RealSocket*>(sock);

  if(real){ // if sock is not a ListenServer
  
    l_write -> add(real);
  
    }

  maxFD = maxFD >= sock -> GetSock() ? maxFD : sock->GetSock();
  debug("Socket added.");
  socknum++;

  }

// Remove Socket* from cycle
void SocketHandler::Remove(Socket* sock){

  l_read -> remove(sock);
  RealSocket* real = dynamic_cast<RealSocket*>(sock);

  if(real){ // if sock is not a ListenServer
  
    l_write -> remove(real);
  
    }

  debug("Removed socket. (" + itos(sock->GetSock()) + (string) ")");

  socknum--;

  }