Keystone README

What is Keystone?
Servers
Status
Bugs
Download
FAQs
Todo
Credits
References

What is Keystone?

Keystone is a tool for KDE that + allows you to remotely access the desktops of machines using the cross-platform + VNC system. Keystone can access machines running a variety of operating + systems (including most UNIX systems and Windows 95/98/NT/2000) providing + they are running a VNC server. Note that Keystone is only a client + program, you will need to download a server separately in order to + use it.

The protocol used by Keystone (called RFB) was developed, and released + as GPL by ORL (now the UK branch of AT&T research), they also + wrote and maintain GPL servers for several platforms. You can find + both information about the protocol and links to servers for a range + of platforms on their website.

Keystone started life as a port of Markus Wuebben's kvncviewer program + to KDE 2, but in the course porting the code, I have rewritten and + redesigned most of the system. The new implementation builds on several + new facilities that were not available in KDE 1, such as KPixmapIO + and QSocket. There is so little of the original code left that I have + decided on a name change, and to put the version number back to 0.1.

You can see a few screenshots of Keystone + in action on my screenshots page. The screenshots may or may not + reflect the look of the current version as I have some look and feel + improvements planned.

Servers

Most Linux distributions include the standard Xvnc server (usually + run via the vncserver script), you can also download this and + servers for other platforms such as MS Windows from the VNC + website. If you have a problem with setting up a server then you + should read the VNC + FAQ, and if that does not help join the VNC mailing list. Do not + mail me on this topic - I can't help and won't even reply.

I may in future write a server that operates in the same manner as + the Win32 server for KDE. The Win32 server differs from the X11 server + in that it does not virtualise the entire desktop. This has both advantages + and disadvatages, it means that you can make an existing session available + over the network, but only allows you to run a single server. I may + also put a GUI together that makes it easy to configure the ORL server.

Status

The current version is 0.4, and the following + are now working:

0.1 +
- Non-blocking socket handling
- Authentication and logon
- KDE 2 user interface
- Raw and CopyRect encodings
- Full screen mode
- Grab keyboard mode
- Graphics
- Taking screenshots of the remote desktop
- Event dispatching
- Konqueror helper application support (you can run Keystone + by entering a vnc: URL anywhere in KDE).
- Options, login, password and about dialogs
+
0.2 +
- XSHM support using KPixmapIO
- Now uses KXMLGUI (thanks to Kurt)
- Tru64 patch from Tom Leitner
- Status reporting improvements
- Config handling fixed
- Recent connections list implemented
- Update frequency respected
+
0.3 [KDE 2.0] +
- Portability fixes for FreeBSD (and maybe others)
+
0.4 +
- Icons for the full screen mode now reflect the current state
- Added a toolbar (optional of course)
- Added support for the clipboard (you can cut and paste between the + local and remote machines)
- Added some what's this help to the options dialog
+

Bugs

Version 0.4 contains the following known bugs: +

Custom about dialog is not shown
+ I can't see a clean way to fix this without creating a complete custom + help menu. For now I've left the standard about dialog in place. +
Crash when you connect to a non-existant server
+ I can reproduce this every time, but I can't figure out what's wrong + other developers have reported similar problems and they seem to be + down to QSocket. The only known fix so far is to use KSocket instead. + I'd prefer to fix the problem at the source, but I'm having no luck and + I suspect QSocket may also be causing some other weird network issues + I've seen, so if I can't track down the bug soon I'll give in and switch + to KSocket like everyone else. +

Download

Keystone is available in the kdenetwork module of the + KDE CVS, and + is included in the KDE 2.0 release. The current version is 0.4. + Note that Keystone requires KDE 2, you cannot use KDE 1.x.

FAQs

Why don't the shortcut keys work in full screen mode?
+ When you're in full screen mode Keystone grabs the keyboard to send + every key press to the remote screen. This means that you can send key + combinations that are used by Keystone or KDE to the remote screen. If + you really hate it, then you can add -nograb to the command line + arguments to disable all keyboard grabs. I will add an option to allow + this behaviour to be overridden in a future release. +
Why is Keystone so slow?
+ Currently only the simplest of the RFB encodings are supported, this + means that Keystone is only useful on fairly fast networks. This is + a serious bug and is being addressed. +

Todo

+ These are the things I'm hoping to add to future versions of Keystone. + They're vaguely sorted in order of importance. +

RRE encoding.
+ I've started this, but the implementation has some + bugs so it did not make the cut for Keystone 0.3.
CoRRE and Hextile encodings
Session management
Support for Windows Terminal Server.
+ There is now a GPL implementation + of the protocol, and the author is happy for me to use the code. If someone + can offer me an account to test it on then this is possible.
Zoom support.
+ This will be handled using the same protocol extension + as is used in the Palm client, this will allow you to make use of + server side scaling to reduce the amount of network traffic. You + will also be able to do client side zooms, but in this case the + full screen needs to transmitted over the network.
Macros
Monitor mode (thumbnails of several machines)
ZLib extension support
Bookmarks
URL specific settings
Possibly a DnD extension using a mechanism based on mulitpart + MIME attachments.

Credits

Keystone owes a lot to Markus Wuebben's kvncviewer which some of + the code is derived from. Thanks are also due to Espen Sand the author + of khexedit from which I borrowed some code for the about dialog. + Alison Burch drew the bridge image used in the background of this + page (and in future versions of Keystone too of course). Finally thanks + go to ORL for making the RFB protocol and servers GPL.

References
+

The Keystone homepage
+ http://www.ipso-facto.demon.co.uk/keystone/
The VNC Homepage
+ http://www.uk.research.att.com/vnc/
The VNC FAQ
+ http://www.uk.research.att.com/vnc/faq.html
The KDE Homepage
+ http://www.kde.org/

+#include +#include +#include +#include +#include +#include "krfbdecoder.h" +#include "krfbbuffer.h" +#include "krfbserverinfo.h" + +// +// Endian stuff +// +#ifndef KDE_USE_FINAL +const int endianTest = 1; +#endif + +#define Swap16IfLE(s) \ + (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s)) + +#define Swap32IfLE(l) \ + (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \ + (((l) & 0x00ff0000) >> 8) | \ + (((l) & 0x0000ff00) << 8) | \ + (((l) & 0x000000ff) << 24)) : (l)) + +KRFBBuffer::KRFBBuffer( KRFBDecoder *decoder, + QObject *parent, const char *name ) + : QObject( parent, name ) +{ + assert( decoder ); + this->decoder = decoder; + pix = new QPixmap(); +} + +KRFBBuffer::~KRFBBuffer() +{ + delete pix; +} + +void KRFBBuffer::resize( int w, int h ) +{ + qWarning( "Resizing buffer" ); + + pix->resize( w, h ); + + QPalette pal = qApp->palette(); + pix->fill( pal.active().base() ); + + emit sizeChanged( w, h ); +} + +void KRFBBuffer::soundBell() +{ + emit bell(); +} + +void KRFBBuffer::mouseEvent( QMouseEvent *e ) +{ + decoder->sendMouseEvent( e ); +} + +void KRFBBuffer::keyPressEvent( QKeyEvent *e ) +{ + qWarning( "Buffer got a key" ); + + decoder->sendKeyPressEvent( e ); +} + +void KRFBBuffer::keyReleaseEvent( QKeyEvent *e ) +{ + decoder->sendKeyReleaseEvent( e ); +} + +void KRFBBuffer::copyRect( int srcX, int srcY, + int destX, int destY, int w, int h ) +{ +// qWarning( "Got copy rect" ); + bitBlt( pix, destX, destY, pix, srcX, srcY, w, h, CopyROP ); + + emit updated( destX, destY, w, h ); +} + +void KRFBBuffer::drawRawRectChunk( void *data, + int x, int y, int w, int h ) +{ + QImage img( w, h, 32 ); + + int redMax = Swap16IfLE( decoder->format->redMax ); + int greenMax = Swap16IfLE( decoder->format->greenMax ); + int blueMax = Swap16IfLE( decoder->format->blueMax ); + + QPainter p( pix ); + + if ( decoder->format->bpp == 8 ) { + uchar *d = (unsigned char *) data; + + uint r,g,b; + + for ( int j = 0; j < h; j++ ) { + for ( int i = 0; i < w ; i++ ) { + r = d[ j * w + i ]; + r = r >> decoder->format->redShift; + r = r & redMax; + + g = d[ j * w + i ]; + g = g >> decoder->format->greenShift; + g = g & greenMax; + + b = d[ j * w + i ]; + b = b >> decoder->format->blueShift; + b = b & blueMax; + + r = ( r * 255 ) / redMax; + g = ( g * 255 ) / greenMax; + b = ( b * 255 ) / blueMax; + + uint *p = ( uint * ) img.scanLine( j ) + i; + *p = qRgb( r,g,b ); + } + } + } + else if ( decoder->format->bpp == 32 ) { + ulong *d = (ulong *) data; + + ulong r,g,b; + + for ( int j = 0; j < h; j++ ) { + for ( int i = 0; i < w ; i++ ) { + ulong pixel = d[ j * w + i ]; + pixel = Swap32IfLE( pixel ); + + r = pixel; + r = r >> decoder->format->redShift; + r = r & redMax; + + g = pixel; + g = g >> decoder->format->greenShift; + g = g & greenMax; + + b = pixel; + b = b >> decoder->format->blueShift; + b = b & blueMax; + + r = ( r * 255 ) / redMax; + g = ( g * 255 ) / greenMax; + b = ( b * 255 ) / blueMax; + + uint *p = ( uint * ) img.scanLine( j ) + i; + *p = qRgb( r,g,b ); + } + } + } + else { + p.setBrush( QBrush( Qt::black ) ); + p.drawRect( x, y, w, h ); + } + + p.drawImage( x, y, img ); + + emit updated( x, y, w, h ); +} + diff --git a/noncore/comm/keypebble/krfbbuffer.h b/noncore/comm/keypebble/krfbbuffer.h new file mode 100644 index 0000000..1116d00 --- a/dev/null +++ b/noncore/comm/keypebble/krfbbuffer.h @@ -0,0 +1,62 @@ +// -*- c++ -*- + +#ifndef KRFBBUFFER_H +#define KRFBBUFFER_H + +#include + +class QPixmap; +class KRFBDecoder; +class QMouseEvent; +class QKeyEvent; + +/** + * A wrapper around QPixmap that knows how to implement the RFB + * drawing primitives. If possible it makes use of the MIT XSHM + * extension to optimise the drawing operations. + */ +class KRFBBuffer : public QObject +{ + Q_OBJECT + +public: + KRFBBuffer( KRFBDecoder *decoder, QObject *parent, const char *name=0 ); + ~KRFBBuffer(); + + QPixmap *pixmap() const { return pix; }; + + /** + * Draw a chunk of a raw encoded rectangle. + */ + void drawRawRectChunk( void *data, int x, int y, int w, int h ); + + void copyRect( int srcX, int srcY, + int destX, int destY, int w, int h ); + + void fillRect( int ,int , int , int , unsigned long ) {}; + + void resize( int w, int h ); + + void mouseEvent( QMouseEvent *e ); + + void keyPressEvent( QKeyEvent *e ); + void keyReleaseEvent( QKeyEvent *e ); + + void soundBell(); + +signals: + /** + * Emitted when the size of the buffer changes. + */ + void sizeChanged( int w, int h ); + + void updated( int x, int y, int w, int h ); + + void bell(); + +private: + KRFBDecoder *decoder; + QPixmap *pix; +}; + +#endif // KRFBBUFFER_H diff --git a/noncore/comm/keypebble/krfbcanvas.cpp b/noncore/comm/keypebble/krfbcanvas.cpp new file mode 100644 index 0000000..f74ab7b --- a/dev/null +++ b/noncore/comm/keypebble/krfbcanvas.cpp @@ -0,0 +1,169 @@ +#include "kvncconnectdlg.h" +#include "krfbconnection.h" +#include "krfbcanvas.h" +#include "krfboptions.h" +#include "krfbbuffer.h" + +#include + +#include +#include +#include +#include +#include +#include +#include + +KRFBCanvas::KRFBCanvas( QWidget *parent, const char *name ) + : QScrollView( parent, name ) +{ + connection_ = new KRFBConnection(); + connect( connection_, SIGNAL( passwordRequired( KRFBConnection * ) ), + this, SLOT( passwordRequired( KRFBConnection * ) ) ); + connect( connection_, SIGNAL( loggedIn() ), + this, SLOT( loggedIn() ) ); + + loggedIn_ = false; + + viewport()->setFocusPolicy( QWidget::StrongFocus ); + viewport()->setFocus(); +} + +KRFBCanvas::~KRFBCanvas() +{ +} + +void KRFBCanvas::openConnection() +{ + KVNCConnectDlg dlg( connection_, this, "connect dialog" ); + if ( dlg.exec() ) { + QCString host = dlg.hostname().latin1(); + password = dlg.password(); + connection_->connectTo( host, dlg.display() ); + } +} + +void KRFBCanvas::openURL( const QUrl &url ) +{ + if ( loggedIn_ ) { + qWarning( "openURL invoked when logged in\n" ); + return; + } + + QCString host = url.host().latin1(); + int display = url.port(); + if ( url.hasPassword() ) + connection_->setPassword( url.password().latin1() ); + + connection_->connectTo( host, display ); +} + +void KRFBCanvas::closeConnection() +{ + loggedIn_ = false; + connection_->disconnect(); + + viewport()->setMouseTracking( false ); + viewport()->setBackgroundMode( PaletteDark ); + setBackgroundMode( PaletteDark ); + update(); +} + +void KRFBCanvas::passwordRequired( KRFBConnection *con ) +{ + con->setPassword( password.latin1() ); +} + +void KRFBCanvas::bell() +{ + if ( connection_->options()->deIconify ) { + topLevelWidget()->raise(); + topLevelWidget()->show(); + } +} + +void KRFBCanvas::loggedIn() +{ + qWarning( "Ok, we're logged in" ); + + // + // Get ready for action + // + loggedIn_ = true; + viewport()->setMouseTracking( true ); + viewport()->setBackgroundMode( NoBackground ); + setBackgroundMode( NoBackground ); + + // Start using the buffer + connect( connection_->buffer(), SIGNAL( sizeChanged( int, int ) ), + this, SLOT( resizeContents(int,int) ) ); + connect( connection_->buffer(), SIGNAL( updated( int, int, int, int ) ), + this, SLOT( viewportUpdate(int,int,int,int) ) ); + connect( connection_->buffer(), SIGNAL( bell() ), + this, SLOT( bell() ) ); + connect( qApp->clipboard(), SIGNAL( dataChanged() ), + this, SLOT( clipboardChanged() ) ); +} + +void KRFBCanvas::viewportPaintEvent( QPaintEvent *e ) +{ + QRect r = e->rect(); + + if ( loggedIn_ ) { + bitBlt( viewport(), r.x(), r.y(), + connection_->buffer()->pixmap(), + r.x() + contentsX(), r.y() + contentsY(), + r.width(), r.height() ); + } + else { + QScrollView::viewportPaintEvent( e ); + } +} + +void KRFBCanvas::viewportUpdate( int x, int y, int w, int h ) +{ + updateContents( x, y, w, h ); +} + +void KRFBCanvas::contentsMousePressEvent( QMouseEvent *e ) +{ + if ( loggedIn_ ) + connection_->buffer()->mouseEvent( e ); +} + +void KRFBCanvas::contentsMouseReleaseEvent( QMouseEvent *e ) +{ + if ( loggedIn_ ) + connection_->buffer()->mouseEvent( e ); +} + +void KRFBCanvas::contentsMouseMoveEvent( QMouseEvent *e ) +{ + if ( loggedIn_ ) + connection_->buffer()->mouseEvent( e ); +} + +void KRFBCanvas::keyPressEvent( QKeyEvent *e ) +{ + if ( loggedIn_ ) + connection_->buffer()->keyPressEvent( e ); +} + +void KRFBCanvas::keyReleaseEvent( QKeyEvent *e ) +{ + if ( loggedIn_ ) + connection_->buffer()->keyReleaseEvent( e ); +} + +void KRFBCanvas::refresh() +{ + if ( loggedIn_ ) + connection_->refresh(); +} + +void KRFBCanvas::clipboardChanged() +{ + if ( loggedIn_ ) { + connection_->sendCutText( qApp->clipboard()->text() ); + } +} diff --git a/noncore/comm/keypebble/krfbcanvas.h b/noncore/comm/keypebble/krfbcanvas.h new file mode 100644 index 0000000..7864f1c --- a/dev/null +++ b/noncore/comm/keypebble/krfbcanvas.h @@ -0,0 +1,54 @@ +// -*- c++ -*- + +#ifndef KRFBCANVAS_H +#define KRFBCANVAS_H + +#include +#include + +class KRFBConnection; + +/** + * Displays data from an KRFBDecoder, and sends events to the + * KRFBConnection. + */ +class KRFBCanvas : public QScrollView +{ + Q_OBJECT +public: + KRFBCanvas( QWidget *parent, const char *name=0 ); + ~KRFBCanvas(); + + void setConnection( KRFBConnection * ); + KRFBConnection *connection() { return connection_; }; + +public slots: + void openConnection(); + void openURL( const QUrl & ); + void closeConnection(); + void passwordRequired( KRFBConnection * ); + + void refresh(); + void bell(); + +protected: + virtual void keyPressEvent( QKeyEvent * ); + virtual void keyReleaseEvent( QKeyEvent * ); + virtual void contentsMousePressEvent( QMouseEvent * ); + virtual void contentsMouseReleaseEvent( QMouseEvent * ); + virtual void contentsMouseMoveEvent( QMouseEvent * ); + + virtual void viewportPaintEvent( QPaintEvent *e ); + +protected slots: + void loggedIn(); + void viewportUpdate( int x, int y, int w, int h ); + void clipboardChanged(); + +private: + KRFBConnection *connection_; + QString password; + bool loggedIn_; +}; + +#endif // KRFBCANVAS_H diff --git a/noncore/comm/keypebble/krfbconnection.cpp b/noncore/comm/keypebble/krfbconnection.cpp new file mode 100644 index 0000000..c413186 --- a/dev/null +++ b/noncore/comm/keypebble/krfbconnection.cpp @@ -0,0 +1,242 @@ +#include +#include +#include +#include + +#include "krfbconnection.h" +#include "krfblogin.h" +#include "krfboptions.h" +#include "krfbdecoder.h" +#include "krfbbuffer.h" + +KRFBConnection::KRFBConnection( QObject *parent ) + : QObject( parent, "KRFBConnection" ) +{ + portBase_ = 5900; + currentState_ = Disconnected; + sock = 0; + minData_ = 0; + options_ = new KRFBOptions(); + updater = 0; + decoder_ = 0; + buffer_ = 0; +} + +KRFBConnection::~KRFBConnection() +{ + if ( ( currentState_ != Disconnected ) && ( currentState_ != Disconnecting ) && sock ) { + disconnectDone(); + } + delete options_; +} + +void KRFBConnection::connectTo( const QCString &host, int display ) +{ + if ( currentState_ != Disconnected ); + disconnect(); + + this->host_= host; + this->display_ = display; + + 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() ) ); + + qWarning( "Connecting..." ); + + currentState_ = Connecting; + sock->connectToHost( host_, portBase_ + display_ ); +} + +void KRFBConnection::disconnect() +{ + qWarning( "Disconnecting from server" ); + + 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() +{ + qWarning( "KRFBConnection disconnected" ); + currentState_ = Disconnected; + delete sock; + sock = 0; + minData_ = 0; + delete updater; + delete decoder_; + delete buffer_; + emit disconnected(); +} + +void KRFBConnection::gotSocketConnection() +{ + currentState_ = LoggingIn; + + qWarning( "Connected, logging in..." ); + + static QString statusMsg = tr( "Connected" ); + emit statusChanged( statusMsg ); + + // Do some login stuff + login = new KRFBLogin( this ); +} + +void KRFBConnection::gotRFBConnection() +{ + qWarning( "Logged into server" ); + + 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 errno ) +{ + currentState_ = Error; + + // Do some error handling stuff + qWarning( "KRFBConnection: Socket error %d", errno ); + + 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 ( errno ) { + 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 ) { + // qWarning( "No need to wait for data" ); + emit gotEnoughData(); + } + else { + // qWarning( "Waiting for %u bytes", sz ); + + 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::setPassword( const QCString &pass ) +{ + this->pass_ = pass; +} + +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_; +} diff --git a/noncore/comm/keypebble/krfbconnection.h b/noncore/comm/keypebble/krfbconnection.h new file mode 100644 index 0000000..fe477c1 --- a/dev/null +++ b/noncore/comm/keypebble/krfbconnection.h @@ -0,0 +1,152 @@ +// -*- c++ -*- + +#ifndef KRFBCONNECTION_H +#define KRFBCONNECTION_H + +#include +#include +#include +#include + +class KRFBLogin; +class KRBUpdateHandler; +class KRFBOptions; +class QSocket; +class KRFBDecoder; +class KRFBBuffer; +class QTimer; + +/** + * Encapsulates the RFB socket. + * + */ +class KRFBConnection : public QObject +{ + Q_OBJECT + +public: + friend class KRFBLogin; + friend class KRFBDecoder; + + //* The state of the connection. + enum State { + Connecting, + LoggingIn, + Connected, + Disconnecting, + Disconnected, + Error + }; + + KRFBConnection( QObject *parent = 0 ); + ~KRFBConnection(); + + //* Get the state of a connection. + State state() const; + + //* Get the options for this connection + KRFBOptions *options() const { return options_; }; + + KRFBBuffer *buffer() const { return buffer_; }; + + KRFBDecoder *decoder() const { return decoder_; }; + + //* Set the base from which the port for a given display will be calculated. + void setPortBase( int base ); + + //* Get the base from which the port for a given display is calculated. + int portBase() const; + + //* Set the password which will be used to login + void setPassword( const QCString &pass ); + + //* Open a connection + void connectTo( const QCString &host, int display ); + + //* Close the connection + void disconnect(); + + //* Get the host + const QCString host() const { return host_; }; + + //* Get the display + int display() const { return display_; }; + + //* Get the current host/display as a URL + const QUrl &url(); + + //* Reload the display + void refresh(); + + //* Send text to the remote clipboard + void sendCutText( const QString & ); + +protected slots: + //* When the shit hits the fan + void gotSocketError( int ); + + //* When we have an open socket + void gotSocketConnection(); + + //* When we have logged in + void gotRFBConnection(); + + //* When some more data arrived + void gotMoreData(); + + void updateTimer(); + + void disconnectDone(); + +signals: + //* Emitted when the status of the connection changes. + void statusChanged( const QString & ); + + /** + * Emitted when we *really* need a password. If the password + * was specified before you tried to connect then you won't + * see this. + */ + void passwordRequired( KRFBConnection * ); + + //* When we have a working RFB connection + void connected(); + + void loggedIn(); + + void disconnected(); + + //* What happened? + void error( const QString &msg ); + + //* Emitted in response to a waitForData() call. + void gotEnoughData(); + +private: + // + // The following are called by our friends. + // + + void waitForData( unsigned int ); + + int read( void *buf, int sz ); + int write( void *buf, int sz ); + +private: + QCString host_; + int portBase_; + int display_; + QCString pass_; + QSocket *sock; + State currentState_; + unsigned int minData_; + QTimer *updater; + KRFBLogin *login; + KRFBDecoder *decoder_; + KRFBOptions *options_; + KRFBBuffer *buffer_; + QUrl url_; +}; + +#endif // KRFBCONNECTION_H + diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp new file mode 100644 index 0000000..174dd7b --- a/dev/null +++ b/noncore/comm/keypebble/krfbdecoder.cpp @@ -0,0 +1,839 @@ +#include "krfbconnection.h" +#include "krfboptions.h" +#include "krfbserverinfo.h" +#include "krfbdecoder.h" +#include "krfbbuffer.h" + +#include + +#include +#include +#include +#include +#include + +#include + +// +// Endian stuff +// +#ifndef KDE_USE_FINAL +const int endianTest = 1; +#endif + +#define Swap16IfLE(s) \ + (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s)) + +#define Swap32IfLE(l) \ + (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \ + (((l) & 0x00ff0000) >> 8) | \ + (((l) & 0x0000ff00) << 8) | \ + (((l) & 0x000000ff) << 24)) : (l)) + +// +// The lengths of the messages we need to wait for +// +const int ServerInitLength = 24; +const int UpdateHeaderLength = 4; +const int RectHeaderLength = 12; +const int RectChunkSize = 4; +const int CopyRectPosLength = 4; +const int ServerCutLenLength = 7; + +// +// Client -> Server Message Identifiers +// +static CARD8 SetPixelFormatId = 0; +//static CARD8 FixColourMapEntriesId = 1; // Not used +static CARD8 SetEncodingsId = 2; +static CARD8 UpdateRequestId = 3; +static CARD8 KeyEventId = 4; +static CARD8 PointerEventId = 5; +static CARD8 ClientCutTextId = 6; + +// +// Server -> Client Message Identifiers +// +static CARD8 UpdateId = 0; +static CARD8 BellId = 2; +static CARD8 ServerCutId = 3; + +// +// Encoding identifiers +// +static CARD32 RawEncoding = Swap32IfLE( 0 ); +static CARD32 CopyRectEncoding = Swap32IfLE(1 ); +static CARD32 RreEncoding = Swap32IfLE( 2 ); +static CARD32 CorreEncoding = Swap32IfLE( 4 ); +static CARD32 HexTileEncoding = Swap32IfLE( 5 ); + +static struct { + int keysym; + int keycode; +} keyMap[] = { + { 0xff08, Qt::Key_Backspace }, + { 0xff09, Qt::Key_Tab }, + { 0xff0d, Qt::Key_Return }, + { 0xff1b, Qt::Key_Escape }, + { 0xff63, Qt::Key_Insert }, + { 0xffff, Qt::Key_Delete }, + { 0xff50, Qt::Key_Home }, + { 0xff57, Qt::Key_End }, + { 0xff55, Qt::Key_Prior }, + { 0xff56, Qt::Key_Next }, + { 0xff51, Qt::Key_Left }, + { 0xff52, Qt::Key_Up }, + { 0xff53, Qt::Key_Right }, + { 0xff54, Qt::Key_Down }, + { 0xffbe, Qt::Key_F1 }, + { 0xffbf, Qt::Key_F2 }, + { 0xffc0, Qt::Key_F3 }, + { 0xffc1, Qt::Key_F4 }, + { 0xffc2, Qt::Key_F5 }, + { 0xffc3, Qt::Key_F6 }, + { 0xffc4, Qt::Key_F7 }, + { 0xffc5, Qt::Key_F8 }, + { 0xffc6, Qt::Key_F9 }, + { 0xffc7, Qt::Key_F10 }, + { 0xffc8, Qt::Key_F11 }, + { 0xffc9, Qt::Key_F12 }, + { 0xffe1, Qt::Key_Shift }, + { 0xffe2, Qt::Key_Shift }, + { 0xffe3, Qt::Key_Control }, + { 0xffe4, Qt::Key_Control }, + { 0xffe7, Qt::Key_Meta }, + { 0xffe8, Qt::Key_Meta }, + { 0xffe9, Qt::Key_Alt }, + { 0xffea, Qt::Key_Alt }, + { 0, 0 } +}; + + +KRFBDecoder::KRFBDecoder( KRFBConnection *con ) + : QObject( con, "RFB Decoder" ) +{ + assert( con ); + assert( con->state() == KRFBConnection::Connected ); + + this->con = con; + this->buf = 0; + this->info = 0; + this->format = 0; + this->buttonMask = 0; + currentState = Idle; +} + +KRFBDecoder::~KRFBDecoder() +{ + if ( info ) + delete info; + if ( format ) + delete format; +} + +void KRFBDecoder::start() +{ + sendClientInit(); +} + +void KRFBDecoder::sendClientInit() +{ + con->write( &( con->options()->shared ), 1 ); + + // Wait for server init + qWarning( "Waiting for server init" ); + + static QString statusMsg = tr( "Waiting for server initialisation..." ); + emit status( statusMsg ); + + currentState = AwaitingServerInit; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerInit() ) ); + con->waitForData( ServerInitLength ); +} + +void KRFBDecoder::gotServerInit() +{ + qWarning( "Got server init" ); + disconnect( con, SIGNAL( gotEnoughData() ), this, SLOT( gotServerInit() ) ); + + if ( info ) + delete info; + info = new KRFBServerInfo; + CHECK_PTR( info ); + + con->read( &(info->width), 2 ); + info->width = Swap16IfLE( info->width ); + con->read( &info->height, 2 ); + info->height = Swap16IfLE( info->height ); + + con->read( &(info->bpp), 1 ); + con->read( &(info->depth), 1 ); + con->read( &(info->bigEndian), 1 ); + con->read( &(info->trueColor), 1 ); + + con->read( &(info->redMax), 2 ); + info->redMax = Swap16IfLE( info->redMax ); + con->read( &(info->greenMax), 2 ); + info->greenMax = Swap16IfLE( info->greenMax ); + con->read( &(info->blueMax), 2 ); + info->blueMax = Swap16IfLE( info->blueMax ); + + con->read( &(info->redShift), 1 ); + con->read( &(info->greenShift), 1 ); + con->read( &(info->blueShift), 1 ); + + con->read( info->padding, 3 ); + + con->read( &(info->nameLength), 4 ); + info->nameLength = Swap32IfLE( info->nameLength ); + + qWarning( "Width = %d, Height = %d", info->width, info->height ); + qWarning( "Bpp = %d, Depth = %d, Big = %d, True = %d", + info->bpp, info->depth, info->bigEndian, info->trueColor ); + qWarning( "RedMax = %d, GreenMax = %d, BlueMax = %d", + info->redMax, info->greenMax, info->blueMax ); + qWarning( "RedShift = %d, GreenShift = %d, BlueShift = %d", + info->redShift, info->greenShift,info-> blueShift ); + + buf->resize( info->width, info->height ); + + // Wait for desktop name + qWarning( "Waiting for desktop name" ); + + static QString statusMsg = tr( "Waiting for desktop name..." ); + emit status( statusMsg ); + + currentState = AwaitingDesktopName; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotDesktopName() ) ); + con->waitForData( info->nameLength ); +} + +void KRFBDecoder::gotDesktopName() +{ + assert( info ); + assert( currentState == AwaitingDesktopName ); + + qWarning( "Got desktop name" ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotDesktopName() ) ); + + char *buf = new char[ info->nameLength + 1 ]; + CHECK_PTR( buf ); + + con->read( buf, info->nameLength ); + buf[ info->nameLength ] = '\0'; + info->name = buf; + + qWarning( "Desktop: %s", info->name.latin1() ); + + delete buf; + + // Get the format we'll really use and tell the server + decidePixelFormat(); + sendPixelFormat(); + sendAllowedEncodings(); + currentState = Idle; + + QString msg; + msg = tr( "Connected to %1" ); + msg = msg.arg( info->name ); + emit status( msg ); + + sendUpdateRequest( false ); +} + +void KRFBDecoder::decidePixelFormat() +{ + assert( info ); + + if ( format ) + delete format; + format = new KRFBPixelFormat; + CHECK_PTR( format ); + + // What depth do we want? + // + // We'll use the minimum of the remote and local depths, UNLESS an + // eight bit session has been specifically requested by the user. + int screenDepth = QPixmap::defaultDepth(); + int bestDepth = ( screenDepth > info->depth ) ? info->depth : screenDepth; + int chosenDepth; + + if ( con->options()->colors256 ) + chosenDepth = 8; + else + chosenDepth = bestDepth; + + qWarning( "Screen depth=%d, server depth=%d, best depth=%d, " \ + "eight bit %d, chosenDepth=%d", + screenDepth, + info->depth, + bestDepth, + con->options()->colors256, chosenDepth ); + + format->depth = chosenDepth; + + // If we're using the servers native depth + if ( chosenDepth == info->depth ) { + // Use the servers native format + format->bpp = info->bpp; + // format->bigEndian = info->bigEndian; + format->bigEndian = true; + format->trueColor = info->trueColor; + format->redMax = info->redMax; + format->greenMax = info->greenMax; + format->blueMax = info->blueMax; + format->redShift = info->redShift; + format->greenShift = info->greenShift; + format->blueShift = info->blueShift; + } + else { + if ( chosenDepth == 8 ) { + format->bpp = 8; + format->bigEndian = true; + format->trueColor = true; + format->redMax = 7; + format->greenMax = 7; + format->blueMax = 3; + format->redShift = 0; + format->greenShift = 3; + format->blueShift = 6; + } + } + + format->redMax = Swap16IfLE( format->redMax ); + format->greenMax = Swap16IfLE( format->greenMax ); + format->blueMax = Swap16IfLE( format->blueMax ); +} + +void KRFBDecoder::sendPixelFormat() +{ + static char padding[3]; + con->write( &SetPixelFormatId, 1 ); + con->write( padding, 3 ); + + con->write( &(format->bpp), 1 ); + con->write( &(format->depth), 1 ); + con->write( &(format->bigEndian), 1 ); + con->write( &(format->trueColor), 1 ); + + con->write( &(format->redMax), 2 ); + con->write( &(format->greenMax), 2 ); + con->write( &(format->blueMax), 2 ); + + con->write( &(format->redShift), 1 ); + con->write( &(format->greenShift), 1 ); + con->write( &(format->blueShift), 1 ); + con->write( format->padding, 3 ); // Padding +} + +void KRFBDecoder::sendAllowedEncodings() +{ + static CARD8 padding[1]; + con->write( &SetEncodingsId, 1 ); + con->write( padding, 1 ); + + static CARD16 noEncodings = con->options()->encodings(); + noEncodings = Swap16IfLE( noEncodings ); + con->write( &noEncodings, 2 ); + + if ( con->options()->corre ) + con->write( &CorreEncoding, 4 ); + if ( con->options()->hexTile ) + con->write( &HexTileEncoding, 4 ); + if ( con->options()->rre ) + con->write( &RreEncoding, 4 ); + if ( con->options()->copyrect ) + con->write( &CopyRectEncoding, 4 ); + // We always support this + con->write( &RawEncoding, 4 ); +} + +void KRFBDecoder::sendUpdateRequest( bool incremental ) +{ + if ( currentState != Idle ) + return; + + con->write( &UpdateRequestId, 1 ); + con->write( &incremental, 1 ); + + static CARD16 x = 0, y = 0; + static CARD16 w = Swap16IfLE( info->width ); + static CARD16 h = Swap16IfLE( info->height ); + + con->write( &x, 2 ); + con->write( &y, 2 ); + con->write( &w, 2 ); + con->write( &h, 2 ); + + // Now wait for the update + currentState = AwaitingUpdate; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) ); + con->waitForData( UpdateHeaderLength ); +} + +void KRFBDecoder::gotUpdateHeader() +{ + assert( currentState == AwaitingUpdate ); + + // qWarning( "Got update header" ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotUpdateHeader() ) ); + + CARD8 msgType; + con->read( &msgType, 1 ); + + if ( msgType != UpdateId ) { + // We might have a bell or server cut + if ( msgType == ServerCutId ) { + oldState = currentState; + gotServerCut(); + } + else if ( msgType == BellId ) { + oldState = currentState; + gotBell(); + } + else { + int msg = msgType; + QString protocolError = tr( "Protocol Error: Message Id %1 was " + "found when expecting an update " + "message." ).arg( msg ); + currentState = Error; + emit error( protocolError ); + } + return; + } + + CARD8 padding; + con->read( &padding, 1 ); + + con->read( &noRects, 2 ); + noRects = Swap16IfLE( noRects ); + + // qWarning( "Expecting %d rects", noRects ); + + // Now wait for the data + currentState = AwaitingRectHeader; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) ); + con->waitForData( RectHeaderLength ); +} + +void KRFBDecoder::gotRectHeader() +{ + assert( currentState == AwaitingRectHeader ); + + // qWarning( "Got rect header" ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotRectHeader() ) ); + + con->read( &x, 2 ); + x = Swap16IfLE( x ); + con->read( &y, 2 ); + y = Swap16IfLE( y ); + + con->read( &w, 2 ); + w = Swap16IfLE( w ); + con->read( &h, 2 ); + h = Swap16IfLE( h ); + + con->read( &encoding, 4 ); + + // CARD32 encodingLocal = Swap32IfLE( encoding ); + // qWarning( "Rect: x=%d, y= %d, w=%d, h=%d, encoding=%ld", + // x, y, w, h, encodingLocal ); + + // + // Each encoding needs to be handled differently. Some require + // waiting for more data, but others like a copyrect do not. + // Our constants have already been byte swapped, so we use + // the remote value as is. + // + if ( encoding == RawEncoding ) { + // qWarning( "Raw encoding" ); + handleRawRect(); + } + else if ( encoding == CopyRectEncoding ) { +// qWarning( "CopyRect encoding" ); + handleCopyRect(); + } + else if ( encoding == RreEncoding ) { + qWarning( "RRE encoding" ); + handleRRERect(); + } + else if ( encoding == CorreEncoding ) { + qWarning( "CoRRE encoding" ); + handleCoRRERect(); + } + else if ( encoding == HexTileEncoding ) { + qWarning( "HexTile encoding" ); + handleHexTileRect(); + } + else { + int msg = Swap32IfLE( encoding ); + QString protocolError = tr( "Protocol Error: An unknown encoding was " + "used by the server %1" ).arg( msg ); + currentState = Error; + qWarning( "Unknown encoding, %d", msg ); + emit error( protocolError ); + return; + } +} + +// +// Raw Encoding +// + +void KRFBDecoder::handleRawRect() +{ + // We need something a bit cleverer here to handle large + // rectanges nicely. The chunking should be based on the + // overall size (but has to be in complete lines). + + // qWarning( "Handling a raw rect chunk" ); + + // CARD32 lineCount = w * format->bpp / 8; + + if ( h > RectChunkSize ) { + // if ( con->sock->size() / lineCount ) { + // getRawRectChunk( con->sock->size() / lineCount ); + // } + // else { + getRawRectChunk( RectChunkSize ); + // } + } + else { + getRawRectChunk( h ); + } +} + +void KRFBDecoder::getRawRectChunk( int lines ) +{ + this->lines = lines; + CARD32 count = lines * w * format->bpp / 8; + + // Wait for server init + // qWarning( "Waiting for raw rect chunk, %ld", count ); + + currentState = AwaitingRawRectChunk; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRawRectChunk() ) ); + con->waitForData( count ); +} + +void KRFBDecoder::gotRawRectChunk() +{ + assert( currentState == AwaitingRawRectChunk ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotRawRectChunk() ) ); + + // qWarning( "Got raw rect chunk" ); + + // + // Read the rect data and copy it to the buffer. + // + + // TODO: Replace this! + int count = lines * w * format->bpp / 8; + char *hack = new char[ count ]; + con->read( hack, count ); + buf->drawRawRectChunk( hack, x, y, w, lines ); + delete hack; + // /TODO: + + h = h - lines; + y = y + lines; + + if ( h > 0 ) { + handleRawRect(); + } + else { + noRects--; + + // qWarning( "There are %d rects left", noRects ); + + if ( noRects ) { + currentState = AwaitingRectHeader; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) ); + con->waitForData( RectHeaderLength ); + } + else + currentState = Idle; + } +} + +// +// Copy Rectangle Encoding +// + +void KRFBDecoder::handleCopyRect() +{ + currentState = AwaitingCopyRectPos; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotCopyRectPos() ) ); + con->waitForData( CopyRectPosLength ); +} + +void KRFBDecoder::gotCopyRectPos() +{ + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotCopyRectPos() ) ); + + CARD16 srcX; + CARD16 srcY; + + con->read( &srcX, 2 ); + con->read( &srcY, 2 ); + + srcX = Swap16IfLE( srcX ); + srcY = Swap16IfLE( srcY ); + + buf->copyRect( srcX, srcY, x, y, w, h ); + + noRects--; + + // qWarning( "There are %d rects left", noRects ); + + if ( noRects ) { + currentState = AwaitingRectHeader; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) ); + con->waitForData( RectHeaderLength ); + } + else + currentState = Idle; +} + +void KRFBDecoder::handleRRERect() +{ + qWarning( "RRE not implemented" ); +} + +void KRFBDecoder::handleCoRRERect() +{ + qWarning( "CoRRE not implemented" ); +} + +void KRFBDecoder::handleHexTileRect() +{ + qWarning( "HexTile not implemented" ); +} + +void KRFBDecoder::sendMouseEvent( QMouseEvent *e ) +{ + // Deal with the buttons + if ( e->type() != QEvent::MouseMove ) { + buttonMask = 0; + if ( e->type() == QEvent::MouseButtonPress ) { + if ( e->button() & LeftButton ) + buttonMask |= 0x01; + if ( e->button() & MidButton ) + buttonMask |= 0x04; + if ( e->button() & RightButton ) + buttonMask |= 0x02; + } + else if ( e->type() == QEvent::MouseButtonRelease ) { + if ( e->button() & LeftButton ) + buttonMask &= 0x06; + if ( e->button() & MidButton ) + buttonMask |= 0x03; + if ( e->button() & RightButton ) + buttonMask |= 0x05; + } + } + + CARD16 x = Swap16IfLE( e->x() ); + CARD16 y = Swap16IfLE( e->y() ); + + con->write( &PointerEventId, 1 ); + con->write( &buttonMask, 1 ); + con->write( &x, 2 ); + con->write( &y, 2 ); +} + + +void KRFBDecoder::sendCutEvent( const QString &unicode ) +{ + // + // Warning: There is a bug in the RFB protocol because there is no way to find + // out the codepage in use on the remote machine. This could be fixed by requiring + // the remote server to use utf8 etc. but for now we have to assume they're the + // same. I've reported this problem to the ORL guys, but they apparantly have no + // immediate plans to fix the issue. :-( (rich) + // + + CARD8 padding[3]; + QCString text = unicode.local8Bit(); + CARD32 length = text.length(); + length = Swap32IfLE( length ); + + con->write( &ClientCutTextId, 1 ); + con->write( &padding, 3 ); + con->write( &length, 4 ); + con->write( text.data(), length ); +} + +void KRFBDecoder::gotServerCut() +{ + qWarning( "Got server cut" ); + + currentState = AwaitingServerCutLength; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutLength() ) ); + con->waitForData( ServerCutLenLength ); +} + +void KRFBDecoder::gotServerCutLength() +{ + assert( currentState = AwaitingServerCutLength ); + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotServerCutLength() ) ); + + CARD8 padding[3]; + con->read( padding, 3 ); + + con->read( &serverCutTextLen, 4 ); + serverCutTextLen = Swap32IfLE( serverCutTextLen ); + + currentState = AwaitingServerCutText; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutText() ) ); + con->waitForData( serverCutTextLen ); +} + +void KRFBDecoder::gotServerCutText() +{ + assert( currentState = AwaitingServerCutText ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotServerCutText() ) ); + + // + // Warning: There is a bug in the RFB protocol because there is no way to find + // out the codepage in use on the remote machine. This could be fixed by requiring + // the remote server to use utf8 etc. but for now we have to assume they're the + // same. I've reported this problem to the ORL guys, but they apparantly have no + // immediate plans to fix the issue. :-( (rich) + // + + char *cutbuf = new char[ serverCutTextLen + 1 ]; + CHECK_PTR( cutbuf ); + + con->read( cutbuf, serverCutTextLen ); + cutbuf[ serverCutTextLen ] = '\0'; + + qWarning( "Server cut: %s", cutbuf ); + + QString cutText( cutbuf ); // DANGER!! + qApp->clipboard()->setText( cutText ); + + delete cutbuf; + + // Now wait for the update (again) + if ( oldState == AwaitingUpdate ) { + currentState = AwaitingUpdate; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) ); + con->waitForData( UpdateHeaderLength ); + } + else if ( oldState == Idle ) { + currentState = Idle; + } + else { + qWarning( "Async handled in weird state" ); + currentState = oldState; + }; +} + +void KRFBDecoder::gotBell() +{ + qWarning( "Got server bell" ); + buf->soundBell(); + + // Now wait for the update (again) + if ( oldState == AwaitingUpdate ) { + currentState = AwaitingUpdate; + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) ); + con->waitForData( UpdateHeaderLength ); + } + else if ( oldState == Idle ) { + currentState = Idle; + } + else { + qWarning( "Async handled in weird state" ); + currentState = oldState; + }; +} + +void KRFBDecoder::sendKeyPressEvent( QKeyEvent *event ) +{ + int key; + key = toKeySym( event ); + if ( key ) { + key = Swap32IfLE( key ); + + CARD8 mask = true; + + CARD16 padding = 0; + con->write( &KeyEventId, 1 ); + con->write( &mask, 1 ); + con->write( &padding, 2 ); + con->write( &key, 4 ); + } +} + +void KRFBDecoder::sendKeyReleaseEvent( QKeyEvent *event ) +{ + int key; + key = toKeySym( event ); + if ( key ) { + key = Swap32IfLE( key ); + + CARD8 mask = false; + + CARD16 padding = 0; + con->write( &KeyEventId, 1 ); + con->write( &mask, 1 ); + con->write( &padding, 2 ); + con->write( &key, 4 ); + } +} + +int KRFBDecoder::toKeySym( QKeyEvent *k ) +{ + int ke = 0; + + ke = k->ascii(); + // Markus: Crappy hack. I dont know why lower case letters are + // not defined in qkeydefs.h. The key() for e.g. 'l' == 'L'. + // This sucks. :-( + + if ( (ke == 'a') || (ke == 'b') || (ke == 'c') || (ke == 'd') + || (ke == 'e') || (ke == 'f') || (ke == 'g') || (ke == 'h') + || (ke == 'i') || (ke == 'j') || (ke == 'k') || (ke == 'l') + || (ke == 'm') || (ke == 'n') || (ke == 'o') || (ke == 'p') + || (ke == 'q') || (ke == 'r') || (ke == 's') || (ke == 't') + || (ke == 'u') || (ke == 'v') ||( ke == 'w') || (ke == 'x') + || (ke == 'y') || (ke == 'z') ) { + ke = k->key(); + ke = ke + 0x20; + return ke; + } + + // qkeydefs = xkeydefs! :-) + if ( ( k->key() >= 0x0a0 ) && k->key() <= 0x0ff ) + return k->key(); + + if ( ( k->key() >= 0x20 ) && ( k->key() <= 0x7e ) ) + return k->key(); + + // qkeydefs != xkeydefs! :-( + // This is gonna suck :-( + + int i = 0; + while ( keyMap[i].keycode ) { + if ( k->key() == keyMap[i].keycode ) + return keyMap[i].keysym; + i++; + } + + return 0; +} + diff --git a/noncore/comm/keypebble/krfbdecoder.h b/noncore/comm/keypebble/krfbdecoder.h new file mode 100644 index 0000000..4ba0185 --- a/dev/null +++ b/noncore/comm/keypebble/krfbdecoder.h @@ -0,0 +1,134 @@ +// -*- c++ -*- + +#ifndef KRFBDECODER_H +#define KRFBDECODER_H + +#include + +class KRFBConnection; +class KRFBServerInfo; +class KRFBPixelFormat; +class KRFBBuffer; + + +typedef unsigned char CARD8; +typedef unsigned short CARD16; +typedef unsigned long CARD32; + +/** + * Negotiates the pixel format to be used then decodes the resulting + * data stream. + * + * @author Richard Moore, rich@kde.org + */ +class KRFBDecoder : public QObject +{ + Q_OBJECT + +public: + friend class KRFBBuffer; + + enum State { + AwaitingServerInit, + AwaitingDesktopName, + AwaitingUpdate, + AwaitingRectHeader, + AwaitingRawRectChunk, + AwaitingCopyRectPos, + AwaitingServerCutLength, + AwaitingServerCutText, + Idle, + Error + }; + + /** + * Create a KRFBDecoder that reads data from a logged in KRFBConnection + * and sends its output to a KRFBBuffer. + */ + KRFBDecoder( KRFBConnection *con ); + ~KRFBDecoder(); + + void setBuffer( KRFBBuffer *buf ) { this->buf = buf; }; + void start(); + + int toKeySym( QKeyEvent *k ); + + // + // Client -> Server messages + // + void sendUpdateRequest( bool incremental ); + void sendMouseEvent( QMouseEvent *e ); + void sendKeyPressEvent( QKeyEvent *e ); + void sendKeyReleaseEvent( QKeyEvent *e ); + void sendCutEvent( const QString &text ); + +protected: + // + // Initial format negotiation + // + void decidePixelFormat(); + void sendPixelFormat(); + void sendClientInit(); + void sendAllowedEncodings(); + + // + // Rectange processing + // + void handleRawRect(); + void handleCopyRect(); + void handleRRERect(); + void handleCoRRERect(); + void handleHexTileRect(); + + void getRawRectChunk( int lines ); + +protected slots: + void gotServerInit(); + void gotDesktopName(); + void gotUpdateHeader(); + void gotRectHeader(); + void gotRawRectChunk(); + void gotCopyRectPos(); + void gotServerCut(); + void gotServerCutLength(); + void gotServerCutText(); + void gotBell(); + +signals: + void error( const QString & ); + void status( const QString & ); + +private: + State currentState; + + // Used to store the state we were in before a cut or bell msg + State oldState; + + // The number of rects we're expecting + CARD16 noRects; + + // + // Info about the current rect. + // + CARD16 x, y, w, h; + int lines; + CARD32 encoding; + + CARD32 serverCutTextLen; + + /** Where we draw the data (and the source of our events). */ + KRFBBuffer *buf; + /** The connection to the server. */ + KRFBConnection *con; + + /** Info about the RFB server. */ + KRFBServerInfo *info; + /** The pixel format we want. */ + KRFBPixelFormat *format; + + CARD8 buttonMask; +}; + +#endif // KRFBDECODER_H + + diff --git a/noncore/comm/keypebble/krfblogin.cpp b/noncore/comm/keypebble/krfblogin.cpp new file mode 100644 index 0000000..073ba0e --- a/dev/null +++ b/noncore/comm/keypebble/krfblogin.cpp @@ -0,0 +1,255 @@ +#include + + +extern "C" { +#include "vncauth.h" +} + +#include "krfblogin.h" +#include "krfbconnection.h" +#include + +// The length of the various messages (used to decide how many bytes to +// wait for). +const int ServerVersionLength = 12; +const int ClientVersionLength = 12; +const int AuthSchemeLength = 4; +const int FailureReasonSizeLength = 4; +const int ChallengeLength = 16; +const int AuthResultLength = 4; + +// Authentication results +enum AuthResult { + AuthOk, + AuthFailed, + AuthTooMany +}; + +typedef unsigned char CARD8; +typedef unsigned short CARD16; +typedef unsigned long CARD32; + +const int endianTest = 1; + +// Endian stuff +#define Swap16IfLE(s) \ + (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s)) + +#define Swap32IfLE(l) \ + (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \ + (((l) & 0x00ff0000) >> 8) | \ + (((l) & 0x0000ff00) << 8) | \ + (((l) & 0x000000ff) << 24)) : (l)) + +KRFBLogin::KRFBLogin( KRFBConnection *con ) + : QObject( con, "RFB login manager" ) +{ + assert( con ); + this->con = con; + currentState = AwaitingServerVersion; + + connect( this, SIGNAL( error( const QString & ) ), + con, SIGNAL( error( const QString & ) ) ); + + connect( this, SIGNAL( passwordRequired( KRFBConnection * ) ), + con, SIGNAL( passwordRequired( KRFBConnection * ) ) ); + + qWarning( "Waiting for server version..." ); + + static QString statusMsg = tr( "Waiting for server version..." ); + emit status( statusMsg ); + + // Kick off the state machine + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerVersion() ) ); + con->waitForData( ServerVersionLength ); +} + +KRFBLogin::~KRFBLogin() +{ + +} + +KRFBLogin::State KRFBLogin::state() const +{ + return currentState; +} + +void KRFBLogin::gotServerVersion() +{ + qWarning( "Got server version" ); + + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotServerVersion() ) ); + + // Read the server's version message + char serverVersion[ ServerVersionLength + 1 ]; + con->read( serverVersion, ServerVersionLength ); + serverVersion[ ServerVersionLength ] = '\0'; + + QCString rfbString( serverVersion, ServerVersionLength + 1 ); + versionString = rfbString; + + QRegExp regexp( "RFB [0-9][0-9][0-9]\\.[0-9][0-9][0-9]\n" ); + + if ( rfbString.find( regexp ) == -1 ) { + static QString msg = tr( "Error: Invalid server version, %1" ).arg( rfbString ); + + qWarning( msg ); + emit error( msg ); + currentState = Error; + return; + } + + // Calculate the actual version number + serverMajor = (serverVersion[4] - '0') * 100 + + (serverVersion[5] - '0') * 10 + + (serverVersion[6] - '0'); + serverMinor = (serverVersion[8] - '0') * 100 + + (serverVersion[9] - '0') * 10 + + (serverVersion[10] - '0'); + + qWarning("Server Version: %03d.%03d", serverMajor, serverMinor ); + + if ( serverMajor != 3 ) { + QString msg = tr( "Error: Unsupported server version, %1" ) + .arg( rfbString ); + + qWarning( msg ); + emit error( msg ); + currentState = Error; + return; + } + + if ( serverMinor != 3 ) { + qWarning( "Minor version mismatch: %d", serverMinor ); + } + + // Setup for the next state + sendClientVersion(); + + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotAuthScheme() ) ); + con->waitForData( AuthSchemeLength ); +} + +void KRFBLogin::gotAuthScheme() +{ + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotAuthScheme() ) ); + + // Got data + CARD32 scheme; + con->read( &scheme, AuthSchemeLength ); + scheme = Swap32IfLE( scheme ); + + static QString statusMsgOk = tr( "Logged in" ); + + switch ( scheme ) { + case 0: + qWarning( "Failed" ); + // Handle failure + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotFailureReasonSize() ) ); + con->waitForData( FailureReasonSizeLength ); + break; + case 1: + // Handle no auth + emit status( statusMsgOk ); + con->gotRFBConnection(); + break; + case 2: + // Handle VNC auth + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotChallenge() ) ); + con->waitForData( ChallengeLength ); + break; + default: + qWarning( "Unknown authentication scheme, 0x%08lx", scheme ); + currentState = Error; + break; + }; +} + +void KRFBLogin::gotChallenge() +{ + disconnect( con, SIGNAL( gotEnoughData() ), + this, SLOT( gotChallenge() ) ); + + QTimer::singleShot( 0, this, SLOT(getPassword()) ); +} + +void KRFBLogin::getPassword() +{ + // Got data + CARD8 challenge[ ChallengeLength ]; + con->read( challenge, ChallengeLength ); + + // Last chance to enter a password + if ( con->pass_.isNull() ) { + qWarning( "krfblogin needs a password" ); + emit passwordRequired( con ); + } + + if ( con->pass_.isNull() ) { + QString msg = tr( "Error: This server requires a password, but none " + "has been specified.\n" ); + + emit error( msg ); + return; + } + + vncEncryptBytes( (unsigned char *) challenge, con->pass_.data() ); + con->write( challenge, ChallengeLength ); + + connect( con, SIGNAL( gotEnoughData() ), SLOT( gotAuthResult() ) ); + con->waitForData( AuthResultLength ); +} + +void KRFBLogin::gotFailureReasonSize() +{ + disconnect( con, SIGNAL( gotEnoughData() ), this, + SLOT( gotFailureReasonSize() ) ); +} + +void KRFBLogin::gotAuthResult() +{ + // Got data + disconnect( con, SIGNAL( gotEnoughData() ), this, + SLOT( gotAuthResult() ) ); + + long result; + con->read( &result, AuthResultLength ); + result = Swap32IfLE( result ); + + qWarning( "Authentication Result is 0x%08lx", result ); + + static QString failed = tr( "Error: The password you specified was incorrect." ); + static QString tooMany = tr( "Error: Too many invalid login attempts have been made\n" + "to this account, please try later." ); + + static QString statusMsgOk = tr( "Logged in" ); + static QString statusMsgFailed = tr( "Login Failed" ); + static QString statusMsgTooMany = tr( "Too many failures" ); + + switch( result ) { + case AuthOk: + emit status( statusMsgOk ); + con->gotRFBConnection(); + break; + case AuthFailed: + qWarning( "Dammit" ); + emit status( statusMsgFailed ); + emit error( failed ); + break; + case AuthTooMany: + emit status( statusMsgTooMany ); + emit error( tooMany ); + break; + default: + qWarning( "Invalid authentication result, %lx", result ); + break; + } +} + +void KRFBLogin::sendClientVersion() +{ + qWarning( "Sending client version" ); + con->write( (void*)"RFB 003.003\n", ClientVersionLength ); +} diff --git a/noncore/comm/keypebble/krfblogin.h b/noncore/comm/keypebble/krfblogin.h new file mode 100644 index 0000000..5208210 --- a/dev/null +++ b/noncore/comm/keypebble/krfblogin.h @@ -0,0 +1,62 @@ +// -*- c++ -*- + +#ifndef KRFBLOGIN_H +#define KRFBLOGIN_H + +#include + +class KRFBConnection; + +/** + * Handles logging into the RFB server. + * + * @version $Id$ + * @author Richard Moore, rich@kde.org + */ +class KRFBLogin : QObject +{ + Q_OBJECT + +public: + enum State { + AwaitingServerVersion, + AwaitingAuthScheme, + AwaitingChallenge, + WaitingForResponse, + Authenticated, + Ready, + Failed, + Error + }; + + KRFBLogin( KRFBConnection *con ); + ~KRFBLogin(); + + KRFBLogin::State state() const; + +protected: + void sendClientVersion(); + +protected slots: + void getPassword(); + void gotServerVersion(); + void gotAuthScheme(); + void gotChallenge(); + void gotAuthResult(); + void gotFailureReasonSize(); + +signals: + void passwordRequired( KRFBConnection * ); + void error( const QString & ); + void status( const QString & ); + +private: + KRFBConnection *con; + State currentState; + QCString versionString; + int serverMajor; + int serverMinor; +}; + +#endif // KRFBLOGIN_H + diff --git a/noncore/comm/keypebble/krfboptions.cpp b/noncore/comm/keypebble/krfboptions.cpp new file mode 100644 index 0000000..9daf3f0 --- a/dev/null +++ b/noncore/comm/keypebble/krfboptions.cpp @@ -0,0 +1,52 @@ +#include +#include +#include "krfboptions.h" + +KRFBOptions::KRFBOptions() +{ + Config config( "keypebble" ); + readSettings( &config ); +} + +KRFBOptions::~KRFBOptions() +{ + Config config( "keypebble" ); + writeSettings( &config ); +} + +void KRFBOptions::readSettings( Config *config ) +{ + hexTile = config->readBoolEntry( "HexTile" ); + corre = config->readBoolEntry( "CORRE" ); + rre = config->readBoolEntry( "RRE" ); + copyrect = config->readBoolEntry( "CopyRect", true ); + colors256 = config->readBoolEntry( "Colors256" ); + shared = config->readBoolEntry( "Shared" ); + readOnly = config->readBoolEntry( "ReadOnly" ); + updateRate = config->readNumEntry( "UpdateRate", 50 ); +} + +void KRFBOptions::writeSettings( Config *config ) +{ + config->writeEntry( "HexTile", hexTile ); + config->writeEntry( "CORRE", corre ); + config->writeEntry( "RRE", rre ); + config->writeEntry( "CopyRect", copyrect ); + config->writeEntry( "Colors256", colors256 ); + config->writeEntry( "Shared", shared ); + config->writeEntry( "ReadOnly", readOnly ); + config->writeEntry( "UpdateRate", updateRate ); +} + +int KRFBOptions::encodings() +{ + // Initially one because we always support raw encoding + int count = 1; + + count += hexTile ? 1 : 0; + count += corre ? 1 : 0; + count += rre ? 1 : 0; + count += copyrect ? 1 : 0; + + return count; +} diff --git a/noncore/comm/keypebble/krfboptions.h b/noncore/comm/keypebble/krfboptions.h new file mode 100644 index 0000000..41cea35 --- a/dev/null +++ b/noncore/comm/keypebble/krfboptions.h @@ -0,0 +1,31 @@ +// -*- c++ -*- + +#ifndef KRFBOPTIONS_H +#define KRFBOPTIONS_H + +class Config; + +class KRFBOptions +{ +public: + KRFBOptions(); + ~KRFBOptions(); + + int encodings(); + void readSettings( Config *config ); + void writeSettings( Config *config ); + + bool hexTile; + bool corre; + bool rre; + bool copyrect; + + bool colors256; + bool shared; + bool readOnly; + bool deIconify; + + int updateRate; +}; + +#endif // KRFBOPTIONS_H diff --git a/noncore/comm/keypebble/krfbserverinfo.h b/noncore/comm/keypebble/krfbserverinfo.h new file mode 100644 index 0000000..7449da9 --- a/dev/null +++ b/noncore/comm/keypebble/krfbserverinfo.h @@ -0,0 +1,42 @@ +// -*- c++ -*- + +#ifndef KRFBSERVERINFO_H +#define KRFBSERVERINFO_H + +#include + +typedef unsigned char CARD8; +typedef unsigned short CARD16; +typedef unsigned long CARD32; + +class KRFBPixelFormat +{ +public: + CARD8 bpp; + CARD8 depth; + CARD8 bigEndian; + CARD8 trueColor; + CARD16 redMax; + CARD16 greenMax; + CARD16 blueMax; + CARD8 redShift; + CARD8 greenShift; + CARD8 blueShift; + CARD8 padding[3]; // 3 bytes padding +}; + +/** + * Information sent by the server in its init message. + */ +class KRFBServerInfo : public KRFBPixelFormat +{ +public: + CARD16 width; + CARD16 height; + CARD32 nameLength; + QString name; +}; + +#endif // KRFBSERVERINFO_H + + diff --git a/noncore/comm/keypebble/kvnc.cpp b/noncore/comm/keypebble/kvnc.cpp new file mode 100644 index 0000000..bb18999 --- a/dev/null +++ b/noncore/comm/keypebble/kvnc.cpp @@ -0,0 +1,191 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "kvnc.h" +#include "krfbcanvas.h" +#include "kvncoptionsdlg.h" +#include "krfbconnection.h" + + +/* XPM */ +static char * menu_xpm[] = { +"12 12 5 1", +" c None", +". c #000000", +"+ c #FFFDAD", +"@ c #FFFF00", +"# c #E5E100", +" ", +" ", +" ......... ", +" .+++++++. ", +" .+@@@@#. ", +" .+@@@#. ", +" .+@@#. ", +" .+@#. ", +" .+#. ", +" .+. ", +" .. ", +" "}; + +const int StatusTextId = 0; + +KVNC::KVNC( const char *name ) : QMainWindow( 0, name ) +{ + setCaption( tr("VNC Viewer") ); + fullscreen = false; + + canvas = new KRFBCanvas( this, "canvas" ); + setCentralWidget( canvas ); + + connect( canvas->connection(), SIGNAL(statusChanged(const QString &)), + this, SLOT(statusMessage(const QString &)) ); + connect( canvas->connection(), SIGNAL(error(const QString &)), + this, SLOT(error(const QString &)) ); + connect( canvas->connection(), SIGNAL(connected()), this, SLOT(connected()) ); + connect( canvas->connection(), SIGNAL(loggedIn()), this, SLOT(loggedIn()) ); + connect( canvas->connection(), SIGNAL(disconnected()), this, SLOT(disconnected()) ); + + setupActions(); + + cornerButton = new QPushButton( this ); + cornerButton->setPixmap( QPixmap( (const char**)menu_xpm ) ); + connect( cornerButton, SIGNAL(pressed()), this, SLOT(showMenu()) ); + canvas->setCornerWidget( cornerButton ); + + QTimer::singleShot( 0, canvas, SLOT(openConnection()) ); +} + +KVNC::~KVNC() +{ + +} + +void KVNC::openURL( const QUrl &url ) +{ + canvas->openURL( url ); +} + +void KVNC::setupActions() +{ + cornerMenu = new QPopupMenu( this ); + + fullScreenAction = new QAction( tr("Full Screen"), QString::null, 0, 0 ); + connect( fullScreenAction, SIGNAL(activated()), + this, SLOT( toggleFullScreen() ) ); + fullScreenAction->addTo( cornerMenu ); + fullScreenAction->setEnabled( false ); + + optionsAction = new QAction( tr("Settings"), QString::null, 0, 0 ); + connect( optionsAction, SIGNAL(activated()), this, SLOT( showOptions() ) ); + optionsAction->addTo( cornerMenu ); + + connectAction = new QAction( tr("Connect..."), QString::null, 0, 0 ); + connect( connectAction, SIGNAL(activated()), + canvas, SLOT( openConnection() ) ); + connectAction->addTo( cornerMenu ); + + disconnectAction = new QAction( tr("Disconnect"), QString::null, 0, 0 ); + connect( disconnectAction, SIGNAL(activated()), + this, SLOT( closeConnection() ) ); + disconnectAction->addTo( cornerMenu ); + disconnectAction->setEnabled( false ); +} + +void KVNC::toggleFullScreen() +{ + if ( fullscreen ) { + canvas->releaseKeyboard(); + canvas->reparent( this, 0, QPoint(0,0), false ); + canvas->setFrameStyle( QFrame::Panel | QFrame::Sunken ); + setCentralWidget( canvas ); + canvas->show(); + fullScreenAction->setText( tr("Full Screen") ); + } else { + canvas->setFrameStyle( QFrame::NoFrame ); + canvas->reparent( 0,WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop, + QPoint(0,0),false); + canvas->resize(qApp->desktop()->width(), qApp->desktop()->height()); + canvas->raise(); + canvas->setFocus(); + canvas->grabKeyboard(); + canvas->show(); + + fullScreenAction->setText( tr("Stop Full Screen") ); + } + + fullscreen = !fullscreen; +} + +void KVNC::closeConnection() +{ + if ( fullscreen ) + toggleFullScreen(); + canvas->closeConnection(); +} + +void KVNC::showMenu() +{ + QPoint pt = mapToGlobal(cornerButton->pos()); + QSize s = cornerMenu->sizeHint(); + pt.ry() -= s.height(); + pt.rx() -= s.width(); + cornerMenu->popup( pt ); +} + +void KVNC::connected() +{ + static QString msg = tr( "Connected to remote host" ); + statusMessage( msg ); + connectAction->setEnabled( false ); + disconnectAction->setEnabled( true ); + fullScreenAction->setEnabled( true ); +} + +void KVNC::loggedIn() +{ + static QString msg = tr( "Logged in to remote host" ); + statusMessage( msg ); +} + +void KVNC::disconnected() +{ + static QString msg = tr( "Connection closed" ); + statusMessage( msg ); + connectAction->setEnabled( true ); + disconnectAction->setEnabled( false ); + fullScreenAction->setEnabled( false ); +} + +void KVNC::statusMessage( const QString &m ) +{ + Global::statusMessage( m ); +} + +void KVNC::error( const QString &msg ) +{ + statusMessage( msg ); + QMessageBox::warning( this, tr("VNC Viewer"), msg ); +} + +void KVNC::showOptions() +{ + KVNCOptionsDlg *wdg = new KVNCOptionsDlg( canvas->connection()->options(), this ); + wdg->showMaximized(); + wdg->exec(); + delete wdg; +} + diff --git a/noncore/comm/keypebble/kvnc.h b/noncore/comm/keypebble/kvnc.h new file mode 100644 index 0000000..92666c5 --- a/dev/null +++ b/noncore/comm/keypebble/kvnc.h @@ -0,0 +1,56 @@ +// -*- c++ -*- + +#ifndef KVNC_H +#define KVNC_H + +#include +#include + +class QAction; +class KRFBCanvas; +class QPushButton; +class QToolBar; + +/** + * Top level window for Keystone. + * + * @author Richard Moore, rich@kde.org + * @version $Id$ + */ +class KVNC : public QMainWindow +{ + Q_OBJECT +public: + KVNC( const char *name = 0 ); + ~KVNC(); + +public slots: + void toggleFullScreen(); + void openURL( const QUrl & ); + void closeConnection(); + void showOptions(); + +protected: + void setupActions(); + +protected slots: + void showMenu(); + + void connected(); + void loggedIn(); + void disconnected(); + void statusMessage( const QString & ); + void error( const QString & ); + +private: + bool fullscreen; + KRFBCanvas *canvas; + QPopupMenu *cornerMenu; + QPushButton *cornerButton; + QAction *fullScreenAction; + QAction *optionsAction; + QAction *disconnectAction; + QAction *connectAction; +}; + +#endif // KVNC_H diff --git a/noncore/comm/keypebble/kvncconnectdlg.cpp b/noncore/comm/keypebble/kvncconnectdlg.cpp new file mode 100644 index 0000000..467cebf --- a/dev/null +++ b/noncore/comm/keypebble/kvncconnectdlg.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "krfbconnection.h" +#include "kvncoptionsdlg.h" +#include "kvncconnectdlg.h" + + +KVNCConnectDlg::KVNCConnectDlg( KRFBConnection *con, + QWidget *parent, const char *name ) + : QDialog( parent, name, true ) +{ + setCaption( tr("Connect to VNC server") ); + assert( con ); + this->con = con; + + QGridLayout *inner = new QGridLayout( this, 3, 2, 6 ); + + QLabel *label = new QLabel( tr("Host Name:"), + this , "hostLabel"); + hostNameCombo = new QComboBox( true, this ); + hostNameCombo->setInsertionPolicy( QComboBox::AtTop ); + hostNameCombo->setMaxCount( 10 ); + hostNameCombo->insertItem( "localhost" ); + hostNameCombo->setFocus(); + + inner->addWidget( label, 0, 0 ); + inner->addWidget( hostNameCombo, 0, 1 ); + + label = new QLabel( tr("Display Number:"), this, "displayNumber" ); + displayNumberEdit = new QSpinBox( this ); + + inner->addWidget( label, 1, 0 ); + inner->addWidget( displayNumberEdit, 1, 1 ); + + // if ( viewer->display() != -1 ) { + // displayNumberEdit->setValue( viewer->display() ); + displayNumberEdit->setValue( 1 ); + // } + + label = new QLabel( tr("Password:"), this ); + inner->addWidget( label, 2, 0 ); + + passwordEdit = new QLineEdit( this ); + passwordEdit->setEchoMode( QLineEdit::Password ); + inner->addWidget( passwordEdit, 2, 1 ); + + inner->setColStretch( 0, 0 ); + inner->setColStretch( 1, 15 ); +} + + +void KVNCConnectDlg::accept() +{ + int dis; + // viewer->setHost(hostNameCombo->currentText()); + QString temp = displayNumberEdit->text(); + if(temp.isEmpty()) + dis = -1; + else + dis = temp.toUInt(); + // viewer->setDisplay(dis); + QDialog::accept(); +} + +void KVNCConnectDlg::options() +{ + KVNCOptionsDlg *wdg = new KVNCOptionsDlg( con->options(), this ); + wdg->exec(); + delete wdg; +} + diff --git a/noncore/comm/keypebble/kvncconnectdlg.h b/noncore/comm/keypebble/kvncconnectdlg.h new file mode 100644 index 0000000..cf34aab --- a/dev/null +++ b/noncore/comm/keypebble/kvncconnectdlg.h @@ -0,0 +1,39 @@ +// -*- c++ -*- + +#ifndef KVNCCONNECTDLG_H +#define KVNCCONNECTDLG_H + +#include +#include +#include +#include +#include + +class KRFBConnection; + +class KVNCConnectDlg : public QDialog +{ + Q_OBJECT + +public: + KVNCConnectDlg( KRFBConnection *con, + QWidget *parent = 0, const char *name = 0 ); + + QString hostname() { return hostNameCombo->currentText(); }; + int display() { return displayNumberEdit->value(); }; + QString password() const { return passwordEdit->text(); } + +protected: + void accept(); + +protected slots: + void options(); + +private: + QComboBox *hostNameCombo; + QSpinBox *displayNumberEdit; + QLineEdit *passwordEdit; + KRFBConnection *con; +}; + +#endif // KVNCCONNECTDLG_H diff --git a/noncore/comm/keypebble/kvncoptionsdlg.cpp b/noncore/comm/keypebble/kvncoptionsdlg.cpp new file mode 100644 index 0000000..b9f57d1 --- a/dev/null +++ b/noncore/comm/keypebble/kvncoptionsdlg.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "krfboptions.h" + +#include "kvncoptionsdlg.h" + +KVNCOptionsDlg::KVNCOptionsDlg( KRFBOptions *options, + QWidget *parent, char *name, bool modal ) + : VncOptionsBase( parent, name, modal ) +{ + this->options = options; + + hex->setChecked( options->hexTile ); + corre->setChecked( options->corre ); + rre->setChecked( options->rre ); + copyRect->setChecked( options->copyrect ); + + // TODO + hex->setEnabled( false ); + corre->setEnabled( false ); + rre->setEnabled( false ); + // /TODO + + deIconify->setChecked( options->deIconify ); + bit->setChecked( options->colors256 ); + shared->setChecked( options->shared ); + timeBox->setValue( options->updateRate ); +} + +KVNCOptionsDlg::~KVNCOptionsDlg() +{ +} + +void KVNCOptionsDlg::accept() +{ + options->hexTile = hex->isChecked(); + options->corre = corre->isChecked(); + options->rre = rre->isChecked(); + options->copyrect = copyRect->isChecked(); + options->deIconify = deIconify->isChecked(); + options->colors256 = bit->isChecked(); + options->shared = shared->isChecked(); + options->updateRate = timeBox->value(); + + QDialog::accept(); +} + diff --git a/noncore/comm/keypebble/kvncoptionsdlg.h b/noncore/comm/keypebble/kvncoptionsdlg.h new file mode 100644 index 0000000..a166490 --- a/dev/null +++ b/noncore/comm/keypebble/kvncoptionsdlg.h @@ -0,0 +1,30 @@ +// -*- c++ -*- + +#ifndef KVNCOPTIONSDIALOG_H +#define KVNCOPTIONSDIALOG_H + +#include "vncoptionsbase.h" + +class KRFBOptions; + +class KVNCOptionsDlg : public VncOptionsBase +{ +Q_OBJECT + +public: + KVNCOptionsDlg( KRFBOptions *options, + QWidget *parent = 0, char *name = 0, bool modal = true ); + ~KVNCOptionsDlg(); + +protected: + void accept(); + +private: + KRFBOptions *options; +}; + +#endif // KVNCOPTIONSDIALOG_H + + + + diff --git a/noncore/comm/keypebble/main.cpp b/noncore/comm/keypebble/main.cpp new file mode 100644 index 0000000..a32a368 --- a/dev/null +++ b/noncore/comm/keypebble/main.cpp @@ -0,0 +1,18 @@ + + +#include +#include +#include "kvnc.h" + +int main( int argc, char **argv ) +{ + QPEApplication app( argc, argv ); + KVNC *view = new KVNC( "Keypebble" ); + app.showMainWidget( view ); + + if ( argc > 1 ) + view->openURL( QUrl(argv[1]) ); + + return app.exec(); +} + diff --git a/noncore/comm/keypebble/qpe-keypebble.control b/noncore/comm/keypebble/qpe-keypebble.control new file mode 100644 index 0000000..75c1b9f --- a/dev/null +++ b/noncore/comm/keypebble/qpe-keypebble.control @@ -0,0 +1,10 @@ +Files: bin/keypebble apps/Applications/keypebble.desktop pics/vnc.png +Priority: optional +Section: qpe/applications +Maintainer: Martin Jones +Architecture: arm +Arch: iPAQ +Version: $QPE_VERSION-2 +Depends: qpe-base ($QPE_VERSION) +Description: VNC Viewer + Virtual Network Computing (VNC) viewer diff --git a/noncore/comm/keypebble/vncauth.c b/noncore/comm/keypebble/vncauth.c new file mode 100644 index 0000000..dc276bf --- a/dev/null +++ b/noncore/comm/keypebble/vncauth.c @@ -0,0 +1,160 @@ +/* + * Copyright (C) 1997, 1998 Olivetti & Oracle Research Laboratory + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * vncauth.c - Functions for VNC password management and authentication. + */ + +#include +#include +#include +#include +#include +#include +#include "vncauth.h" +#include "d3des.h" + + +/* + * We use a fixed key to store passwords, since we assume that our local + * file system is secure but nonetheless don't want to store passwords + * as plaintext. + */ + +unsigned char fixedkey[8] = {23,82,107,6,35,78,88,7}; + + +/* + * Encrypt a password and store it in a file. Returns 0 if successful, + * 1 if the file could not be written. + */ + +int +vncEncryptAndStorePasswd(char *passwd, char *fname) +{ + FILE *fp; + int i; + unsigned char encryptedPasswd[8]; + + if ((fp = fopen(fname,"w")) == NULL) return 1; + + chmod(fname, S_IRUSR|S_IWUSR); + + /* pad password with nulls */ + + for (i = 0; i < 8; i++) { + if (i < strlen(passwd)) { + encryptedPasswd[i] = passwd[i]; + } else { + encryptedPasswd[i] = 0; + } + } + + /* Do encryption in-place - this way we overwrite our copy of the plaintext + password */ + + deskey(fixedkey, EN0); + des(encryptedPasswd, encryptedPasswd); + + for (i = 0; i < 8; i++) { + putc(encryptedPasswd[i], fp); + } + + fclose(fp); + return 0; +} + + +/* + * Decrypt a password from a file. Returns a pointer to a newly allocated + * string containing the password or a null pointer if the password could + * not be retrieved for some reason. + */ + +char * +vncDecryptPasswdFromFile(char *fname) +{ + FILE *fp; + int i, ch; + unsigned char *passwd = (unsigned char *)malloc(9); + + if ((fp = fopen(fname,"r")) == NULL) return NULL; + + for (i = 0; i < 8; i++) { + ch = getc(fp); + if (ch == EOF) { + fclose(fp); + return NULL; + } + passwd[i] = ch; + } + + deskey(fixedkey, DE1); + des(passwd, passwd); + + passwd[8] = 0; + + return (char *)passwd; +} + + +/* + * Generate CHALLENGESIZE random bytes for use in challenge-response + * authentication. + */ + +void +vncRandomBytes(unsigned char *bytes) +{ + int i; + unsigned int seed = (unsigned int) time(0); + + srandom(seed); + for (i = 0; i < CHALLENGESIZE; i++) { + bytes[i] = (unsigned char)(random() & 255); + } +} + + +/* + * Encrypt CHALLENGESIZE bytes in memory using a password. + */ + +void +vncEncryptBytes(unsigned char *bytes, char *passwd) +{ + unsigned char key[8]; + int i; + + /* key is simply password padded with nulls */ + + for (i = 0; i < 8; i++) { + if (i < strlen(passwd)) { + key[i] = passwd[i]; + } else { + key[i] = 0; + } + } + + deskey(key, EN0); + + for (i = 0; i < CHALLENGESIZE; i += 8) { + des(bytes+i, bytes+i); + } +} diff --git a/noncore/comm/keypebble/vncauth.h b/noncore/comm/keypebble/vncauth.h new file mode 100644 index 0000000..38b289e --- a/dev/null +++ b/noncore/comm/keypebble/vncauth.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 1997, 1998 Olivetti & Oracle Research Laboratory + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/* + * vncauth.h - describes the functions provided by the vncauth library. + */ + +#define MAXPWLEN 8 +#define CHALLENGESIZE 16 + +extern int vncEncryptAndStorePasswd(char *passwd, char *fname); +extern char *vncDecryptPasswdFromFile(char *fname); +extern void vncRandomBytes(unsigned char *bytes); +extern void vncEncryptBytes(unsigned char *bytes, char *passwd); diff --git a/noncore/comm/keypebble/vncoptionsbase.ui b/noncore/comm/keypebble/vncoptionsbase.ui new file mode 100644 index 0000000..d049a79 --- a/dev/null +++ b/noncore/comm/keypebble/vncoptionsbase.ui @@ -0,0 +1,270 @@ + +VncOptionsBase + + QDialog + + name + VncOptionsBase + + + geometry + + 0 + 0 + 234 + 221 + + + + caption + VNC Viewer Options + + + layoutMargin + + + + margin + 0 + + + spacing + 6 + + + QTabWidget + + name + TabWidget3 + + + QWidget + + name + tab + + + title + Data Encoding + + + + margin + 11 + + + spacing + 6 + + + QLabel + + name + TextLabel1 + + + text + Check for screen updates every: + + + + QLayoutWidget + + name + Layout2 + + + + margin + 0 + + + spacing + 6 + + + QSpinBox + + name + timeBox + + + maxValue + 500 + + + minValue + 1 + + + + QLabel + + name + TextLabel2 + + + text + Milliseconds + + + + + + QCheckBox + + name + bit + + + text + Request 8-bit session + + + + QCheckBox + + name + deIconify + + + text + Raise on bell + + + + QCheckBox + + name + shared + + + text + Request shared session + + + + + name + Spacer2 + + + orientation + Vertical + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + + + QWidget + + name + tab + + + title + Connection + + + + margin + 11 + + + spacing + 6 + + + QCheckBox + + name + hex + + + enabled + false + + + text + Hextile encoding + + + + QCheckBox + + name + corre + + + enabled + false + + + text + CoRRE encoding + + + + QCheckBox + + name + rre + + + enabled + false + + + text + RRE encoding + + + + QCheckBox + + name + copyRect + + + text + Copy rectangle encoding + + + + + name + Spacer3 + + + orientation + Vertical + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + + + + + -- cgit v0.9.0.2