src/dashserver/connection.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 "connection.h"
  22
  23 // Qt
  24 #include <QCryptographicHash>
  25 #include <QQueue>
  26 #include <QXmlStreamReader>
  27 #include <QXmlStreamWriter>
  28
  29 // DLib
  30 #include <dcore/algorithm.h>
  31 #include <dcore/debug.h>
  32
  33 // Dash
  34 #include <dash/network/socket.h>
  35
  36 // Dashemon
  37 #include "server.h"
  38 #include "logger.h"
  39 #include "users/user.h"
  40 #include "dash/network/package/error.h"
  41
  42
  43 namespace DashServer {
  44
  45 class Connection::Private
  46 {
  47         public:
  48                 Private(TcpServer *server) : server(server), user(0), finishing(false)
  49                 {
  50                 }
  51
  52                 ~Private()
  53                 {
  54                         delete client;
  55                         delete user;
  56                 }
  57
  58                 Dash::Network::Socket *client;
  59                 DashServer::TcpServer *server;
  60
  61                 bool isValid;
  62                 QQueue<QString> readed;
  63                 QHash<int, QVariant> data;
  64                 QString sign;
  65
  66                 Users::User *user;
  67                 bool finishing;
  68
  69                 void signPackage(QDomDocument &doc);
  70 };
  71
  72 void Connection::Private::signPackage(QDomDocument &doc)
  73 {
  74         doc.documentElement().setAttribute("sign", sign);
  75 }
  76
  77 Connection::Connection(int socketDescriptor, DashServer::TcpServer *server) : QThread(server), d(new Private(server))
  78 {
  79         D_INIT;
  80
  81         d->client = new Dash::Network::Socket(this);
  82         d->client->setSocketDescriptor(socketDescriptor);
  83         connect(d->client, SIGNAL(disconnected()), this, SLOT(removeConnection()));
  84         d->isValid = true;
  85         d->client->addObserver(this);
  86 }
  87
  88 Connection::~Connection()
  89 {
  90         D_END;
  91         delete d;
  92 }
  93
  94 void Connection::run()
  95 {
  96         while(! d->readed.isEmpty() )
  97         {
  98                 if ( !d->isValid ) break;
  99
 100                 if( !d->user )
 101                         d->isValid = false;
 102
 103                 QString readed = d->readed.dequeue();
 104
 105                 dDebug(/*"server"*/) << "Reicieved: " << readed;
 106
 107                 QString root;
 108                 {
 109                         QXmlStreamReader reader(readed);
 110                         while( !reader.atEnd())
 111                         {
 112                                 if( reader.readNext() == QXmlStreamReader::StartElement)
 113                                 {
 114                                         root = reader.name().toString();
 115                                         break;
 116                                 }
 117                         }
 118                 }
 119
 120                 if ( !root.isEmpty() )
 121                 {
 122                         emit packageReaded(this, root, readed);
 123                 }
 124                 else
 125                 {
 126                         dError("server") << "Cannot set document content!";
 127                 }
 128         }
 129 }
 130
 131
 132 void Connection::removeConnection()
 133 {
 134         emit connectionClosed(this);
 135 }
 136
 137 void Connection::close()
 138 {
 139         d->isValid = false;
 140         d->finishing = true;
 141
 142         d->readed.clear();
 143         if ( d->client->state() != QAbstractSocket::UnconnectedState )
 144         {
 145                 d->client->flush();
 146
 147                 d->client->disconnectFromHost();
 148                 d->client->waitForDisconnected();
 149         }
 150 }
 151
 152 void Connection::readed(const QString &readed)
 153 {
 154         if( d->finishing ) return;
 155
 156         dDebug(/*"server"*/) << "Enqueing: " << readed;
 157         d->readed.enqueue(readed);
 158
 159         process();
 160 }
 161
 162 void Connection::dataReaded(const QByteArray &data)
 163 {
 164         Q_UNUSED(data);
 165 }
 166
 167 void Connection::sendToClient(const QString &xml, bool sign) const
 168 {
 169         if( sign )
 170         {
 171                 d->client->send( signXml(xml).toLocal8Bit() );
 172         }
 173         else
 174         {
 175                 d->client->send( xml.toLocal8Bit() );
 176         }
 177 }
 178
 179 void Connection::setData(int key, const QVariant &value)
 180 {
 181         d->data.insert(key, value);
 182 }
 183
 184 QVariant Connection::data(int key) const
 185 {
 186         return d->data.value(key);
 187 }
 188
 189 Dash::Network::Socket *Connection::client() const
 190 {
 191         return d->client;
 192 }
 193
 194 TcpServer *Connection::server() const
 195 {
 196         return d->server;
 197 }
 198
 199 void Connection::sendToAll(const QString &xml, bool sign)
 200 {
 201         emit requestSendToAll(signXml(xml));
 202 }
 203
 204 void Connection::sendToClient(QDomDocument &doc, bool sign)
 205 {
 206         if ( sign)
 207                 d->signPackage(doc);
 208
 209         dDebug() << "sending " << doc.toString();
 210
 211         d->client->send(doc);
 212
 213 }
 214
 215 void Connection::sendToAll(QDomDocument &doc, bool sign)
 216 {
 217         if( sign )
 218                 d->signPackage(doc);
 219         emit requestSendToAll(doc.toString(0));
 220 }
 221
 222 void Connection::sendBinaryData(const QByteArray &data)
 223 {
 224         d->client->setFormat(Dash::Network::Socket::Binary);
 225
 226         d->client->send(data);
 227
 228         d->client->setFormat(Dash::Network::Socket::Text);
 229 }
 230
 231 QString Connection::sign() const
 232 {
 233         return d->sign;
 234 }
 235
 236 QString Connection::signXml(const QString &xml) const
 237 {
 238         QString tosend;
 239
 240         if( !d->sign.isEmpty() )
 241         {
 242                 QXmlStreamReader reader(xml);
 243                 QXmlStreamWriter writer(&tosend);
 244
 245                 bool isRoot = false;
 246                 while( ! reader.atEnd() )
 247                 {
 248                         reader.readNext();
 249
 250                         writer.writeCurrentToken(reader);
 251                         if( reader.tokenType() == QXmlStreamReader::StartElement && !isRoot )
 252                         {
 253                                 dfDebug << "Writing sign on " << reader.name().toString();
 254
 255                                 if( reader.attributes().value("sign").isEmpty() )
 256                                         writer.writeAttribute("sign", d->sign);
 257                                 isRoot = true;
 258                         }
 259                 }
 260
 261                 if ( !isRoot )
 262                         tosend = xml;
 263         }
 264         else
 265         {
 266                 tosend = xml;
 267         }
 268
 269         return tosend;
 270 }
 271
 272 void Connection::setUser(Users::User *user)
 273 {
 274         d->user = user;
 275         generateSign();
 276
 277         d->isValid = true;
 278 }
 279
 280 Users::User *Connection::user() const
 281 {
 282         return d->user;
 283 }
 284
 285 void Connection::generateSign()
 286 {
 287         if ( d->user )
 288         {
 289                 d->sign =
 290                 QCryptographicHash::hash((d->user->login()+DCore::Algorithm::randomString(DCore::Algorithm::random() % 10)).toLocal8Bit(), QCryptographicHash::Md5).toBase64();
 291         }
 292 }
 293
 294
 295 void Connection::sendError(const QString & message, Dash::Network::Package::Error::Level level)
 296 {
 297         Dash::Network::Package::Error error(message, level);
 298         sendToClient(error.toString(), true);
 299 }
 300
 301 void Connection::setValid(bool v)
 302 {
 303         d->isValid = v;
 304 }
 305
 306 bool Connection::isValid() const
 307 {
 308         return d->isValid;
 309 }
 310
 311 void Connection::process()
 312 {
 313         if( !isRunning() && !d->finishing )
 314         {
 315                 start();
 316         }
 317 }
 318
 319 }
 320
 321
 322