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 "databaseobjectfactory.h"
  46 #include "xdbms/manager.h"
  47
  48 #include <dash/network/socket.h>
  49
  50 using namespace Dash::Network;
  51
  52 namespace DashServer {
  53
  54 class TcpServer::Private
  55 {
  56         public:
  57                 QSet<DashServer::Connection *> connections;
  58                 QSet<DashServer::Connection *> admins;
  59
  60                 Backups::Manager *backupManager;
  61                 Bans::Manager *banManager;
  62                 Users::Manager *userManager;
  63                 Project::Manager *projectManager;
  64
  65                 QList<DashServer::Observer *> observers;
  66 };
  67
  68 TcpServer::TcpServer(QObject *parent) : QTcpServer(parent), d(new Private)
  69 {
  70         D_INIT;
  71
  72         XDBMS::Manager::self()->setObjectFactory(new DatabaseObjectFactory);
  73
  74         d->backupManager = new Backups::Manager;
  75         d->observers << d->backupManager;
  76
  77         d->banManager = new Bans::Manager;
  78         d->observers << d->banManager;
  79
  80         d->userManager = new Users::Manager;
  81         d->observers << d->userManager;
  82
  83         d->projectManager = new DashServer::Project::Manager;
  84         d->observers << d->projectManager;
  85 }
  86
  87
  88 TcpServer::~TcpServer()
  89 {
  90         D_END;
  91
  92         DashServer::Logger::self()->info("DashServer finished");
  93
  94         qDebug("=> Deleting observers");
  95         qDeleteAll(d->observers);
  96
  97         qDebug("=> Deleting connections");
  98         foreach(DashServer::Connection *cnn, d->connections)
  99         {
 100                 removeConnection(cnn);
 101         }
 102
 103         delete d;
 104 }
 105
 106 bool TcpServer::openConnection(const QString &host, int port)
 107 {
 108         DashServer::Logger::self()->info(QObject::tr("Initialized server on %1:%2").arg(host).arg(port));
 109
 110         QList<QHostAddress> addrs = QHostInfo::fromName(host).addresses();
 111         if ( !addrs.isEmpty() )
 112         {
 113                 if(! listen(QHostAddress(addrs[0]), port) )
 114                 {
 115                         dError() << "Can't connect to " << host<<":"<<port<< " error was: " << errorString();
 116                         return false;
 117                 }
 118         }
 119         else
 120         {
 121                 dError() << "Error while try to resolve " << host;
 122                 return false;
 123         }
 124         return true;
 125 }
 126
 127 void TcpServer::addAdmin(DashServer::Connection *cnx)
 128 {
 129         d->admins << cnx;
 130 }
 131
 132 Backups::Manager *TcpServer::backupManager() const
 133 {
 134         return d->backupManager;
 135 }
 136
 137 Bans::Manager *TcpServer::banManager() const
 138 {
 139         return d->banManager;
 140 }
 141
 142 Users::Manager *TcpServer::userManager() const
 143 {
 144         return d->userManager;
 145 }
 146
 147 Project::Manager *TcpServer::projectManager() const
 148 {
 149         return d->projectManager;
 150 }
 151
 152 void TcpServer::addObserver(DashServer::Observer *observer)
 153 {
 154         d->observers << observer;
 155 }
 156
 157 bool TcpServer::removeObserver(DashServer::Observer *observer)
 158 {
 159         return d->observers.removeAll(observer) > 0;
 160 }
 161
 162 void TcpServer::incomingConnection(int socketDescriptor)
 163 {
 164         D_SHOW_VAR(d->connections.count());
 165         D_SHOW_VAR(socketDescriptor);
 166
 167         DashServer::Connection *newConnection = new DashServer::Connection(socketDescriptor,this);
 168
 169         QString ip = newConnection->client()->peerAddress().toString();
 170         d->banManager->initialize(ip);
 171
 172         if ( !d->banManager->isBanned(ip) )
 173         {
 174                 handle(newConnection);
 175                 d->connections << newConnection;
 176         }
 177         else
 178         {
 179                 connect(newConnection, SIGNAL(finished()), newConnection, SLOT(deleteLater()));
 180                 newConnection->sendError(tr("You're banned, Please contact to server administrator if you think is an error!"), Dash::Network::Package::Error::Err);
 181         }
 182 }
 183
 184 void TcpServer::handle(DashServer::Connection *cnx)
 185 {
 186         connect(cnx, SIGNAL(requestSendToAll( const QString& )), this, SLOT(sendToAll( const QString& )));
 187
 188         connect(cnx, SIGNAL(packageReaded(DashServer::Connection*, const QString&, const QString&)), this, SLOT(handlePackage(DashServer::Connection*, const QString&, const QString&)));
 189
 190         connect(cnx, SIGNAL(connectionClosed(DashServer::Connection*)), this, SLOT(removeConnection(DashServer::Connection*)));
 191 }
 192
 193
 194 void TcpServer::sendToAll(const QString &msg)
 195 {
 196         foreach(DashServer::Connection *connection, d->connections)
 197         {
 198                 connection->sendToClient(msg, false);
 199         }
 200 }
 201
 202 void TcpServer::sendToAll(const QDomDocument &pkg)
 203 {
 204         D_FUNCINFO;
 205         sendToAll(pkg.toString(0));
 206 }
 207
 208 void TcpServer::sendToAdmins(const QString &str)
 209 {
 210         foreach(DashServer::Connection *cnn, d->admins)
 211         {
 212                 cnn->sendToClient(str, false);
 213         }
 214 }
 215
 216 void TcpServer::removeConnection(DashServer::Connection *cnx)
 217 {
 218         D_FUNCINFO;
 219
 220         if( ! cnx ) return;
 221
 222         if( !d->connections.contains(cnx) ) return;
 223
 224         d->connections.remove(cnx);
 225         d->admins.remove(cnx);
 226
 227         foreach(DashServer::Observer *observer, d->observers)
 228         {
 229                 observer->connectionClosed(cnx);
 230         }
 231
 232         cnx->blockSignals(true);
 233         cnx->close();
 234         cnx->blockSignals(false);
 235
 236         if( !cnx->isRunning() )
 237         {
 238                 cnx->deleteLater();
 239         }
 240         else
 241         {
 242                 connect(cnx, SIGNAL(finished()), cnx, SLOT(deleteLater()));
 243                 cnx->terminate();
 244         }
 245 }
 246
 247
 248 void TcpServer::handlePackage(DashServer::Connection* client, const QString &root, const QString&package)
 249 {
 250         DashServer::Package *pkg = new DashServer::Package(root, package, client);
 251
 252         foreach(DashServer::Observer *observer, d->observers)
 253         {
 254                 observer->handlePackage(pkg);
 255
 256                 if ( pkg->isAccepted() )
 257                         break;
 258         }
 259
 260         if( ! pkg->isAccepted() )
 261                 qWarning() << "NOT ACCEPTED: " << pkg->root();
 262
 263         delete pkg;
 264
 265         client->process();
 266 }
 267
 268
 269 }
 270
 271