krfbconnection.cpp

Go to the documentation of this file.

#include "krfbconnection.h"
#include "krfblogin.h"
#include "krfbdecoder.h"
#include "krfbbuffer.h"

/* OPIE */
#include <opie2/odebug.h>
using namespace Opie::Core;

/* QT */
#include <qsocket.h>
#include <qtimer.h>

/* STD */
#include <assert.h>
#include <string.h>

KRFBConnection::KRFBConnection( QObject *parent )
                : QObject( parent, "KRFBConnection" )
{
                portBase_ = 5900;
                currentState_ = Disconnected;
                sock = 0;
                minData_ = 0;
                options_ = new KRFBServer();
                updater = 0;
                decoder_ = 0;
                buffer_ = 0;
}

KRFBConnection::~KRFBConnection()
{
                if ( ( currentState_ != Disconnected ) && ( currentState_ != Disconnecting ) && sock ) {
                                disconnectDone();
                }
                delete options_;
}

void KRFBConnection::connectTo( KRFBServer server)
{
                if ( currentState_ != Disconnected )
                                disconnect();
                
    (*options_)=server;

                sock = new QSocket( this, "rfbSocket" );
                CHECK_PTR( sock );

                // Connect to something to notice connection or error
                connect( sock, SIGNAL( error(int) ), SLOT( gotSocketError(int) ) );
                connect( sock, SIGNAL( connected() ), SLOT( gotSocketConnection() ) );

                owarn << "Connecting..." << oendl; 

                currentState_ = Connecting;
                sock->connectToHost( options_->hostname.latin1(), portBase_ + options_->display );
}

void KRFBConnection::disconnect()
{
                owarn << "Disconnecting from server" << oendl; 

                if ( ( currentState_ != Disconnected )
                                                && ( currentState_ != Disconnecting )
                                                && sock ) {
                                currentState_ = Disconnecting;

                                connect( sock, SIGNAL( delayedCloseFinished() ), SLOT( disconnectDone() ) );
                                sock->close();

                                if ( sock->state() != QSocket::Closing )
                                                disconnectDone();
                }
}

void KRFBConnection::disconnectDone()
{
                currentState_ = Disconnected;
                delete sock;
                sock = 0;
                minData_ = 0;
                delete updater;
                delete decoder_;
                delete buffer_;
                emit disconnected();
}

void KRFBConnection::gotSocketConnection()
{
                currentState_ = LoggingIn;

                owarn << "Connected, logging in..." << oendl; 

                static QString statusMsg = tr( "Connected" );
                emit statusChanged( statusMsg );

                // Do some login stuff
                login = new KRFBLogin( this );
}

void KRFBConnection::gotRFBConnection()
{
                owarn << "Logged into server" << oendl; 

                currentState_ = Connected;
                emit connected();

                // Create the decoder and start doing stuff
                decoder_ = new KRFBDecoder( this );
                CHECK_PTR( decoder_ );

                buffer_ = new KRFBBuffer( decoder_, this, "RFB Buffer" );
                CHECK_PTR( buffer_ );
                decoder_->setBuffer( buffer_ );

                connect( decoder_, SIGNAL( status(const QString&) ),
                                                this, SIGNAL( statusChanged(const QString&) ) );
                emit loggedIn();

                decoder_->start();

                updater = new QTimer;
                connect( updater, SIGNAL( timeout() ), SLOT( updateTimer() ) );
                updater->start( options_->updateRate );
}

void KRFBConnection::gotSocketError( int err )
{
                currentState_ = Error;

                // Do some error handling stuff
                owarn << "KRFBConnection: Socket error " << err << "" << oendl; 

                static QString refused = tr( "Connection Refused" );
                static QString host = tr( "Host not found" );
                static QString read = tr( "Read Error: QSocket reported an error reading\n"
                                                "data, the remote host has probably dropped the\n"
                                                "connection." );
                static QString confused = tr( "QSocket reported an invalid error code" );

                QString msg;
                switch ( err ) {
                                case QSocket::ErrConnectionRefused:
                                                msg = refused;
                                                break;
                                case QSocket::ErrHostNotFound:
                                                msg = host;
                                                break;
                                case QSocket::ErrSocketRead:
                                                msg = read;
                                                break;
                                default:
                                                msg = confused;
                };

                QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
                delete sock;
                sock = 0;
                currentState_ = Disconnected;

                emit error( msg );
}

void KRFBConnection::gotMoreData()
{
                assert( minData_ > 0 );

                if ( sock->size() >= minData_ ) {
                                minData_ = 0;
                                QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
                                emit gotEnoughData();
                }
}

void KRFBConnection::waitForData( unsigned int sz )
{
                assert( minData_ == 0 );
                assert( sz > 0 );
                assert( currentState_ != Error );

                if ( sock->size() >= sz ) {
                                //    owarn << "No need to wait for data" << oendl; 
                                emit gotEnoughData();
                }
                else {
                                //    owarn << "Waiting for " << sz << " bytes" << oendl; 
                                minData_ = sz;
                                connect( sock, SIGNAL( readyRead() ), SLOT( gotMoreData() ) );
                }
}

int KRFBConnection::read( void *buf, int sz )
{
                return sock->readBlock( (char *)  buf, sz );
}

int KRFBConnection::write( void *buf, int sz )
{
                return sock->writeBlock( (const char *) buf, sz );
}

KRFBConnection::State KRFBConnection::state() const
{
                return currentState_;
}

void KRFBConnection::setPortBase( int base )
{
                portBase_ = base;
}

int KRFBConnection::portBase() const
{
                return portBase_;
}

void KRFBConnection::updateTimer()
{
                decoder_->sendUpdateRequest( true );
}

void KRFBConnection::refresh()
{
                decoder_->sendUpdateRequest( false );
}

void KRFBConnection::sendCutText( const QString &text )
{
                decoder_->sendCutEvent( text );
}

const QUrl &KRFBConnection::url()
{
                url_.setProtocol( "vnc" );
                url_.setPort( display() );
                url_.setHost( host() );
                url_.setPath( "/" );

                return url_;
}

---