Server/src/tcpserver.cpp

   1 // vim: set noexpandtab tabstop=4 shiftwidth=4:
   2 //----------------------------------------------------------------------------
   3 //                                  PlaQui
   4 //----------------------------------------------------------------------------
   5 // This file is part of PlaQui.
   6 //
   7 // PlaQui is free software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the Free Software
   9 // Foundation; either version 2 of the License, or (at your option) any later
  10 // version.
  11 //
  12 // PlaQui is distributed in the hope that it will be useful, but WITHOUT ANY
  13 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15 // details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with PlaQui; if not, write to the Free Software Foundation, Inc., 59 Temple
  19 // Place, Suite 330, Boston, MA  02111-1307  USA
  20 //----------------------------------------------------------------------------
  21 // Creado:  Sat Oct 18 18:18:36 2003
  22 // Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23 //----------------------------------------------------------------------------
  24 //
  25 // $Id$
  26 //
  27
  28 #include "plaqui/server/tcpserver.h"
  29 #include <sigc++/class_slot.h>
  30 #include <glibmm/timer.h>
  31 #ifdef DEBUG
  32 #       include <iostream>
  33 #endif // DEBUG
  34
  35 using namespace std;
  36
  37 namespace PlaQui {
  38
  39 namespace Server {
  40
  41 TCPServer::~TCPServer(void) {
  42 #ifdef DEBUG
  43         cerr << __FILE__ << "(" << __LINE__ << ")"
  44                 <<  ": destructor." << endl;
  45 #endif // DEBUG
  46         // Mando a terminar todas las conexiones.
  47         connections_mutex.lock();
  48         for (ConnectionList::iterator con = connections.begin();
  49                         con != connections.end(); con++) {
  50                 (*con)->finish();
  51         }
  52         ConnectionList::size_type count = connections.size();
  53         connections_mutex.unlock();
  54         // Espero que terminen realmente.
  55         while (count) {
  56                 Glib::usleep(10000); // 10 milisegundos
  57                 connections_mutex.lock();
  58                 count = connections.size();
  59                 connections_mutex.unlock();
  60         }
  61 }
  62
  63 TCPServer::TCPServer(const Connection::Port& port) throw(sockerr):
  64                 socket(sockbuf::sock_stream) {
  65 #ifdef DEBUG
  66         cerr << __FILE__ << "(" << __LINE__ << ")"
  67                 <<  ": port = " << port << endl;
  68 #endif // DEBUG
  69         socket.reuseaddr(true);
  70         socket.bind(port);
  71 #ifdef DEBUG
  72         cerr << __FILE__ << "(" << __LINE__ << ")"
  73                 <<  ": escuchando en " << socket.localhost()
  74                 << ":" << socket.localport() << "." << endl;
  75 #endif // DEBUG
  76         socket.listen(MAX_PENDING_CONNECTIONS);
  77 #ifdef DEBUG
  78         cerr << __FILE__ << "(" << __LINE__ << ")"
  79                 <<  ": [despues de listen()] escuchando en "
  80                 << socket.localhost() << ":" << socket.localport() << "." << endl;
  81 #endif // DEBUG
  82 }
  83
  84 void TCPServer::finish(void) {
  85 #ifdef DEBUG
  86         cerr << __FILE__ << "(" << __LINE__ << ")"
  87                 <<  ": finish(void);" << endl;
  88 #endif // DEBUG
  89         Runnable::finish();
  90         // Creo una conexión suicida para que el accept() del server retorne
  91         // el control y el server pueda terminar realmente.
  92         try {
  93                 sockinetbuf suicida(sockbuf::sock_stream);
  94                 suicida.connect(socket.localhost(), socket.localport());
  95         } catch (const sockerr& e) {
  96                 // FIXME mejorar codigos de error.
  97                 signal_error().emit(100000 + e.serrno(), string("No se pudo crear "
  98                                         "conexión 'suicida' para terminar el servidor: ")
  99                                         + e.errstr());
 100         }
 101 }
 102
 103 void TCPServer::on_connection_finished(Connection* connection) {
 104 #ifdef DEBUG
 105         cerr << __FILE__ << "(" << __LINE__ << ")"
 106                 <<  ": on_connection_finished(connection = "
 107                 << connection << ")" << endl;
 108 #endif // DEBUG
 109         Glib::Mutex::Lock lock(connections_mutex);
 110         connections.remove(connection);
 111 #ifdef DEBUG
 112         cerr << __FILE__ << "(" << __LINE__ << ")"
 113                 <<  ": lista de conexiones" << endl;
 114         for (ConnectionList::const_iterator i = connections.begin();
 115                         i != connections.end(); i++) {
 116                 cerr << "\t " << *i << endl;
 117         }
 118 #endif // DEBUG
 119 }
 120
 121 void TCPServer::real_run(void) throw() {
 122 #ifdef DEBUG
 123         cerr << __FILE__ << "(" << __LINE__ << ")"
 124                 <<  ": real_run()" << endl;
 125 #endif // DEBUG
 126         Connection* connection;
 127         while (!stop()) {
 128                 // Forma grasa de salir del accept: crear conexion que salga al toque.
 129                 try {
 130                         connection = new_connection(socket.accept());
 131                 } catch (const sockerr& e) { // No se si el accept() puede fallar.
 132                         signal_error().emit(e.serrno(),
 133                                         string("Error creando conexión nueva: ") + e.errstr());
 134                         continue; // Supongo que puede seguir aceptando conexiones.
 135                 }
 136                 if (!stop()) {
 137                         // Solo avisamos si la conexión que viene no es para matarnos.
 138                         _connection_opened(connection->get_host(), connection->get_port());
 139                 }
 140 #ifdef DEBUG
 141                 cerr << __FILE__ << "(" << __LINE__ << ")"
 142                         <<  ": real_run(): connection = " << connection
 143                         << endl;
 144 #endif // DEBUG
 145                 Glib::Mutex::Lock lock(connections_mutex);
 146                 connections.push_back(connection);
 147 #ifdef DEBUG
 148                 cerr << __FILE__ << "(" << __LINE__ << ")"
 149                         <<  ": real_run(): lista de conexiones" << endl;
 150                 for (ConnectionList::const_iterator i = connections.begin();
 151                                 i != connections.end(); i++) {
 152                         cerr << "\t " << *i << endl;
 153                 }
 154 #endif // DEBUG
 155                 // Conecto la señal para cuando termina una conexión, borrarla.
 156                 connection->signal_finished().connect(SigC::bind(
 157                                 SigC::slot_class(*this, &TCPServer::on_connection_finished),
 158                                 connection));
 159                 connection->run();
 160         }
 161 }
 162
 163 bool TCPServer::disconnect(const std::string& host, const Connection::Port& port) {
 164 #ifdef DEBUG
 165         cerr << __FILE__ << "(" << __LINE__ << ")"
 166                 <<  ": disconnect(host = " << host
 167                 << ", port = " << port << ")" << endl;
 168 #endif // DEBUG
 169         Glib::Mutex::Lock lock(connections_mutex);
 170         for (ConnectionList::iterator con = connections.begin();
 171                         con != connections.end(); con++) {
 172                 if (((*con)->get_host() == host) && ((*con)->get_port() == port)) {
 173                         (*con)->finish();
 174                         return true;
 175                 }
 176         }
 177         return false;
 178 }
 179
 180 /// \todo TODO Hay que reemplazarlo por una lista generica.
 181 TCPServer::ConnectionInfoList TCPServer::get_connected(void) {
 182 #ifdef DEBUG
 183         cerr << __FILE__ << "(" << __LINE__ << ")"
 184                 <<  ": get_connected()" << endl;
 185 #endif // DEBUG
 186         TCPServer::ConnectionInfoList cl;
 187         Glib::Mutex::Lock lock(connections_mutex);
 188         for (ConnectionList::const_iterator con = connections.begin();
 189                         con != connections.end(); con++) {
 190                 TCPServer::ConnectionInfo ci =
 191                         { (*con)->get_host(), (*con)->get_port() };
 192                 cl.push_back(ci);
 193         }
 194         return cl;
 195 }
 196
 197 TCPServer::SignalConnectionOpened& TCPServer::signal_connection_opened(void) {
 198         return _connection_opened;
 199 }
 200
 201 } // namespace Server
 202
 203 } // namespace PlaQui
 204