ListenServer.cpp

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

/*
    mySocket, ListenServer
    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 <sys/param.h> // MAXHOSTNAMELEN
#include <ListenServer.h>
#include <SocketHandler.h>
#include <IncomingSocket.h>
#include <StringLib.h>

using namespace std;
using namespace StringLib;

// Constructor
ListenServer::ListenServer() : Socket(-1) {

  running = false;
  port = -1;
  addr = "";

  }

// Destructor
ListenServer::~ListenServer() {

  }

// Try to socket(), bind(), listen()
void ListenServer::Start(int _port, string _addr, SocketType _type){

  if(_type != TYPE_TCP) throw 0; // only TCP supported, yet
  type = _type;

  if(running) throw SocketException(ALREADY_RUNNING);

  try{

    Bind(_addr, _port);
    Listen(backlog);

    }

  catch(SocketException e) { // needs to be replaced

    switch(e.i){
      case SOCKET_FAILED:
        error("Socket failed: " + GetLastError());
        break;
      case BIND_FAILED:
        error("Bind failed: " + GetLastError());
        break;
      case LISTEN_FAILED:
        error("Listen failed: " + GetLastError());
        break;
      default:
        error("Unknown Exception!");
      }
    return;

    }

  SocketHandler* handler = SocketHandler::getInstance();
  if(!handler) throw SocketException(SOCKETHANDLING_FAILED);

  handler -> Add(this);
  port = _port;
  addr = _addr;
  running = true;

  debug("Starting listening on " + GetAddr() + ":" + itos(GetPort()));
  
  }

// Another way to start  
void ListenServer::Start(sockaddr_in _saddr, SocketType _type){

  Start(ntohs(_saddr.sin_port), (string) inet_ntoa(_saddr.sin_addr), _type);

  }

void ListenServer::Stop(){

  if(!running) throw SocketException(NOT_RUNNING);

  SocketHandler* handler = SocketHandler::getInstance();
  if(!handler) throw SocketException(SOCKETHANDLING_FAILED);

  IncomingSocket* incoming;

  for(int i=0; i < handler -> l_read -> size(); i++){ // stopping all children

    incoming = dynamic_cast<IncomingSocket*>(handler -> l_read -> get(i));

    if(incoming -> GetParent() == this){

      incoming -> Close();
      handler -> Remove(incoming);
      i--;

      }

    }

  Close();
  handler -> Remove(this);
  memset(&saddr, 0, sizeof(saddr));
  running = false;
  port = -1;
  addr = "";

  }


void ListenServer::OnAccept(){

// incomplete UDP support
  if(type == TYPE_UDP){

    sockaddr_in sa;
    socklen_t sa_len;
    char buffer[65536];
    int ret = recvfrom(GetSock(),buffer,65536,0,(sockaddr*)&sa,&sa_len);

    out((string)"UDP SOCKET FROM " + inet_ntoa(sa.sin_addr) + ":" + itos(htons(sa.sin_port)) + " -> " + buffer);

    return;  
    }

  __OnAccept();

  }
  
int ListenServer::Accept(sockaddr_in &_saddr){

  if(!running) throw SocketException(NOT_RUNNING);

  socklen_t tmpsize = sizeof(saddr);
#ifdef _WIN32
  socket_t ret = accept(GetSock(), (SOCKADDR*) &_saddr, &tmpsize);
#else
  socket_t ret = accept(GetSock(), (sockaddr *) &_saddr, &tmpsize);
#endif

  if(ret == -1) throw SocketException(ACCEPT_FAILED);

  return ret;

  }

void ListenServer::OnAcceptFailed(){

//   if(!running) throw SocketException(NOT_RUNNING); ???
  
  __OnAcceptFailed();

  }

void ListenServer::__OnAccept(){

  struct sockaddr_in _saddr;
  int ret = Accept(_saddr); // accept any connection

  IncomingSocket* IS = new IncomingSocket(ret, _saddr, this);

  SocketHandler* handler = SocketHandler::getInstance();
  if(!handler) throw SocketException(SOCKETHANDLING_FAILED);
  handler -> Add(IS);

  }


// Bind to a port
void ListenServer::Bind(string host, int port){ // SocketType needs to be implemented

  addr = host;
  memset(&saddr, 0, sizeof(saddr));
  saddr.sin_family = AF_INET;
  saddr.sin_port = htons(port);

  if(host == ""){
  
    saddr.sin_addr.s_addr = INADDR_ANY;
  
    }else{
        
//  static char myhostname[MAXHOSTNAMELEN+1];
//  gethostname(myhostname, MAXHOSTNAMELEN);

    saddr.sin_addr.s_addr = inet_addr(host.c_str());

        }

  Bind();

  }

// Do the binding
void ListenServer::Bind(){

  MakeSock();

  if(setsockopt(GetSock(), SOL_SOCKET, SO_REUSEADDR, "1", sizeof(int)) == -1)
    throw SocketException(BIND_FAILED);

  int ret = bind(GetSock(), (sockaddr*) &saddr, sizeof(saddr));

  if(ret < 0) throw SocketException(BIND_FAILED);

//  WSACleanup(); -> when?

  }

// Listen on a port
void ListenServer::Listen(int opt){

  if(GetSock() == -1) throw SocketException(BIND_FIRST);

  int conn = listen(GetSock(), opt);

  if(conn == -1) throw SocketException(LISTEN_FAILED);

  }