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)
  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
  68                 void signPackage(QDomDocument &doc);
  69 };
  70
  71 void Connection::Private::signPackage(QDomDocument &doc)
  72 {
  73         doc.documentElement().setAttribute("sign", sign);
  74 }
  75
  76 Connection::Connection(int socketDescriptor, DashServer::TcpServer *server) : QThread(server), d(new Private(server))
  77 {
  78         D_INIT;
  79
  80         d->client = new Dash::Network::Socket(this);
  81         d->client->setSocketDescriptor(socketDescriptor);
  82         connect(d->client, SIGNAL(disconnected()), this, SLOT(removeConnection()));
  83         d->isValid = true;
  84         d->client->addObserver(this);
  85 }
  86
  87 Connection::~Connection()
  88 {
  89         D_END;
  90         delete d;
  91 }
  92
  93 void Connection::run()
  94 {
  95         while(! d->readed.isEmpty() )
  96         {
  97                 if ( !d->isValid ) break;
  98
  99                 if( !d->user )
 100                         d->isValid = false;
 101
 102                 QString readed = d->readed.dequeue();
 103
 104                 dDebug(/*"server"*/) << "Reicieved: " << readed;
 105
 106                 QString root;
 107                 {
 108                         QXmlStreamReader reader(readed);
 109                         while( !reader.atEnd())
 110                         {
 111                                 if( reader.readNext() == QXmlStreamReader::StartElement)
 112                                 {
 113                                         root = reader.name().toString();
 114                                         break;
 115                                 }
 116                         }
 117                 }
 118
 119                 if ( !root.isEmpty() )
 120                 {
 121                         emit packageReaded(this, root, readed);
 122                 }
 123                 else
 124                 {
 125                         dError("server") << "Cannot set document content!";
 126                 }
 127         }
 128 }
 129
 130
 131 void Connection::removeConnection()
 132 {
 133         emit connectionClosed(this);
 134 }
 135
 136 void Connection::close()
 137 {
 138         d->isValid = false;
 139
 140         d->readed.clear();
 141         if ( d->client->state() != QAbstractSocket::UnconnectedState )
 142         {
 143                 d->client->flush();
 144
 145                 d->client->disconnectFromHost();
 146                 d->client->waitForDisconnected();
 147                 d->client->close();
 148         }
 149 }
 150
 151 void Connection::readed(const QString &readed)
 152 {
 153         dDebug(/*"server"*/) << "Enqueing: " << readed;
 154         d->readed.enqueue(readed);
 155
 156         if( ! isRunning() )
 157                 start();
 158 }
 159
 160 void Connection::dataReaded(const QByteArray &data)
 161 {
 162         dfDebug << "Data readed!";
 163
 164         qFatal("Save the file!");
 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 QString Connection::sign() const
 223 {
 224         return d->sign;
 225 }
 226
 227 QString Connection::signXml(const QString &xml) const
 228 {
 229         QString tosend;
 230
 231         if( !d->sign.isEmpty() )
 232         {
 233                 QXmlStreamReader reader(xml);
 234                 QXmlStreamWriter writer(&tosend);
 235
 236                 bool isRoot = false;
 237                 while( ! reader.atEnd() )
 238                 {
 239                         reader.readNext();
 240
 241                         writer.writeCurrentToken(reader);
 242                         if( reader.tokenType() == QXmlStreamReader::StartElement && !isRoot )
 243                         {
 244                                 dfDebug << "Writing sign on " << reader.name().toString();
 245
 246                                 if( reader.attributes().value("sign").isEmpty() )
 247                                         writer.writeAttribute("sign", d->sign);
 248                                 isRoot = true;
 249                         }
 250                 }
 251
 252                 if ( !isRoot )
 253                         tosend = xml;
 254         }
 255         else
 256         {
 257                 tosend = xml;
 258         }
 259
 260         return tosend;
 261 }
 262
 263 void Connection::setUser(Users::User *user)
 264 {
 265         d->user = user;
 266         generateSign();
 267
 268         d->isValid = true;
 269 }
 270
 271 Users::User *Connection::user() const
 272 {
 273         return d->user;
 274 }
 275
 276 void Connection::generateSign()
 277 {
 278         if ( d->user )
 279         {
 280                 d->sign =
 281                 QCryptographicHash::hash((d->user->login()+DCore::Algorithm::randomString(DCore::Algorithm::random() % 10)).toLocal8Bit(), QCryptographicHash::Md5).toBase64();
 282         }
 283 }
 284
 285
 286 void Connection::sendError(const QString & message, Dash::Network::Package::Error::Level level)
 287 {
 288         Dash::Network::Package::Error error(message, level);
 289         sendToClient(error.toString(), true);
 290 }
 291
 292 void Connection::setValid(bool v)
 293 {
 294         d->isValid = v;
 295 }
 296
 297 bool Connection::isValid() const
 298 {
 299         return d->isValid;
 300 }
 301
 302 }
 303
 304
 305