src/dash/network/socket.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 "socket.h"
  22
  23 #include <QTextStream>
  24 #include <QQueue>
  25
  26 #include <dcore/debug.h>
  27
  28
  29 // Dash
  30 #include "socketobserver.h"
  31
  32 namespace Dash {
  33 namespace Network {
  34
  35 struct Socket::Private
  36 {
  37         Private() : format(Text) {}
  38
  39         QQueue<QByteArray> queue;
  40         QList<SocketObserver *> observers;
  41
  42         Format format;
  43
  44         QString readed;
  45 };
  46
  47 Socket::Socket(QObject *parent)
  48  : /*QSslSocket*/QTcpSocket(parent), d(new Private)
  49 {
  50         connect(this, SIGNAL(readyRead ()), this, SLOT(readFromServer()) );
  51         connect(this, SIGNAL(connected()), this, SLOT(sendQueue()));
  52         connect(this, SIGNAL(disconnected()), this, SLOT(clearQueue()));
  53 }
  54
  55
  56 Socket::~Socket()
  57 {
  58         delete d;
  59 }
  60
  61 void Socket::setFormat(Format format)
  62 {
  63         d->format = format;
  64 }
  65
  66 Socket::Format Socket::format() const
  67 {
  68         return d->format;
  69 }
  70
  71 void Socket::addObserver(SocketObserver *observer)
  72 {
  73         d->observers << observer;
  74 }
  75
  76 void Socket::removeObserver(SocketObserver *observer)
  77 {
  78         d->observers.removeAll(observer);
  79 }
  80
  81 void Socket::sendQueue()
  82 {
  83         while( d->queue.count() > 0 )
  84         {
  85                 if ( state() == QAbstractSocket::ConnectedState )
  86                 {
  87                         send(d->queue.dequeue());
  88                 }
  89                 else break;
  90         }
  91 }
  92
  93 void Socket::clearQueue()
  94 {
  95         d->queue.clear();
  96 }
  97
  98 bool Socket::send(const QByteArray &data)
  99 {
 100         if( state() == QAbstractSocket::ConnectedState )
 101         {
 102                 switch(d->format)
 103                 {
 104                         case Text:
 105                         {
 106                                 QByteArray toSend = data.toBase64()+"%%\n";
 107                                 QByteArray block;
 108
 109                                 for(int i = 0; i < toSend.size(); i++)
 110                                 {
 111                                         block += toSend[i];
 112                                         if( i % 1024 == 0 )
 113                                         {
 114                                                 if( write(block) == -1 )
 115                                                 {
 116                                                         return false;
 117                                                 }
 118                                                 block = QByteArray();
 119                                         }
 120                                 }
 121
 122                                 if( !block.isEmpty() )
 123                                 {
 124                                         return write(block) != -1;
 125                                 }
 126
 127                                 return true;
 128                         }
 129                         break;
 130                         case Binary:
 131                         {
 132                                 return write(data) != -1;
 133                         }
 134                         break;
 135                 }
 136         }
 137         else
 138         {
 139                 d->queue.enqueue(data);
 140         }
 141 }
 142
 143 bool Socket::send(const QDomDocument &doc)
 144 {
 145         return send(doc.toString(0).toLocal8Bit());
 146 }
 147
 148 void Socket::readFromServer()
 149 {
 150         switch(d->format)
 151         {
 152                 case Text:
 153                 {
 154                         while(bytesAvailable() > 0 )
 155                         {
 156                                 int bytes = bytesAvailable();
 157
 158                                 bool process = false;
 159                                 {
 160                                         QString line = this->readLine();
 161
 162                                         if( line.isEmpty() )
 163                                         {
 164                                                 d->readed += this->read(1024);
 165                                         }
 166                                         else
 167                                         {
 168                                                 d->readed += line;
 169                                         }
 170                                 }
 171                                 if ( d->readed.endsWith("%%\n") )
 172                                 {
 173                                         d->readed.remove(d->readed.lastIndexOf("%%"), 2);
 174                                         process = true;
 175                                 }
 176
 177                                 if( process && !d->readed.isEmpty() )
 178                                 {
 179                                         d->readed = QByteArray::fromBase64(d->readed.toLocal8Bit());
 180
 181                                         foreach(SocketObserver *o, d->observers)
 182                                         {
 183                                                 o->readed(d->readed);
 184                                         }
 185                                         d->readed = QString();
 186
 187                                         if( d->format != Text ) break;
 188                                 }
 189                         }
 190                 }
 191                 break;
 192                 case Binary:
 193                 {
 194                         d->readed = QString();
 195                         while(bytesAvailable() > 0)
 196                         {
 197                                 QByteArray data = this->read(1024);
 198                                 foreach(SocketObserver *o, d->observers)
 199                                 {
 200                                         o->dataReaded(data);
 201                                 }
 202                         }
 203                 }
 204                 break;
 205         }
 206
 207         if (this->bytesAvailable() > 0) emit readyRead();
 208 }
 209
 210 }
 211 }
 212