src/dashserver/users/usermanager.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 "usermanager.h"
  22
  23 #include <QHash>
  24 #include <QDomDocument>
  25 #include <QXmlStreamReader>
  26
  27 #include "user.h"
  28
  29 #include <dcore/debug.h>
  30 #include <dcore/fortunegenerator.h>
  31
  32 #include "package.h"
  33 #include "logger.h"
  34
  35 #include "server.h"
  36 #include "connection.h"
  37
  38 #include "useractionparser.h"
  39 #include "dash/network/package/userlist.h"
  40 #include "dash/network/package/ack.h"
  41 #include "bans/banmanager.h"
  42 #include "dashserver/xdbms/manager.h"
  43 #include "dashserver/xdbms/table.h"
  44
  45 #include <dash/network/socket.h>
  46
  47 namespace DashServer {
  48 namespace Users {
  49
  50 class Manager::Private
  51 {
  52         public:
  53                 Private()
  54                 {
  55                 }
  56
  57                 ~Private()
  58                 {
  59                 }
  60 };
  61
  62 Manager::Manager() : d(new Private())
  63 {
  64 }
  65
  66
  67 Manager::~Manager()
  68 {
  69         delete d;
  70 }
  71
  72 QList<User *> Manager::users() const
  73 {
  74         QList<User *> users;
  75
  76         XDBMS::Table *table = XDBMS::Manager::self()->table("users");
  77         foreach(QString login, table->objects())
  78         {
  79                 User *user = new User;
  80                 user->setLogin(login);
  81                 table->load(user);
  82
  83                 users << user;
  84         }
  85
  86
  87         return users;
  88 }
  89
  90 void Manager::handlePackage(DashServer::Package *const pkg)
  91 {
  92         QString root = pkg->root();
  93         QString package = pkg->xml();
  94
  95         DashServer::Connection *cnn = pkg->source();
  96         DashServer::TcpServer *server = cnn->server();
  97
  98
  99         if ( root == "connect" )
 100         {
 101                 pkg->accept();
 102                 cnn->setValid(false);
 103
 104                 User *user = parseConnect(package);
 105
 106                 if( user )
 107                 {
 108                         cnn->setUser(user);
 109
 110                         if( user->type() == 1 )
 111                         {
 112                                 server->addAdmin(cnn);
 113                         }
 114
 115                         QHash<QString, int> userPerms;
 116                         QList<Permission *> permissions = user->permissions();
 117                         foreach(Permission *perm, permissions)
 118                         {
 119                                 userPerms[perm->module()] = perm->opts();
 120                         }
 121
 122                         Dash::Network::Package::Ack ack(QObject::tr("<center><b>Message of the day:</b></center><br/> ")+QObject::tr("Hello, world!"), cnn->sign(), userPerms);
 123
 124                         cnn->sendToClient(ack.toString(), false);
 125                 }
 126                 else
 127                 {
 128                         Dash::Network::Package::Error error(QObject::tr("Invalid login or password"), Dash::Network::Package::Error::Err);
 129
 130                         dfDebug << error.toString();
 131
 132                         QString ip = cnn->client()->peerAddress().toString();
 133                         server->banManager()->failed(ip);
 134
 135                         cnn->sendToClient(error.toString(), true);
 136                         cnn->close();
 137                 }
 138         }
 139         else if(root == "adduser")
 140         {
 141                 if ( cnn->user()->canWriteOn(DashServer::Module::Admin) )
 142                 {
 143                         Parsers::UserActionParser parser;
 144                         if(parser.parse(package))
 145                         {
 146                                 Users::User user = parser.user();
 147
 148                                 if( XDBMS::Manager::self()->addObject("users", &user) )
 149                                 {
 150                                         QDomDocument doc;
 151                                         doc.setContent(package);
 152
 153                                         doc.firstChild().removeChild( doc.firstChild().firstChildElement ("password"));
 154
 155                                         server->sendToAdmins(doc.toString());
 156                                         pkg->accept();
 157                                 }
 158                                 else
 159                                 {
 160                                         cnn->sendError(QObject::tr("Error adding user"), Dash::Network::Package::Error::Err);
 161                                 }
 162                         }
 163                 }
 164                 else
 165                 {
 166                         cnn->sendError(QObject::tr("Permission denied."), Dash::Network::Package::Error::Err);
 167                 }
 168         }
 169         else if ( root == "listusers" )
 170         {
 171                 if ( cnn->user()->canWriteOn(DashServer::Module::Admin) )
 172                 {
 173                         Dash::Network::Package::UserList info;
 174
 175                         QList<User *> users = this->users();
 176
 177                         foreach(Users::User *u, users )
 178                         {
 179                                 info.addUser(u->login(), u->name());
 180                                 //delete u;
 181                         }
 182
 183                         qDeleteAll(users);
 184                         users.clear();
 185
 186                         cnn->sendToClient(info, true);
 187                         pkg->accept();
 188                 }
 189                 else
 190                 {
 191                         cnn->sendError(QObject::tr("Permission denied."), Dash::Network::Package::Error::Err);
 192                 }
 193         }
 194         else if(root == "removeuser")
 195         {
 196                 if ( cnn->user()->canWriteOn( DashServer::Module::Admin ) )
 197                 {
 198                         Parsers::UserActionParser parser;
 199
 200                         if(parser.parse(package))
 201                         {
 202                                 User user = parser.user();
 203
 204                                 if( XDBMS::Manager::self()->remove("users", &user) )
 205                                 {
 206                                         server->sendToAdmins(package);
 207                                         pkg->accept();
 208                                 }
 209                         }
 210                 }
 211                 else
 212                 {
 213                         cnn->sendError(QObject::tr("Permission denied."), Dash::Network::Package::Error::Err);
 214                 }
 215         }
 216         else if(root == "queryuser")
 217         {
 218                 if ( cnn->user()->canReadOn( DashServer::Module::Admin ) )
 219                 {
 220                         Parsers::UserActionParser parser;
 221                         if(parser.parse(package))
 222                         {
 223                                 Users::User user = parser.user();
 224
 225                                 if(XDBMS::Manager::self()->load("users", &user))
 226                                 {
 227                                         QString xml;
 228
 229                                         {
 230                                                 QXmlStreamWriter writer(&xml);
 231
 232                                                 writer.writeStartDocument();
 233                                                 writer.writeStartElement("userquery");
 234
 235                                                 user.toXml(&writer);
 236
 237                                                 writer.writeEndElement();
 238                                                 writer.writeEndDocument();
 239                                         }
 240
 241                                         cnn->sendToClient(xml, true);
 242                                         pkg->accept();
 243                                 }
 244                         }
 245                 }
 246                 else
 247                 {
 248                         cnn->sendError(QObject::tr("Permission denied."), Dash::Network::Package::Error::Err);
 249                 }
 250         }
 251         else if(root == "updateuser")
 252         {
 253                 if ( cnn->user()->canWriteOn( DashServer::Module::Admin ) )
 254                 {
 255                         Parsers::UserActionParser parser;
 256                         User user = parser.user();
 257
 258                         if(parser.parse(package))
 259                         {
 260                                 if( XDBMS::Manager::self()->update("users", &user) )
 261                                 {
 262                                         server->sendToAdmins(package);
 263                                         pkg->accept();
 264                                 }
 265                         }
 266                 }
 267                 else
 268                 {
 269                         cnn->sendError(QObject::tr("Permission denied."), Dash::Network::Package::Error::Err);
 270                 }
 271         }
 272 }
 273
 274
 275 User *Manager::parseConnect(const QString &package)
 276 {
 277         QString login, password;
 278         int type = 0;
 279
 280         QXmlStreamReader reader(package);
 281
 282         while( !reader.atEnd() )
 283         {
 284                 switch(reader.readNext())
 285                 {
 286                         case QXmlStreamReader::StartElement:
 287                         {
 288                                 QString tagName = reader.name().toString();
 289
 290                                 if( tagName == "client" )
 291                                 {
 292                                         type = reader.attributes().value("type").toString().toInt();
 293                                 }
 294                                 else if( tagName == "login" )
 295                                 {
 296                                         reader.readNext();
 297                                         if( reader.isCharacters() )
 298                                         {
 299                                                 login = reader.text().toString();
 300                                         }
 301                                 }
 302                                 else if(tagName == "password" )
 303                                 {
 304                                         reader.readNext();
 305
 306                                         if( reader.isCharacters() )
 307                                         {
 308                                                 password = reader.text().toString();
 309                                         }
 310                                 }
 311                         }
 312                         break;
 313                         default: break;
 314
 315                 }
 316         }
 317
 318         if( ! login.isEmpty() )
 319         {
 320                 Users::User *user = new Users::User;
 321                 user->setLogin(login);
 322
 323                 XDBMS::Manager::self()->load("users", user);
 324
 325                 if( user->password() == password ) // FIXME: encrypt
 326                 {
 327                         user->setType(type);
 328                         return user;
 329                 }
 330
 331                 delete user;
 332         }
 333
 334         return 0;
 335 }
 336
 337 }
 338 }
 339
 340
 341