kopete/protocols/groupwise/libgroupwise/gwclientstream.cpp

   1 /*
   2     gwclientstream.cpp - Kopete Groupwise Protocol
   3
   4     Copyright (c) 2006      Novell, Inc                  http://www.opensuse.org
   5     Copyright (c) 2004      SUSE Linux AG                http://www.suse.com
   6
   7     Based on Iris, Copyright (C) 2003  Justin Karneges <justin@affinix.com>
   8     encode_method from Gaim src/protocols/novell/nmconn.c
   9     Copyright (c) 2004 Novell, Inc. All Rights Reserved
  10
  11     Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
  12
  13     *************************************************************************
  14     *                                                                       *
  15     * This library is free software; you can redistribute it and/or         *
  16     * modify it under the terms of the GNU Lesser General Public            *
  17     * License as published by the Free Software Foundation; either          *
  18     * version 2 of the License, or (at your option) any later version.      *
  19     *                                                                       *
  20     *************************************************************************
  21 */
  22
  23 //#include<qtextstream.h>
  24 //#include<qguardedptr.h>
  25 // #include<qca.h>
  26 // #include<stdlib.h>
  27 // #include"bytestream.h"
  28 // #include"base64.h"
  29 // #include"hash.h"
  30 // #include"simplesasl.h"
  31 // #include"securestream.h"
  32 // #include"protocol.h"
  33
  34 #include <qapplication.h>  // for qdebug
  35 #include <qpointer.h>
  36 #include <qobject.h>
  37 #include <QQueue>
  38 #include <qtimer.h>
  39 //Added by qt3to4:
  40 #include <QByteArray>
  41
  42 #include "bytestream.h"
  43 #include "connector.h"
  44 #include "coreprotocol.h"
  45 #include "request.h"
  46 #include "securestream.h"
  47 #include "tlshandler.h"
  48
  49 //#include "iostream.h"
  50
  51 #include "gwclientstream.h"
  52
  53 //#define LIBGW_DEBUG 1
  54
  55 void cs_dump( const QByteArray &bytes );
  56
  57 enum {
  58         Idle,
  59         Connecting,
  60         WaitVersion,
  61         WaitTLS,
  62         NeedParams,
  63         Active,
  64         Closing
  65 };
  66
  67 enum {
  68         Client,
  69         Server
  70 };
  71
  72 class ClientStream::Private
  73 {
  74 public:
  75         Private()
  76         {
  77                 conn = 0;
  78                 bs = 0;
  79                 ss = 0;
  80                 tlsHandler = 0;
  81                 tls = 0;
  82 //              sasl = 0;
  83
  84                 allowPlain = false;
  85                 mutualAuth = false;
  86                 haveLocalAddr = false;
  87 /*              minimumSSF = 0;
  88                 maximumSSF = 0;*/
  89                 doBinding = true;
  90
  91                 in_rrsig = false;
  92
  93                 reset();
  94         }
  95         void reset()
  96         {
  97                 state = Idle;
  98                 notify = 0;
  99                 newTransfers = false;
 100 //              sasl_ssf = 0;
 101                 tls_warned = false;
 102                 using_tls = false;
 103         }
 104
 105         NovellDN id;
 106         QString server;
 107         bool oldOnly;
 108         bool allowPlain, mutualAuth;
 109         bool haveLocalAddr;
 110         QHostAddress localAddr;
 111         quint16 localPort;
 112 //      int minimumSSF, maximumSSF;
 113 //      QString sasl_mech;
 114         bool doBinding;
 115
 116         bool in_rrsig;
 117
 118         Connector *conn;
 119         ByteStream *bs;
 120         TLSHandler *tlsHandler;
 121         QCA::TLS *tls;
 122 //      QCA::SASL *sasl;
 123         SecureStream *ss;
 124         CoreProtocol client;
 125         //CoreProtocol srv;
 126
 127         QString defRealm;
 128
 129         int mode;
 130         int state;
 131         int notify;
 132         bool newTransfers;
 133 //      int sasl_ssf;
 134         bool tls_warned, using_tls;
 135         bool doAuth;
 136
 137 //      QStringList sasl_mechlist;
 138
 139         int errCond;
 140         QString errText;
 141
 142         QQueue<Transfer *> in;
 143
 144         QTimer noopTimer; // probably not needed
 145         int noop_time;
 146 };
 147
 148 ClientStream::ClientStream(Connector *conn, TLSHandler *tlsHandler, QObject *parent)
 149 :Stream(parent), d(new Private())
 150 {
 151         d->mode = Client;
 152         d->conn = conn;
 153         connect( d->conn, SIGNAL(connected()), SLOT(cr_connected()) );
 154         connect( d->conn, SIGNAL(error()), SLOT(cr_error()) );
 155         connect( &d->client, SIGNAL( outgoingData( const QByteArray& ) ), SLOT ( cp_outgoingData( const QByteArray & ) ) );
 156         connect( &d->client, SIGNAL( incomingData() ), SLOT ( cp_incomingData() ) );
 157
 158         d->noop_time = 0;
 159         connect(&d->noopTimer, SIGNAL(timeout()), SLOT(doNoop()));
 160
 161         d->tlsHandler = tlsHandler;             // all the extra stuff happening in the larger ctor happens at connect time :)
 162 }
 163
 164 ClientStream::~ClientStream()
 165 {
 166         reset( true );
 167         delete d;
 168 }
 169
 170 void ClientStream::reset(bool all)
 171 {
 172         d->reset();
 173         d->noopTimer.stop();
 174
 175         // delete securestream
 176         delete d->ss;
 177         d->ss = 0;
 178
 179         // reset sasl
 180 //      delete d->sasl;
 181 //      d->sasl = 0;
 182
 183         // client
 184         if(d->mode == Client) {
 185                 // reset tls
 186                 if(d->tlsHandler)
 187                         d->tlsHandler->reset();
 188
 189                 // reset connector
 190                 if(d->bs) {
 191                         d->bs->close();
 192                         d->bs = 0;
 193                 }
 194                 d->conn->done();
 195
 196                 // reset state machine
 197                 d->client.reset();
 198         }
 199         if(all)
 200                 while (!d->in.isEmpty())
 201                         delete d->in.dequeue();
 202 }
 203
 204 // Jid ClientStream::jid() const
 205 // {
 206 //      return d->jid;
 207 // }
 208
 209 void ClientStream::connectToServer(const NovellDN &id, bool auth)
 210 {
 211         reset(true);
 212         d->state = Connecting;
 213         d->id = id;
 214         d->doAuth = auth;
 215         d->server = d->id.server;
 216
 217         d->conn->connectToServer( d->server );
 218 }
 219
 220 void ClientStream::continueAfterWarning()
 221 {
 222         if(d->state == WaitVersion) {
 223                 // if we don't have TLS yet, then we're never going to get it
 224                 if(!d->tls_warned && !d->using_tls) {
 225                         d->tls_warned = true;
 226                         d->state = WaitTLS;
 227                         emit warning(WarnNoTLS);
 228                         return;
 229                 }
 230                 d->state = Connecting;
 231                 processNext();
 232         }
 233         else if(d->state == WaitTLS) {
 234                 d->state = Connecting;
 235                 processNext();
 236         }
 237 }
 238
 239 void ClientStream::accept()
 240 {
 241 /*      d->srv.host = d->server;
 242         processNext();*/
 243 }
 244
 245 bool ClientStream::isActive() const
 246 {
 247         return (d->state != Idle);
 248 }
 249
 250 bool ClientStream::isAuthenticated() const
 251 {
 252         return (d->state == Active);
 253 }
 254
 255 // void ClientStream::setPassword(const QString &s)
 256 // {
 257 //      if(d->client.old) {
 258 //              d->client.setPassword(s);
 259 //      }
 260 //      else {
 261 //              if(d->sasl)
 262 //                      d->sasl->setPassword(s);
 263 //      }
 264 // }
 265
 266 // void ClientStream::setRealm(const QString &s)
 267 // {
 268 //      if(d->sasl)
 269 //              d->sasl->setRealm(s);
 270 // }
 271
 272 void ClientStream::continueAfterParams()
 273 {
 274 /*      if(d->state == NeedParams) {
 275                 d->state = Connecting;
 276                 if(d->client.old) {
 277                         processNext();
 278                 }
 279                 else {
 280                         if(d->sasl)
 281                                 d->sasl->continueAfterParams();
 282                 }
 283         }*/
 284 }
 285
 286 void ClientStream::setNoopTime(int mills)
 287 {
 288         d->noop_time = mills;
 289
 290         if(d->state != Active)
 291                 return;
 292
 293         if(d->noop_time == 0) {
 294                 d->noopTimer.stop();
 295                 return;
 296         }
 297         d->noopTimer.start(d->noop_time);
 298 }
 299
 300 void ClientStream::setLocalAddr(const QHostAddress &addr, quint16 port)
 301 {
 302         d->haveLocalAddr = true;
 303         d->localAddr = addr;
 304         d->localPort = port;
 305 }
 306
 307 int ClientStream::errorCondition() const
 308 {
 309         return d->errCond;
 310 }
 311
 312 QString ClientStream::errorText() const
 313 {
 314         return d->errText;
 315 }
 316
 317 // QDomElement ClientStream::errorAppSpec() const
 318 // {
 319 //      return d->errAppSpec;cr_error
 320 // }
 321
 322 // bool ClientStream::old() const
 323 // {
 324 //      return d->client.old;
 325 // }
 326
 327 void ClientStream::close()
 328 {
 329         if(d->state == Active) {
 330                 d->state = Closing;
 331 //              d->client.shutdown();
 332                 processNext();
 333         }
 334         else if(d->state != Idle && d->state != Closing) {
 335                 reset();
 336         }
 337 }
 338
 339 void ClientStream::setAllowPlain(bool b)
 340 {
 341         d->allowPlain = b;
 342 }
 343
 344 void ClientStream::setRequireMutualAuth(bool b)
 345 {
 346         d->mutualAuth = b;
 347 }
 348
 349 // void ClientStream::setSSFRange(int low, int high)
 350 // {
 351 //      d->minimumSSF = low;
 352 //      d->maximumSSF = high;
 353 // }
 354
 355 // void ClientStream::setOldOnly(bool b)
 356 // {
 357 //      d->oldOnly = b;
 358 // }
 359
 360 bool ClientStream::transfersAvailable() const
 361 {
 362         return ( !d->in.isEmpty() );
 363 }
 364
 365 Transfer * ClientStream::read()
 366 {
 367         if(d->in.isEmpty())
 368                 return 0; //first from queue...
 369         else
 370                 return d->in.dequeue();
 371 }
 372
 373 void ClientStream::write( Request *request )
 374 {
 375         // pass to CoreProtocol for transformation into wire format
 376         d->client.outgoingTransfer( request );
 377 }
 378
 379 void cs_dump( const QByteArray &bytes )
 380 {
 381 //#define GW_CLIENTSTREAM_DEBUG 1
 382 #ifdef GW_CLIENTSTREAM_DEBUG
 383         CoreProtocol::debug( QString( "contains: %1 bytes " ).arg( bytes.count() ) );
 384         uint count = 0;
 385         while ( count < bytes.count() )
 386         {
 387                 int dword = 0;
 388                 for ( int i = 0; i < 8; ++i )
 389                 {
 390                         if ( count + i < bytes.count() )
 391                                 printf( "%02x ", bytes[ count + i ] );
 392                         else
 393                                 printf( "   " );
 394                         if ( i == 3 )
 395                                 printf( " " );
 396                 }
 397                 printf(" | ");
 398                 dword = 0;
 399                 for ( int i = 0; i < 8; ++i )
 400                 {
 401                         if ( count + i < bytes.count() )
 402                         {
 403                                 int j = bytes [ count + i ];
 404                                 if ( j >= 0x20 && j <= 0x7e )
 405                                         printf( "%2c ", j );
 406                                 else
 407                                         printf( "%2c ", '.' );
 408                         }
 409                         else
 410                                 printf( "   " );
 411                         if ( i == 3 )
 412                                 printf( " " );
 413                 }
 414                 printf( "\n" );
 415                 count += 8;
 416         }
 417         printf( "\n" );
 418 #else
 419         Q_UNUSED( bytes );
 420 #endif
 421 }
 422
 423 void ClientStream::cp_outgoingData( const QByteArray& outgoingBytes )
 424 {
 425         // take formatted bytes from CoreProtocol and put them on the wire
 426 #ifdef LIBGW_DEBUG
 427         CoreProtocol::debug( "ClientStream::cp_outgoingData:" );
 428         cs_dump( outgoingBytes );
 429 #endif
 430         d->ss->write( outgoingBytes );
 431 }
 432
 433 void ClientStream::cp_incomingData()
 434 {
 435         CoreProtocol::debug( "ClientStream::cp_incomingData:" );
 436         Transfer * incoming = d->client.incomingTransfer();
 437         if ( incoming )
 438         {
 439                 CoreProtocol::debug( " - got a new transfer" );
 440                 d->in.enqueue( incoming );
 441                 d->newTransfers = true;
 442                 emit doReadyRead();
 443         }
 444         else
 445                 CoreProtocol::debug( QString( " - client signalled incomingData but none was available, state is: %1" ).arg( d->client.state() ) );
 446 }
 447
 448 void ClientStream::cr_connected()
 449 {
 450         d->bs = d->conn->stream();
 451         connect(d->bs, SIGNAL(connectionClosed()), SLOT(bs_connectionClosed()));
 452         connect(d->bs, SIGNAL(delayedCloseFinished()), SLOT(bs_delayedCloseFinished()));
 453
 454         QByteArray spare = d->bs->read();
 455
 456         d->ss = new SecureStream(d->bs);
 457         connect(d->ss, SIGNAL(readyRead()), SLOT(ss_readyRead()));
 458         connect(d->ss, SIGNAL(bytesWritten(int)), SLOT(ss_bytesWritten(int)));
 459         connect(d->ss, SIGNAL(tlsHandshaken()), SLOT(ss_tlsHandshaken()));
 460         connect(d->ss, SIGNAL(tlsClosed()), SLOT(ss_tlsClosed()));
 461         connect(d->ss, SIGNAL(error(int)), SLOT(ss_error(int)));
 462
 463         //d->client.startDialbackOut("andbit.net", "im.pyxa.org");
 464         //d->client.startServerOut(d->server);
 465
 466 //      d->client.startClientOut(d->jid, d->oldOnly, d->conn->useSSL(), d->doAuth);
 467 //      d->client.setAllowTLS(d->tlsHandler ? true: false);
 468 //      d->client.setAllowBind(d->doBinding);
 469 //      d->client.setAllowPlain(d->allowPlain);
 470
 471         /*d->client.jid = d->jid;
 472         d->client.server = d->server;
 473         d->client.allowPlain = d->allowPlain;
 474         d->client.oldOnly = d->oldOnly;
 475         d->client.sasl_mech = d->sasl_mech;
 476         d->client.doTLS = d->tlsHandler ? true: false;
 477         d->client.doBinding = d->doBinding;*/
 478
 479         QPointer<QObject> self = this;
 480         emit connected();
 481         if(!self)
 482                 return;
 483
 484         // immediate SSL?
 485         if(d->conn->useSSL()) {
 486                 CoreProtocol::debug( "CLIENTSTREAM: cr_connected(), starting TLS" );
 487                 d->using_tls = true;
 488                 d->ss->startTLSClient(d->tlsHandler, d->server, spare);
 489         }
 490         else {
 491 /*              d->client.addIncomingData(spare);
 492                 processNext();*/
 493         }
 494 }
 495
 496 void ClientStream::cr_error()
 497 {
 498         reset();
 499         emit error(ErrConnection);
 500 }
 501
 502 void ClientStream::bs_connectionClosed()
 503 {
 504         reset();
 505         emit connectionClosed();
 506 }
 507
 508 void ClientStream::bs_delayedCloseFinished()
 509 {
 510         // we don't care about this (we track all important data ourself)
 511 }
 512
 513 void ClientStream::bs_error(int)
 514 {
 515         // TODO
 516 }
 517
 518 void ClientStream::ss_readyRead()
 519 {
 520         QByteArray a;
 521         a = d->ss->read();
 522
 523 #ifdef LIBGW_DEBUG
 524         QByteArray cs(a.data(), a.size()+1);
 525         CoreProtocol::debug( QString( "ClientStream: ss_readyRead() recv: %1 bytes" ).arg( a.size() ) );
 526         cs_dump( a );
 527 #endif
 528
 529         d->client.addIncomingData(a);
 530 /*      if(d->notify & CoreProtocol::NRecv) { */
 531         //processNext();
 532 }
 533
 534 void ClientStream::ss_bytesWritten(int bytes)
 535 {
 536 #ifdef LIBGW_DEBUG
 537         CoreProtocol::debug( QString( "ClientStream::ss_bytesWritten: %1 bytes written" ).arg( bytes ) );
 538 #else
 539         Q_UNUSED( bytes );
 540 #endif
 541 }
 542
 543 void ClientStream::ss_tlsHandshaken()
 544 {
 545         QPointer<QObject> self = this;
 546         emit securityLayerActivated(LayerTLS);
 547         if(!self)
 548                 return;
 549         processNext();
 550 }
 551
 552 void ClientStream::ss_tlsClosed()
 553 {
 554         CoreProtocol::debug( "ClientStream::ss_tlsClosed()" );
 555         reset();
 556         emit connectionClosed();
 557 }
 558
 559 void ClientStream::ss_error(int x)
 560 {
 561         CoreProtocol::debug( QString( "ClientStream::ss_error() x=%1 ").arg( x ) );
 562         if(x == SecureStream::ErrTLS) {
 563                 reset();
 564                 d->errCond = TLSFail;
 565                 emit error(ErrTLS);
 566         }
 567         else {
 568                 reset();
 569                 emit error(ErrSecurityLayer);
 570         }
 571 }
 572
 573 void ClientStream::srvProcessNext()
 574 {
 575 }
 576
 577 void ClientStream::doReadyRead()
 578 {
 579         //QPointer<QObject> self = this;
 580         emit readyRead();
 581         //if(!self)
 582         //      return;
 583         //d->in_rrsig = false;
 584 }
 585
 586 void ClientStream::processNext()
 587 {
 588         if( !d->in.isEmpty() ) {
 589                 //d->in_rrsig = true;
 590                 QTimer::singleShot(0, this, SLOT(doReadyRead()));
 591         }
 592 }
 593
 594 bool ClientStream::handleNeed()
 595 {
 596         return false;
 597 }
 598
 599
 600 void ClientStream::doNoop()
 601 {
 602 }
 603
 604 void ClientStream::handleError()
 605 {
 606 }
 607
 608 #include "gwclientstream.moc"