src/dashserver/server.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                      *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "server.h"
  22 #include "connection.h"
  23
  24 #include <QHostInfo>
  25 #include <QTimer>
  26 #include <QQueue>
  27 #include <QHostAddress>
  28
  29 #include <dcore/debug.h>
  30
  31 #include "packagehandlerbase.h"
  32 #include "defaultpackagehandler.h"
  33
  34 #include "bans/banmanager.h"
  35 #include "backups/backupmanager.h"
  36 #include "users/usermanager.h"
  37
  38 #include "registers/regmanager.h"
  39 #include "project/projectmanager.h"
  40
  41 #include "package.h"
  42 #include "observer.h"
  43 #include "logger.h"
  44
  45 #include <dash/network/socket.h>
  46
  47 using namespace Dash::Network;
  48
  49 namespace DashServer {
  50
  51 class TcpServer::Private
  52 {
  53         public:
  54                 QSet<DashServer::Connection *> connections;
  55                 QSet<DashServer::Connection *> admins;
  56
  57                 Backups::Manager *backupManager;
  58                 Bans::Manager *banManager;
  59                 Users::Manager *userManager;
  60
  61                 QList<DashServer::Observer *> observers;
  62 };
  63
  64 TcpServer::TcpServer(QObject *parent) : QTcpServer(parent), d(new Private)
  65 {
  66         D_INIT;
  67         d->backupManager = new Backups::Manager;
  68         d->observers << d->backupManager;
  69
  70         d->banManager = new Bans::Manager;
  71         d->observers << d->banManager;
  72
  73         d->userManager = new Users::Manager;
  74         d->observers << d->userManager;
  75
  76         addObserver(new DashServer::Project::Manager);
  77 }
  78
  79
  80 TcpServer::~TcpServer()
  81 {
  82         D_END;
  83
  84         DashServer::Logger::self()->info("DashServer finished");
  85
  86         qDebug("=> Deleting observers");
  87         qDeleteAll(d->observers);
  88
  89         qDebug("=> Deleting connections");
  90         foreach(DashServer::Connection *cnn, d->connections)
  91         {
  92                 removeConnection(cnn);
  93         }
  94
  95         delete d;
  96 }
  97
  98 bool TcpServer::openConnection(const QString &host, int port)
  99 {
 100         DashServer::Logger::self()->info(QObject::tr("Initialized server on %1:%2").arg(host).arg(port));
 101
 102         QList<QHostAddress> addrs = QHostInfo::fromName(host).addresses();
 103         if ( !addrs.isEmpty() )
 104         {
 105                 if(! listen(QHostAddress(addrs[0]), port) )
 106                 {
 107                         dError() << "Can't connect to " << host<<":"<<port<< " error was: " << errorString();
 108                         return false;
 109                 }
 110         }
 111         else
 112         {
 113                 dError() << "Error while try to resolve " << host;
 114                 return false;
 115         }
 116         return true;
 117 }
 118
 119 void TcpServer::addAdmin(DashServer::Connection *cnx)
 120 {
 121         d->admins << cnx;
 122 }
 123
 124 Backups::Manager *TcpServer::backupManager() const
 125 {
 126         return d->backupManager;
 127 }
 128
 129 Bans::Manager *TcpServer::banManager() const
 130 {
 131         return d->banManager;
 132 }
 133
 134 Users::Manager *TcpServer::userManager() const
 135 {
 136         return d->userManager;
 137 }
 138
 139 void TcpServer::addObserver(DashServer::Observer *observer)
 140 {
 141         d->observers << observer;
 142 }
 143
 144 bool TcpServer::removeObserver(DashServer::Observer *observer)
 145 {
 146         return d->observers.removeAll(observer) > 0;
 147 }
 148
 149 void TcpServer::incomingConnection(int socketDescriptor)
 150 {
 151         D_SHOW_VAR(d->connections.count());
 152         D_SHOW_VAR(socketDescriptor);
 153
 154         DashServer::Connection *newConnection = new DashServer::Connection(socketDescriptor,this);
 155
 156         QString ip = newConnection->client()->peerAddress().toString();
 157         d->banManager->initialize(ip);
 158
 159         if ( !d->banManager->isBanned(ip) )
 160         {
 161                 handle(newConnection);
 162                 d->connections << newConnection;
 163         }
 164         else
 165         {
 166                 connect(newConnection, SIGNAL(finished()), newConnection, SLOT(deleteLater()));
 167                 newConnection->sendError(tr("You're banned, Please contact to server administrator if you think is an error!"), Dash::Network::Package::Error::Err);
 168         }
 169 }
 170
 171 void TcpServer::handle(DashServer::Connection *cnx)
 172 {
 173         connect(cnx, SIGNAL(requestSendToAll( const QString& )), this, SLOT(sendToAll( const QString& )));
 174
 175         connect(cnx, SIGNAL(packageReaded(DashServer::Connection*, const QString&, const QString&)), this, SLOT(handlePackage(DashServer::Connection*, const QString&, const QString&)));
 176
 177         connect(cnx, SIGNAL(connectionClosed(DashServer::Connection*)), this, SLOT(removeConnection(DashServer::Connection*)));
 178 }
 179
 180
 181 void TcpServer::sendToAll(const QString &msg)
 182 {
 183         foreach(DashServer::Connection *connection, d->connections)
 184         {
 185                 connection->sendToClient(msg, false);
 186         }
 187 }
 188
 189 void TcpServer::sendToAll(const QDomDocument &pkg)
 190 {
 191         D_FUNCINFO;
 192         sendToAll(pkg.toString(0));
 193 }
 194
 195 void TcpServer::sendToAdmins(const QString &str)
 196 {
 197         foreach(DashServer::Connection *cnn, d->admins)
 198         {
 199                 cnn->sendToClient(str, false);
 200         }
 201 }
 202
 203 void TcpServer::removeConnection(DashServer::Connection *cnx)
 204 {
 205         D_FUNCINFO;
 206
 207         if( ! cnx ) return;
 208
 209         if( !d->connections.contains(cnx) ) return;
 210
 211         d->connections.remove(cnx);
 212         d->admins.remove(cnx);
 213
 214         foreach(DashServer::Observer *observer, d->observers)
 215         {
 216                 observer->connectionClosed(cnx);
 217         }
 218
 219         cnx->blockSignals(true);
 220         cnx->close();
 221         cnx->blockSignals(false);
 222
 223         if( !cnx->isRunning() )
 224         {
 225                 cnx->deleteLater();
 226         }
 227         else
 228         {
 229                 connect(cnx, SIGNAL(finished()), cnx, SLOT(deleteLater()));
 230                 cnx->terminate();
 231         }
 232 }
 233
 234
 235 void TcpServer::handlePackage(DashServer::Connection* client, const QString &root, const QString&package)
 236 {
 237         DashServer::Package *pkg = new DashServer::Package(root, package, client);
 238
 239         foreach(DashServer::Observer *observer, d->observers)
 240         {
 241                 observer->handlePackage(pkg);
 242
 243                 if ( pkg->isAccepted() )
 244                         break;
 245         }
 246
 247         if( ! pkg->isAccepted() )
 248                 qWarning() << "NOT ACCEPTED: " << pkg->root();
 249
 250         delete pkg;
 251
 252         client->process();
 253 }
 254
 255
 256 }
 257
 258