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         // FIXME
  70         //cerr << "recvtimeout = " << socket.recvtimeout(1) << endl;
  71         //cerr << "sendtimeout = " << socket.sendtimeout(1) << endl;
  72         //cerr << "recvtimeout = " << socket.recvtimeout(1) << endl;
  73         //cerr << "sendtimeout = " << socket.sendtimeout(1) << endl;
  74         socket.reuseaddr(true);
  75         socket.bind(port);
  76 #ifdef DEBUG
  77         cerr << __FILE__ << "(" << __LINE__ << ")"
  78                 <<  ": escuchando en " << socket.localhost()
  79                 << ":" << socket.localport() << "." << endl;
  80 #endif // DEBUG
  81         socket.listen(MAX_PENDING_CONNECTIONS);
  82 #ifdef DEBUG
  83         cerr << __FILE__ << "(" << __LINE__ << ")"
  84                 <<  ": [despues de listen()] escuchando en "
  85                 << socket.localhost() << ":" << socket.localport() << "." << endl;
  86 #endif // DEBUG
  87 }
  88
  89 /*void TCPServer::finish(bool attach) {
  90 #ifdef DEBUG
  91         cerr << __FILE__ << "(" << __LINE__ << ")"
  92                 <<  ": finish(attach = " << attach << ");" << endl;
  93 #endif // DEBUG
  94         //socket_mutex.lock();
  95         close(socket.sd());
  96         //socket.shutdown(sockbuf::shut_readwrite);
  97         //socket_mutex.unlock();
  98         Runnable::finish(attach);
  99 }*/
 100
 101 void TCPServer::on_connection_finished(Connection* connection) {
 102 #ifdef DEBUG
 103         cerr << __FILE__ << "(" << __LINE__ << ")"
 104                 <<  ": on_connection_finished(connection = "
 105                 << connection << ")" << endl;
 106 #endif // DEBUG
 107         Glib::Mutex::Lock lock(connections_mutex);
 108         connections.remove(connection);
 109 #ifdef DEBUG
 110         cerr << __FILE__ << "(" << __LINE__ << ")"
 111                 <<  ": lista de conexiones" << endl;
 112         for (ConnectionList::const_iterator i = connections.begin();
 113                         i != connections.end(); i++) {
 114                 cerr << "\t " << *i << endl;
 115         }
 116 #endif // DEBUG
 117 }
 118
 119 void TCPServer::real_run(void) throw() {
 120 #ifdef DEBUG
 121         cerr << __FILE__ << "(" << __LINE__ << ")"
 122                 <<  ": real_run()" << endl;
 123 #endif // DEBUG
 124         Connection* connection;
 125         while (!stop()) {
 126                 // Forma grasa de salir del accept: crear conexion que salga al toque.
 127                 try {
 128                         connection = new_connection(socket.accept());
 129                 } catch (const sockerr& e) { // No se si el accept() puede fallar.
 130                         signal_error().emit(e.serrno(), e.errstr());
 131                         continue; // Supongo que puede seguir aceptando conexiones.
 132                 }
 133 #ifdef DEBUG
 134                 cerr << __FILE__ << "(" << __LINE__ << ")"
 135                         <<  ": real_run(): connection = " << connection
 136                         << endl;
 137 #endif // DEBUG
 138                 Glib::Mutex::Lock lock(connections_mutex);
 139                 // XXX connections_mutex.lock();
 140                 connections.push_back(connection);
 141 #ifdef DEBUG
 142                 cerr << __FILE__ << "(" << __LINE__ << ")"
 143                         <<  ": real_run(): lista de conexiones" << endl;
 144                 for (ConnectionList::const_iterator i = connections.begin();
 145                                 i != connections.end(); i++) {
 146                         cerr << "\t " << *i << endl;
 147                 }
 148 #endif // DEBUG
 149                 // XXX connections_mutex.unlock(); // Si pongo el mutex antes del run(),
 150                 //                                    muere.
 151                 // Conecto la señal para cuando termina una conexión, borrarla.
 152                 connection->signal_finished().connect(
 153                                 SigC::bind<Connection*>(
 154                                         SigC::slot_class(*this,
 155                                                 &TCPServer::on_connection_finished),
 156                                         connection));
 157                 connection->run();
 158         }
 159 }
 160
 161 bool TCPServer::disconnect(const std::string& host, const Connection::Port& port) {
 162 #ifdef DEBUG
 163         cerr << __FILE__ << "(" << __LINE__ << ")"
 164                 <<  ": disconnect(host = " << host
 165                 << ", port = " << port << ")" << endl;
 166 #endif // DEBUG
 167         Glib::Mutex::Lock lock(connections_mutex);
 168         for (ConnectionList::iterator con = connections.begin();
 169                         con != connections.end(); con++) {
 170                 if (((*con)->get_host() == host) && ((*con)->get_port() == port)) {
 171                         (*con)->finish();
 172                         return true;
 173                 }
 174         }
 175         return false;
 176 }
 177
 178 /// \todo TODO Hay que reemplazarlo por una lista generica.
 179 TCPServer::ConnectionInfoList TCPServer::get_connected(void) {
 180 #ifdef DEBUG
 181         cerr << __FILE__ << "(" << __LINE__ << ")"
 182                 <<  ": get_connected()" << endl;
 183 #endif // DEBUG
 184         TCPServer::ConnectionInfoList cl;
 185         Glib::Mutex::Lock lock(connections_mutex);
 186         for (ConnectionList::const_iterator con = connections.begin();
 187                         con != connections.end(); con++) {
 188                 TCPServer::ConnectionInfo ci =
 189                         { (*con)->get_host(), (*con)->get_port() };
 190                 cl.push_back(ci);
 191         }
 192         return cl;
 193 }
 194
 195 } // namespace Server
 196
 197 } // namespace PlaQui
 198