kopete/protocols/msn/transport.cpp

   1 /*
   2     transport.cpp - Peer to peer transport
   3
   4     Copyright (c) 2005 by Gregg Edghill     <gregg.edghill@gmail.com>
   5
   6     Kopete    (c) 2002-2005 by the Kopete developers <kopete-devel@kde.org>
   7
   8     *************************************************************************
   9     *                                                                       *
  10     * This program is free software; you can redistribute it and/or modify  *
  11     * it under the terms of the GNU General Public License as published by  *
  12     * the Free Software Foundation; either version 2 of the License, or     *
  13     * (at your option) any later version.                                   *
  14     *                                                                       *
  15     *************************************************************************
  16 */
  17
  18 #include "transport.h"
  19 #include "messageformatter.h"
  20
  21 //BEGIN QT Includes
  22 //END
  23
  24 //BEGIN KDE Includes
  25 #include <kclientsocketbase.h>
  26 #include <kdebug.h>
  27 #include <kstreamsocket.h>
  28 //END
  29
  30 //BEGIN Using Directives
  31 using namespace KNetwork;
  32 //END
  33
  34 #include "msnswitchboardsocket.h"
  35
  36 namespace PeerToPeer {
  37
  38 Transport::Transport(QObject* parent)
  39  : QObject(parent)
  40 {
  41         mFormatter = new PeerToPeer::MessageFormatter(this);
  42 }
  43
  44
  45 Transport::~Transport()
  46 {
  47 }
  48
  49 //BEGIN Public Methods
  50
  51 TransportBridge* Transport::getBridge (const QString& to, quint16 port, TransportBridgeType type, const QString& identifier)
  52 {
  53         TransportBridge *bridge = 0l;
  54         KInetSocketAddress address;
  55         if (mAddresses.contains(to))
  56         {
  57                 address = mAddresses[to];
  58         }
  59         else
  60         {
  61                 address = KInetSocketAddress(KIpAddress(to), port);
  62                 mAddresses[to] = address;
  63         }
  64
  65         if (PeerToPeer::Tcp == type){
  66                 bridge = new TcpTransportBridge(address, mFormatter, this, identifier.ascii());
  67         }
  68
  69         if (PeerToPeer::Udp == type){
  70 // TODO Add class UdpTransportBridge
  71 //              bridge = new UdpTransportBridge(address, this, mFormatter, identifier.ascii());
  72         }
  73
  74         if (bridge != 0l)
  75         {
  76                 QObject::connect(bridge, SIGNAL(readyRead(const QByteArray&)), SLOT(slotOnReceive(const QByteArray&)));
  77         }
  78
  79         return 0l;
  80 }
  81
  82 void Transport::setDefaultBridge(MSNSwitchBoardSocket* mss)
  83 {
  84         mDefaultBridge = mss;
  85         QObject::connect((MSNSwitchBoardSocket*)mDefaultBridge, SIGNAL(messageReceived(const QString&, const QByteArray&)), SLOT(slotOnReceive(const QString&, const QByteArray&)));
  86 }
  87
  88 //END
  89
  90 //BEGIN Private Slot Methods
  91
  92 // void Transport::slotOnReceive(Message& message)
  93 // {
  94 // }
  95
  96 void Transport::slotOnReceive(const QString& contact, const QByteArray& bytes)
  97 {
  98         kDebug (14140) << " >> RECEIVED " << bytes.size() << " bytes.";
  99 //      Message message = mFormatter->readMessage(bytes);
 100 }
 101
 102 //END
 103
 104
 105
 106
 107 TransportBridge::TransportBridge(const KNetwork::KInetSocketAddress& to, MessageFormatter* formatter, QObject* parent)
 108 : QObject(parent)
 109 {
 110         mAddress = to;
 111         mFormatter = formatter;
 112 }
 113
 114 TransportBridge::TransportBridge(KNetwork::KClientSocketBase* socket, MessageFormatter* formatter, QObject* parent)
 115 : QObject(parent)
 116 {
 117         mSocket = socket;
 118         mAddress = mSocket->peerAddress();
 119 }
 120
 121 TransportBridge::~TransportBridge()
 122 {
 123 }
 124
 125 //BEGIN Public Methods
 126
 127 void TransportBridge::connect()
 128 {
 129         slotOnConnect();
 130 }
 131
 132 void TransportBridge::disconnect()
 133 {
 134         slotOnDisconnect();
 135 }
 136
 137 //END
 138
 139 //BEGIN Protected Slot Methods
 140
 141 void TransportBridge::slotOnConnect()
 142 {
 143 }
 144
 145 void TransportBridge::slotOnDisconnect()
 146 {
 147 }
 148
 149 void TransportBridge::slotOnError(int)
 150 {
 151 }
 152
 153 void TransportBridge::slotOnSocketClose()
 154 {
 155 }
 156
 157 void TransportBridge::slotOnSocketConnect()
 158 {
 159 }
 160
 161 void TransportBridge::slotOnSocketReceive()
 162 {
 163 }
 164
 165
 166 //END
 167
 168
 169
 170 TcpTransportBridge::TcpTransportBridge(const KNetwork::KInetSocketAddress& to, MessageFormatter* formatter, QObject* parent)
 171 : TransportBridge(to, formatter, parent)
 172 {
 173         mSocket = new KStreamSocket(mAddress.ipAddress().toString(), QString::number(mAddress.port()), this);
 174         mSocket->setBlocking(false);
 175         QObject::connect(mSocket, SIGNAL(connected(const KResolverEntry&)), SLOT(slotOnSocketConnect()));
 176         QObject::connect(mSocket, SIGNAL(gotError(int)), SLOT(slotOnError(int)));
 177         mConnected = false;
 178 }
 179
 180 TcpTransportBridge::TcpTransportBridge(KNetwork::KClientSocketBase* socket, MessageFormatter* formatter, QObject* parent)
 181 : TransportBridge(socket, formatter, parent)
 182 {
 183         mConnected = (mSocket->state() == KStreamSocket::Open) ? true : false;
 184         mSocket->setBlocking(false);
 185 }
 186
 187 TcpTransportBridge::~TcpTransportBridge()
 188 {
 189 }
 190
 191 //BEGIN Protected Slot Methods
 192
 193 void TcpTransportBridge::slotOnConnect()
 194 {
 195         if (mConnected)
 196         {
 197                 kDebug(14140) << "Bridge (" << name() << ") ALREADY CONNECTED " << mSocket->peerAddress().toString() << " <-> " << mSocket->localAddress().toString();
 198                 return;
 199         }
 200
 201         KStreamSocket *socket = static_cast<KStreamSocket*>(mSocket);
 202         socket->setTimeout(5000);
 203         QObject::connect(socket, SIGNAL(timeOut()), SLOT(slotOnSocketConnectTimeout()));
 204         mSocket->connect();
 205 }
 206
 207 void TcpTransportBridge::slotOnDisconnect()
 208 {
 209         if (mConnected){
 210                 mSocket->close();
 211         }
 212 }
 213
 214 void TcpTransportBridge::slotOnError(int errorCode)
 215 {
 216         kDebug(14140) << "Bridge (" << name() << ") ERROR occurred on {" << mSocket->localAddress().toString() << " <-> " << mSocket->peerAddress().toString() << "} - " << mSocket->errorString();
 217         emit bridgeError(QString("Bridge ERROR %1: %2").arg(errorCode).arg(mSocket->errorString()));
 218         if (mConnected){
 219                 mSocket->disconnect();
 220                 mConnected = false;
 221         }
 222         mSocket->deleteLater();
 223         mSocket = 0l;
 224 }
 225
 226 void TcpTransportBridge::slotOnSocketClose()
 227 {
 228         mSocket->disconnect();
 229         kDebug(14140) << "Bridge (" << name() << ") DISCONNECTED {" << mSocket->peerAddress().toString() << " <-> " << mSocket->localAddress().toString() << "}";
 230         mConnected = false;
 231         mSocket->deleteLater();
 232         mSocket = 0l;
 233
 234         emit bridgeDisconnect();
 235 }
 236
 237 void TcpTransportBridge::slotOnSocketConnect()
 238 {
 239         kDebug(14140) << "Bridge (" << name() << ") CONNECTED to " << mSocket->peerAddress().toString() << " from "
 240                 << mSocket->localAddress().toString() << endl;
 241         mConnected = true;
 242
 243         QObject::connect(mSocket, SIGNAL(readyRead()), SLOT(slotOnSocketReceive()));
 244         QObject::connect(mSocket, SIGNAL(closed()), SLOT(slotOnSocketClose()));
 245
 246         mVerified = true;
 247         QString foo = "foo\0";
 248         mSocket->write(foo.toAscii(), foo.length());
 249         foo.clear();
 250
 251         emit bridgeConnect();
 252 }
 253
 254 void TcpTransportBridge::slotOnSocketReceive()
 255 {
 256         kDebug (14140) << "Bridge (" << name() << ") RECEIVED " << mSocket->bytesAvailable() << " bytes.";
 257
 258         QByteArray bytes(mSocket->bytesAvailable());
 259         mSocket->read(bytes.data(), bytes.size());
 260         // Write the data to the buffer.
 261         mBuffer.write(bytes);
 262
 263         if (mVerified == false && mBuffer.size() >= 4)
 264         {
 265                 QByteArray foo = mBuffer.read(4);
 266                 if (QString(foo) == "foo"){
 267                         kDebug (14140) << "Bridge (" << name() << ") CONNECTION verified.";
 268                         mVerified = true;
 269                 }
 270         }
 271
 272         while(mBuffer.size() > 0)
 273         {
 274                 if (mBuffer.size() >= 4 && mLength == 0)
 275                 {
 276                         QByteArray array = mBuffer.read(4);
 277                         for (int i=0; i < 4; i++){
 278                                 ((char*)mLength)[i] = array[i];
 279                         }
 280                 }
 281
 282                 if (mLength > 0 && mBuffer.size() >= mLength)
 283                 {
 284                         kDebug (14140) << "Bridge (" << name() << ") read " << mLength << " bytes.";
 285                         bytes = mBuffer.read(mLength);
 286                         mLength = 0;
 287 //                      Message message = mFormatter->readMessage(bytes, true);
 288 //                      emit messageReceived(message);
 289                 }
 290                 else
 291                 {
 292                         kDebug (14140) << "Bridge (" << name() << ") waiting for " << mLength << " bytes.";
 293                         break;
 294                 }
 295         }
 296 }
 297
 298 //END
 299
 300 //BEGIN Private Slot Methods
 301
 302 void TcpTransportBridge::slotOnSocketConnectTimeout()
 303 {
 304         kDebug (14140) << "Bridge (" << name() << ") CONNECT timeout.";
 305         emit bridgeConnectTimeout();
 306         mSocket->deleteLater();
 307         mSocket = 0l;
 308 }
 309
 310 //END
 311
 312
 313
 314
 315 TcpTransportBridge::Buffer::Buffer(quint32 length)
 316 : QByteArray(length)
 317 {
 318 }
 319
 320 TcpTransportBridge::Buffer::~Buffer()
 321 {
 322 }
 323
 324 //BEGIN Public Methods
 325
 326 void TcpTransportBridge::Buffer::write(const QByteArray& bytes)
 327 {
 328         resize(size() + bytes.size());
 329         for (uint i=0; i < bytes.size(); i++){
 330                 (*this)[size() + i] = bytes[i];
 331         }
 332 }
 333
 334 QByteArray TcpTransportBridge::Buffer::read(quint32 length)
 335 {
 336         if (length >= size()) return QByteArray();
 337
 338         QByteArray buffer;
 339         buffer.duplicate(data(), length);
 340
 341         char *bytes = new char[size() - length];
 342         for(uint i=0; i < size() - length; i++){
 343                 bytes[i] = data()[length + i];
 344         }
 345
 346         duplicate(bytes, size() - length);
 347         delete[] bytes;
 348
 349         return buffer;
 350 }
 351
 352 //END
 353
 354 }
 355
 356 #include "transport.moc"
 357