summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--core/qws/TODO31
-rw-r--r--core/qws/config.in16
-rw-r--r--core/qws/main.cpp71
-rw-r--r--core/qws/opie-qws.control10
-rw-r--r--core/qws/oqwsserver.cpp196
-rw-r--r--core/qws/oqwsserver.h57
-rw-r--r--core/qws/qcopbridge.cpp422
-rw-r--r--core/qws/qcopbridge.h92
-rw-r--r--core/qws/qws.pro20
-rw-r--r--core/qws/transferserver.cpp1424
-rw-r--r--core/qws/transferserver.h179
11 files changed, 2518 insertions, 0 deletions
diff --git a/core/qws/TODO b/core/qws/TODO
new file mode 100644
index 0000000..b35d87e
--- a/dev/null
+++ b/core/qws/TODO
@@ -0,0 +1,31 @@
+New Launcher TODO:
+
+[x] Split QWS Server out of launcher/taskbar application
+[ ] Handling of default Opie env vars that may or may not be
+ affected by ODevice. This should really affect all Opie apps..
+ perhaps in qpeapplication, or a seperate app that sets the env vars
+ for Opie ala the way ssh-agent outputs an eval'able set of vars.
+
+[.] QWS Server
+ [x] actual qws server (qpeapplication as GuiServer)
+ [x] qcop bridge
+ [x] transfer server (sync compatibility)
+ [ ] calibration QCop calls (to split calibration into a seperate app)
+ [ ] window list / management QCop calls (matchbox style task switching)
+ [ ] qws event filter hooks
+ [ ] Touch and Key clicks
+ [ ] xstroke style input
+
+[ ] Launcher/Taskbar
+ [ ] Proper VT handling, and VT switching - qt/e + qpeapplication.. every app needs to handle this properly
+ [ ] Proper timezone handling (create localtime link) - belongs in that which handles the time. clock applet, systemtime.
+ [ ] LauncherView as plugins, possibly allow the plugin to add any
+ arbitary number of tabs, in which case the launcher is simply
+ a tab bar with plugins, the default being the AppLnk and Docs
+ scanning plugins, to give us the current functionality.
+
+[ ] Uncertain
+ [ ] Alerts - mem and battery
+ [ ] OpieScreenSaver
+ [.] package slave - essentially take bridged qcop message, pass it
+ along to the app which is associated with the .ipk mime type.
diff --git a/core/qws/config.in b/core/qws/config.in
new file mode 100644
index 0000000..1316c77
--- a/dev/null
+++ b/core/qws/config.in
@@ -0,0 +1,16 @@
+ config QWS
+ boolean "Minimal QWS Server"
+ default "n"
+ depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE
+
+# menu "Advanced QWS Server Config"
+# config QWS_QCOP
+# bool "QCop bridge and Transfer server (sync)"
+# default y
+# depends on QWS
+#
+# config QWS_PACKAGE
+# bool "Package Slave (package installs via sync software)"
+# default n
+# depends on QWS
+# endmenu
diff --git a/core/qws/main.cpp b/core/qws/main.cpp
new file mode 100644
index 0000000..bfed283
--- a/dev/null
+++ b/core/qws/main.cpp
@@ -0,0 +1,71 @@
+#include <qwindowsystem_qws.h>
+#include <qapplication.h>
+
+#include "oqwsserver.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <syslog.h>
+#include <stdio.h>
+
+#define APPNAME "op-qws"
+
+void toSyslog(QtMsgType type, const char *msg)
+{
+ int level = LOG_INFO;
+ switch (type) {
+ case QtDebugMsg:
+ level = LOG_DEBUG;
+ break;
+ case QtWarningMsg:
+ level = LOG_WARNING;
+ break;
+ case QtFatalMsg:
+ level = LOG_ERR;
+ break;
+ }
+ syslog (LOG_DAEMON | level, msg);
+}
+
+int daemon_init(void)
+{
+ pid_t pid;
+
+ if ((pid = fork()) < 0)
+ return(-1);
+ else if (pid != 0)
+ exit(0);
+
+ setsid();
+
+ chdir("/");
+
+ umask(0);
+
+ fclose(stdout);
+ fclose(stderr);
+ fclose(stdin);
+
+ return(0);
+}
+
+int main( int argc, char ** argv )
+{
+ while (argc > 1) {
+ if (strcmp(argv[--argc], "-d") == 0) {
+ // daemonize
+ openlog(APPNAME, 0, LOG_DAEMON);
+ qInstallMsgHandler(toSyslog);
+ if (daemon_init() != 0) {
+ fprintf(stderr, "%s: Error: Unable to daemonize\n", APPNAME);
+ return 1;
+ }
+ }
+ }
+
+ OQWSServer a(argc, argv, QApplication::GuiServer);
+ return a.exec();
+}
diff --git a/core/qws/opie-qws.control b/core/qws/opie-qws.control
new file mode 100644
index 0000000..fe5f4e0
--- a/dev/null
+++ b/core/qws/opie-qws.control
@@ -0,0 +1,10 @@
+Package: opie-taskbar
+Files: bin/qpe apps/Settings/Calibrate.desktop pics/launcher pics/devicebuttons/*.png plugins/applets/libsuspendapplet.so* plugins/applets/libhomeapplet.so* plugins/applets/liblogoutapplet.so* plugins/applets/librotateapplet.so* root/etc/init.d/opie
+Priority: required
+Section: opie/system
+Maintainer: Project Opie <opie@handhelds.org>
+Architecture: arm
+Version: $QPE_VERSION-$SUB_VERSION.3
+Depends: task-opie-minimal
+Replaces: opie-rotation
+Description: Launcher for Opie
diff --git a/core/qws/oqwsserver.cpp b/core/qws/oqwsserver.cpp
new file mode 100644
index 0000000..1c61d19
--- a/dev/null
+++ b/core/qws/oqwsserver.cpp
@@ -0,0 +1,196 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS. All rights reserved.
+**
+** This file is part of Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include <syslog.h>
+
+#include "oqwsserver.h"
+#include "qcopbridge.h"
+#include "transferserver.h"
+
+#include <qpe/applnk.h>
+#include <qpe/mimetype.h>
+#include <qpe/password.h>
+#include <qpe/config.h>
+#include <qpe/power.h>
+#include <qpe/timeconversion.h>
+#include <qpe/qcopenvelope_qws.h>
+#include <qpe/network.h>
+#include <qpe/global.h>
+
+#if defined( QT_QWS_SL5XXX ) || defined( QT_QWS_IPAQ )
+#include <qpe/custom.h>
+#endif
+
+#include <opie/odevice.h>
+
+#include <qgfx_qws.h>
+#include <qmainwindow.h>
+#include <qmessagebox.h>
+#include <qtimer.h>
+#include <qwindowsystem_qws.h>
+
+#include <qvaluelist.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+using namespace Opie;
+
+OQWSServer::OQWSServer( int& argc, char **argv, Type appType )
+ : QPEApplication( argc, argv, appType )
+{
+ startServers();
+}
+
+OQWSServer::~OQWSServer()
+{
+ terminateServers();
+}
+
+bool OQWSServer::eventFilter ( QObject *o, QEvent *e )
+{
+#if 0
+ if ( e-> type ( ) == QEvent::KeyPress || e-> type ( ) == QEvent::KeyRelease ) {
+ QKeyEvent *ke = (QKeyEvent *) e;
+
+ const ODeviceButton *db = ODevice::inst ( )-> buttonForKeycode ( ke-> key ( ));
+
+ if ( db ) {
+ if (checkButtonAction ( db, ke-> key ( ), e-> type ( ) == QEvent::KeyPress, ke-> isAutoRepeat ( )))
+ return true; //checkButtonAction retrune false if events should be routed through
+ }
+ }
+#endif
+ return QPEApplication::eventFilter ( o, e );
+}
+
+#ifdef Q_WS_QWS
+
+bool OQWSServer::qwsEventFilter( QWSEvent *e )
+{
+#if 0
+ qpedesktop->checkMemory();
+
+ if ( e->type == QWSEvent::Key ) {
+ QWSKeyEvent * ke = (QWSKeyEvent *) e;
+ ushort keycode = ke-> simpleData. keycode;
+
+ if ( !loggedin && keycode != Key_F34 )
+ return true;
+
+ bool press = ke-> simpleData. is_press;
+ bool autoRepeat = ke-> simpleData. is_auto_repeat;
+
+ if ( !keyboardGrabbed ( )) {
+ // app that registers key/message to be sent back to the app, when it doesn't have focus,
+ // when user presses key, unless keyboard has been requested from app.
+ // will not send multiple repeats if user holds key
+ // i.e. one shot
+
+ if ( keycode != 0 && press && !autoRepeat ) {
+ for ( KeyRegisterList::Iterator it = keyRegisterList.begin(); it != keyRegisterList.end(); ++it ) {
+ if (( *it ). getKeyCode ( ) == keycode ) {
+ QCopEnvelope (( *it ). getChannel ( ), ( *it ). getMessage ( ));
+ return true;
+ }
+ }
+ }
+ }
+
+ if ( keycode == HardKey_Suspend ) {
+ if ( press )
+ emit power ( );
+ return true;
+ }
+ else if ( keycode == HardKey_Backlight ) {
+ if ( press )
+ emit backlight ( );
+ return true;
+ }
+ else if ( keycode == Key_F32 ) {
+ if ( press )
+ QCopEnvelope e( "QPE/Desktop", "startSync()" );
+ return true;
+ }
+ else if ( keycode == Key_F31 && !ke-> simpleData. modifiers ) { // Symbol Key -> show Unicode IM
+ if ( press )
+ emit symbol ( );
+ return true;
+ }
+ else if ( keycode == Key_NumLock ) {
+ if ( press )
+ emit numLockStateToggle ( );
+ }
+ else if ( keycode == Key_CapsLock ) {
+ if ( press )
+ emit capsLockStateToggle();
+ }
+ if (( press && !autoRepeat ) || ( !press && autoRepeat )) {
+ if ( m_keyclick_sound )
+ ODevice::inst ( )-> keySound ( );
+ }
+ }
+ else if ( e-> type == QWSEvent::Mouse ) {
+ QWSMouseEvent * me = ( QWSMouseEvent * ) e;
+ static bool up = true;
+
+ if ( me-> simpleData. state & LeftButton ) {
+ if ( up ) {
+ up = false;
+ if ( m_screentap_sound )
+ ODevice::inst ( ) -> touchSound ( );
+ }
+ }
+ else {
+ up = true;
+ }
+ }
+#endif
+ return QPEApplication::qwsEventFilter ( e );
+}
+
+#endif
+
+void OQWSServer::startServers()
+{
+ // start qcop bridge server
+ m_qcopBridge = new QCopBridge( 4243 );
+ if ( !m_qcopBridge->ok() ) {
+ delete m_qcopBridge;
+ m_qcopBridge = 0;
+ }
+ // start transfer server
+ m_transferServer = new TransferServer( 4242 );
+ if ( !m_transferServer->ok() ) {
+ delete m_transferServer;
+ m_transferServer = 0;
+ }
+// if ( !transferServer || !qcopBridge )
+// startTimer( 2000 );
+}
+
+void OQWSServer::terminateServers()
+{
+ delete m_transferServer;
+ delete m_qcopBridge;
+ m_transferServer = 0;
+ m_qcopBridge = 0;
+}
diff --git a/core/qws/oqwsserver.h b/core/qws/oqwsserver.h
new file mode 100644
index 0000000..b95c3fb
--- a/dev/null
+++ b/core/qws/oqwsserver.h
@@ -0,0 +1,57 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS. All rights reserved.
+**
+** This file is part of Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#ifndef __DESKTOP_H__
+#define __DESKTOP_H__
+
+
+#include <qpe/qpeapplication.h>
+#include <opie/odevicebutton.h>
+
+#include <qwidget.h>
+#include <qdatetime.h>
+
+class QCopBridge;
+class TransferServer;
+
+class OQWSServer : public QPEApplication
+{
+ Q_OBJECT
+public:
+ OQWSServer( int& argc, char **argv, Type t );
+ ~OQWSServer();
+
+protected:
+ virtual bool eventFilter ( QObject *o, QEvent *e );
+
+#ifdef Q_WS_QWS
+ bool qwsEventFilter( QWSEvent * );
+#endif
+
+private:
+ void startServers();
+ void terminateServers();
+
+ QCopBridge *m_qcopBridge;
+ TransferServer *m_transferServer;
+};
+
+#endif // __DESKTOP_H__
+
diff --git a/core/qws/qcopbridge.cpp b/core/qws/qcopbridge.cpp
new file mode 100644
index 0000000..6177a7c
--- a/dev/null
+++ b/core/qws/qcopbridge.cpp
@@ -0,0 +1,422 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "qcopbridge.h"
+#include "transferserver.h"
+
+#include <qpe/qcopenvelope_qws.h>
+#include <qpe/qpeapplication.h>
+#include <qpe/version.h>
+
+#include <qdir.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qdatastream.h>
+#include <qstringlist.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+#ifdef QWS
+#include <qcopchannel_qws.h>
+#endif
+
+#define _XOPEN_SOURCE
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#if defined(_OS_LINUX_)
+#include <shadow.h>
+#endif
+
+//#define INSECURE
+
+const int block_size = 51200;
+
+QCopBridge::QCopBridge( Q_UINT16 port, QObject *parent ,
+ const char* name )
+ : QServerSocket( port, 1, parent, name ),
+ desktopChannel( 0 ),
+ cardChannel( 0 )
+{
+ if ( !ok() )
+ qWarning( "Failed to bind to port %d", port );
+ else {
+#ifndef QT_NO_COP
+ desktopChannel = new QCopChannel( "QPE/Desktop", this );
+ connect( desktopChannel, SIGNAL(received(const QCString &, const QByteArray &)),
+ this, SLOT(desktopMessage( const QCString &, const QByteArray &)) );
+ cardChannel = new QCopChannel( "QPE/Card", this );
+ connect( cardChannel, SIGNAL(received(const QCString &, const QByteArray &)),
+ this, SLOT(desktopMessage( const QCString &, const QByteArray &)) );
+#endif
+ }
+ sendSync = FALSE;
+}
+
+QCopBridge::~QCopBridge()
+{
+#ifndef QT_NO_COP
+ delete desktopChannel;
+#endif
+}
+
+void QCopBridge::newConnection( int socket )
+{
+ QCopBridgePI *pi = new QCopBridgePI( socket, this );
+ openConnections.append( pi );
+ connect ( pi, SIGNAL( connectionClosed( QCopBridgePI *) ), this, SLOT( connectionClosed( QCopBridgePI *) ) );
+#ifndef QT_NO_COP
+ QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::DisableSuspend;
+#endif
+
+ if ( sendSync ) {
+ pi ->startSync();
+ sendSync = FALSE;
+ }
+}
+
+void QCopBridge::connectionClosed( QCopBridgePI *pi )
+{
+ openConnections.remove( pi );
+ if ( openConnections.count() == 0 ) {
+#ifndef QT_NO_COP
+ QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
+#endif
+ }
+}
+
+void QCopBridge::closeOpenConnections()
+{
+ QCopBridgePI *pi;
+ for ( pi = openConnections.first(); pi != 0; pi = openConnections.next() )
+ pi->close();
+}
+
+
+void QCopBridge::desktopMessage( const QCString &command, const QByteArray &args )
+{
+ command.stripWhiteSpace();
+
+ int paren = command.find( "(" );
+ if ( paren <= 0 ) {
+ qDebug("DesktopMessage: bad qcop syntax");
+ return;
+ }
+
+ QString params = command.mid( paren + 1 );
+ if ( params[params.length()-1] != ')' ) {
+ qDebug("DesktopMessage: bad qcop syntax");
+ return;
+ }
+
+ params.truncate( params.length()-1 );
+
+ QStringList paramList = QStringList::split( ",", params );
+ QString data;
+ if ( paramList.count() ) {
+ QDataStream stream( args, IO_ReadOnly );
+ for ( QStringList::Iterator it = paramList.begin(); it != paramList.end(); ++it ) {
+ QString str;
+ if ( *it == "QString" ) {
+ stream >> str;
+ } else if ( *it == "QCString" ) {
+ QCString cstr;
+ stream >> cstr;
+ str = QString::fromLocal8Bit( cstr );
+ } else if ( *it == "int" ) {
+ int i;
+ stream >> i;
+ str = QString::number( i );
+ } else if ( *it == "bool" ) {
+ int i;
+ stream >> i;
+ str = QString::number( i );
+ } else {
+ qDebug(" cannot route the argument type %s throught the qcop bridge", (*it).latin1() );
+ return;
+ }
+ QString estr;
+ for (int i=0; i<(int)str.length(); i++) {
+ QChar ch = str[i];
+ if ( ch.row() )
+ goto quick;
+ switch (ch.cell()) {
+ case '&':
+ estr.append( "&amp;" );
+ break;
+ case ' ':
+ estr.append( "&0x20;" );
+ break;
+ case '\n':
+ estr.append( "&0x0d;" );
+ break;
+ case '\r':
+ estr.append( "&0x0a;" );
+ break;
+ default: quick:
+ estr.append(ch);
+ }
+ }
+ data += " " + estr;
+ }
+ }
+ QString sendCommand = QString(command.data()) + data;
+ // send the command to all open connections
+ if ( command == "startSync()" ) {
+ // we need to buffer it a bit
+ sendSync = TRUE;
+ startTimer( 20000 );
+ }
+
+ QCopBridgePI *pi;
+ for ( pi = openConnections.first(); pi != 0; pi = openConnections.next() ) {
+ pi->sendDesktopMessage( sendCommand );
+ }
+}
+
+void QCopBridge::timerEvent( QTimerEvent * )
+{
+ sendSync = FALSE;
+ killTimers();
+}
+
+
+QCopBridgePI::QCopBridgePI( int socket, QObject *parent , const char* name )
+ : QSocket( parent, name )
+{
+ setSocket( socket );
+
+ peerport = peerPort();
+ peeraddress = peerAddress();
+
+#ifndef INSECURE
+ if ( !SyncAuthentication::isAuthorized(peeraddress) ) {
+ state = Forbidden;
+ startTimer( 0 );
+ } else
+#endif
+ {
+ state = Connected;
+ sendSync = FALSE;
+ connect( this, SIGNAL( readyRead() ), SLOT( read() ) );
+ connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
+
+ QString intro="220 Qtopia ";
+ intro += QPE_VERSION; intro += ";";
+ intro += "challenge="; intro += SyncAuthentication::serverId(); intro += ";";
+ intro += "loginname="; intro += SyncAuthentication::loginName(); intro += ";";
+ intro += "displayname="; intro += SyncAuthentication::ownerName(); intro += ";";
+ send( intro );
+ state = Wait_USER;
+
+ // idle timer to close connections when not used anymore
+ startTimer( 60000 );
+ connected = TRUE;
+ }
+}
+
+
+QCopBridgePI::~QCopBridgePI()
+{
+
+}
+
+void QCopBridgePI::connectionClosed()
+{
+ emit connectionClosed( this );
+ // qDebug( "Debug: Connection closed" );
+ delete this;
+}
+
+void QCopBridgePI::sendDesktopMessage( const QString &msg )
+{
+ QString str = "CALL QPE/Desktop " + msg;
+ send ( str );
+}
+
+
+void QCopBridgePI::send( const QString& msg )
+{
+ QTextStream os( this );
+ os << msg << endl;
+ //qDebug( "sending qcop message: %s", msg.latin1() );
+}
+
+void QCopBridgePI::read()
+{
+ while ( canReadLine() )
+ process( readLine().stripWhiteSpace() );
+}
+
+void QCopBridgePI::process( const QString& message )
+{
+ //qDebug( "Command: %s", message.latin1() );
+
+ // split message using "," as separator
+ QStringList msg = QStringList::split( " ", message );
+ if ( msg.isEmpty() ) return;
+
+ // command token
+ QString cmd = msg[0].upper();
+
+ // argument token
+ QString arg;
+ if ( msg.count() >= 2 )
+ arg = msg[1];
+
+ // we always respond to QUIT, regardless of state
+ if ( cmd == "QUIT" ) {
+ send( "211 Have a nice day!" );
+ delete this;
+ return;
+ }
+
+ // connected to client
+ if ( Connected == state )
+ return;
+
+ // waiting for user name
+ if ( Wait_USER == state ) {
+
+ if ( cmd != "USER" || msg.count() < 2 || !SyncAuthentication::checkUser( arg ) ) {
+ send( "530 Please login with USER and PASS" );
+ return;
+ }
+ send( "331 User name ok, need password" );
+ state = Wait_PASS;
+ return;
+ }
+
+ // waiting for password
+ if ( Wait_PASS == state ) {
+
+ if ( cmd != "PASS" || !SyncAuthentication::checkPassword( arg ) ) {
+ send( "530 Please login with USER and PASS" );
+ return;
+ }
+ send( "230 User logged in, proceed" );
+ state = Ready;
+ if ( sendSync ) {
+ sendDesktopMessage( "startSync()" );
+ sendSync = FALSE;
+ }
+ return;
+ }
+
+ // noop (NOOP)
+ else if ( cmd == "NOOP" ) {
+ connected = TRUE;
+ send( "200 Command okay" );
+ }
+
+ // call (CALL)
+ else if ( cmd == "CALL" ) {
+
+ // example: call QPE/System execute(QString) addressbook
+
+ if ( msg.count() < 3 ) {
+ send( "500 Syntax error, command unrecognized" );
+ }
+ else {
+
+ QString channel = msg[1];
+ QString command = msg[2];
+
+ command.stripWhiteSpace();
+
+ int paren = command.find( "(" );
+ if ( paren <= 0 ) {
+ send( "500 Syntax error, command unrecognized" );
+ return;
+ }
+
+ QString params = command.mid( paren + 1 );
+ if ( params[params.length()-1] != ')' ) {
+ send( "500 Syntax error, command unrecognized" );
+ return;
+ }
+
+ params.truncate( params.length()-1 );
+ QByteArray buffer;
+ QDataStream ds( buffer, IO_WriteOnly );
+
+ int msgId = 3;
+
+ QStringList paramList = QStringList::split( ",", params );
+ if ( paramList.count() > msg.count() - 3 ) {
+ send( "500 Syntax error, command unrecognized" );
+ return;
+ }
+
+ for ( QStringList::Iterator it = paramList.begin(); it != paramList.end(); ++it ) {
+
+ QString arg = msg[msgId];
+ arg.replace( QRegExp("&0x20;"), " " );
+ arg.replace( QRegExp("&amp;"), "&" );
+ arg.replace( QRegExp("&0x0d;"), "\n" );
+ arg.replace( QRegExp("&0x0a;"), "\r" );
+ if ( *it == "QString" )
+ ds << arg;
+ else if ( *it == "QCString" )
+ ds << arg.local8Bit();
+ else if ( *it == "int" )
+ ds << arg.toInt();
+ else if ( *it == "bool" )
+ ds << arg.toInt();
+ else {
+ send( "500 Syntax error, command unrecognized" );
+ return;
+ }
+ msgId++;
+ }
+
+#ifndef QT_NO_COP
+ if ( !QCopChannel::isRegistered( channel.latin1() ) ) {
+ // send message back about it
+ QString answer = "599 ChannelNotRegistered " + channel;
+ send( answer );
+ return;
+ }
+#endif
+
+#ifndef QT_NO_COP
+ if ( paramList.count() )
+ QCopChannel::send( channel.latin1(), command.latin1(), buffer );
+ else
+ QCopChannel::send( channel.latin1(), command.latin1() );
+
+ send( "200 Command okay" );
+#endif
+ }
+ }
+ // not implemented
+ else
+ send( "502 Command not implemented" );
+}
+
+
+
+void QCopBridgePI::timerEvent( QTimerEvent * )
+{
+ if ( connected )
+ connected = FALSE;
+ else
+ connectionClosed();
+}
diff --git a/core/qws/qcopbridge.h b/core/qws/qcopbridge.h
new file mode 100644
index 0000000..408d10d
--- a/dev/null
+++ b/core/qws/qcopbridge.h
@@ -0,0 +1,92 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#ifndef __qcopbridge_h__
+#define __qcopbridge_h__
+
+#include <qserversocket.h>
+#include <qsocket.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qbuffer.h>
+
+class QFileInfo;
+class QCopBridgePI;
+class QCopChannel;
+
+class QCopBridge : public QServerSocket
+{
+ Q_OBJECT
+
+public:
+ QCopBridge( Q_UINT16 port, QObject *parent = 0, const char* name = 0 );
+ virtual ~QCopBridge();
+
+ void newConnection( int socket );
+ void closeOpenConnections();
+
+public slots:
+ void connectionClosed( QCopBridgePI *pi );
+ void desktopMessage( const QCString &call, const QByteArray & );
+
+protected:
+ void timerEvent( QTimerEvent * );
+
+private:
+ QCopChannel *desktopChannel;
+ QCopChannel *cardChannel;
+ QList<QCopBridgePI> openConnections;
+ bool sendSync;
+};
+
+
+class QCopBridgePI : public QSocket
+{
+ Q_OBJECT
+
+ enum State { Connected, Wait_USER, Wait_PASS, Ready, Forbidden };
+
+public:
+ QCopBridgePI( int socket, QObject *parent = 0, const char* name = 0 );
+ virtual ~QCopBridgePI();
+
+ void sendDesktopMessage( const QString &msg );
+ void startSync() { sendSync = TRUE; }
+
+signals:
+ void connectionClosed( QCopBridgePI *);
+
+protected slots:
+ void read();
+ void send( const QString& msg );
+ void process( const QString& command );
+ void connectionClosed();
+
+protected:
+ void timerEvent( QTimerEvent *e );
+
+private:
+ State state;
+ Q_UINT16 peerport;
+ QHostAddress peeraddress;
+ bool connected;
+ bool sendSync;
+};
+
+#endif
diff --git a/core/qws/qws.pro b/core/qws/qws.pro
new file mode 100644
index 0000000..5656a59
--- a/dev/null
+++ b/core/qws/qws.pro
@@ -0,0 +1,20 @@
+TEMPLATE = app
+CONFIG = qt warn_on release
+DESTDIR = $(OPIEDIR)/bin
+
+HEADERS = \
+ transferserver.h \
+ qcopbridge.h \
+ oqwsserver.h
+SOURCES = \
+ main.cpp \
+ transferserver.cpp \
+ qcopbridge.cpp \
+ oqwsserver.cpp
+
+INCLUDEPATH += $(OPIEDIR)/include
+DEPENDPATH += $(OPIEDIR)/include .
+TARGET = op-qws
+LIBS += -lqpe -lopie
+
+include ( $(OPIEDIR)/include.pro )
diff --git a/core/qws/transferserver.cpp b/core/qws/transferserver.cpp
new file mode 100644
index 0000000..0337a94
--- a/dev/null
+++ b/core/qws/transferserver.cpp
@@ -0,0 +1,1424 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#define _XOPEN_SOURCE
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <time.h>
+#include <shadow.h>
+
+/* we need the _OS_LINUX stuff first ! */
+#include <qglobal.h>
+
+#ifndef _OS_LINUX_
+
+extern "C"
+{
+#include <uuid/uuid.h>
+#define UUID_H_INCLUDED
+}
+
+#endif // not defined linux
+
+#if defined(_OS_LINUX_)
+#include <shadow.h>
+#endif
+
+#include <qdir.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qdatastream.h>
+#include <qmessagebox.h>
+#include <qstringlist.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+//#include <qpe/qcopchannel_qws.h>
+#include <qpe/process.h>
+#include <qpe/global.h>
+#include <qpe/config.h>
+#include <qpe/contact.h>
+#include <qpe/quuid.h>
+#include <qpe/version.h>
+#include <qpe/qcopenvelope_qws.h>
+
+#include "transferserver.h"
+#include <opie/oprocess.h>
+
+const int block_size = 51200;
+
+TransferServer::TransferServer( Q_UINT16 port, QObject *parent ,
+ const char* name )
+ : QServerSocket( port, 1, parent, name )
+{
+ if ( !ok() )
+ qWarning( "Failed to bind to port %d", port );
+}
+
+TransferServer::~TransferServer()
+{
+}
+
+void TransferServer::newConnection( int socket )
+{
+ (void) new ServerPI( socket, this );
+}
+
+/*
+ * small class in anonymous namespace
+ * to generate a QUUid for us
+ */
+namespace
+{
+struct UidGen
+{
+ QString uuid();
+};
+#if !defined(_OS_LINUX_)
+
+QString UidGen::uuid()
+{
+ uuid_t uuid;
+ uuid_generate( uuid );
+ return QUUid( uuid ).toString();
+}
+#else
+/*
+* linux got a /proc/sys/kernel/random/uuid file
+* it'll generate the uuids for us
+*/
+QString UidGen::uuid()
+{
+ QFile file( "/proc/sys/kernel/random/uuid" );
+ if (!file.open(IO_ReadOnly ) )
+ return QString::null;
+
+ QTextStream stream(&file);
+
+ return "{" + stream.read().stripWhiteSpace() + "}";
+}
+#endif
+}
+
+QString SyncAuthentication::serverId()
+{
+ Config cfg("Security");
+ cfg.setGroup("Sync");
+ QString r = cfg.readEntry("serverid");
+ if ( r.isEmpty() ) {
+ UidGen gen;
+ r = gen.uuid();
+ cfg.writeEntry("serverid", r );
+ }
+ return r;
+}
+
+QString SyncAuthentication::ownerName()
+{
+ QString vfilename = Global::applicationFileName("addressbook",
+ "businesscard.vcf");
+ if (QFile::exists(vfilename)) {
+ Contact c;
+ c = Contact::readVCard( vfilename )[0];
+ return c.fullName();
+ }
+
+ return "";
+}
+
+QString SyncAuthentication::loginName()
+{
+ struct passwd *pw;
+ pw = getpwuid( geteuid() );
+ return QString::fromLocal8Bit( pw->pw_name );
+}
+
+int SyncAuthentication::isAuthorized(QHostAddress peeraddress)
+{
+ Config cfg("Security");
+ cfg.setGroup("Sync");
+ // QString allowedstr = cfg.readEntry("auth_peer","192.168.1.0");
+ uint auth_peer = cfg.readNumEntry("auth_peer", 0xc0a80100);
+
+ // QHostAddress allowed;
+ // allowed.setAddress(allowedstr);
+ // uint auth_peer = allowed.ip4Addr();
+ uint auth_peer_bits = cfg.readNumEntry("auth_peer_bits", 24);
+ uint mask = auth_peer_bits >= 32 // shifting by 32 is not defined
+ ? 0xffffffff : (((1 << auth_peer_bits) - 1) << (32 - auth_peer_bits));
+ return (peeraddress.ip4Addr() & mask) == auth_peer;
+}
+
+bool SyncAuthentication::checkUser( const QString& user )
+{
+ if ( user.isEmpty() )
+ return FALSE;
+ QString euser = loginName();
+ return user == euser;
+}
+
+bool SyncAuthentication::checkPassword( const QString& password )
+{
+#ifdef ALLOW_UNIX_USER_FTP
+ // First, check system password...
+
+ struct passwd *pw = 0;
+ struct spwd *spw = 0;
+
+ pw = getpwuid( geteuid() );
+ spw = getspnam( pw->pw_name );
+
+ QString cpwd = QString::fromLocal8Bit( pw->pw_passwd );
+ if ( cpwd == "x" && spw )
+ cpwd = QString::fromLocal8Bit( spw->sp_pwdp );
+
+ // Note: some systems use more than crypt for passwords.
+ QString cpassword = QString::fromLocal8Bit( crypt( password.local8Bit(), cpwd.local8Bit() ) );
+ if ( cpwd == cpassword )
+ return TRUE;
+#endif
+
+ static int lastdenial = 0;
+ static int denials = 0;
+ int now = time(0);
+
+ // Detect old Qtopia Desktop (no password)
+ if ( password.isEmpty() ) {
+ if ( denials < 1 || now > lastdenial + 600 ) {
+ QMessageBox::warning( 0, tr("Sync Connection"),
+ tr("<p>An unauthorized system is requesting access to this device."
+ "<p>If you are using a version of Qtopia Desktop older than 1.5.1, "
+ "please upgrade."),
+ tr("Deny") );
+ denials++;
+ lastdenial = now;
+ }
+ return FALSE;
+ }
+
+ // Second, check sync password...
+ QString pass = password.left(6);
+ /* old QtopiaDesktops are sending
+ * rootme newer versions got a Qtopia
+ * prefixed. Qtopia prefix will suceed
+ * until the sync software syncs up
+ * FIXME
+ */
+ if ( pass == "rootme" || pass == "Qtopia") {
+
+ QString cpassword = QString::fromLocal8Bit( crypt( password.mid(8).local8Bit(), "qp" ) );
+ Config cfg("Security");
+ cfg.setGroup("Sync");
+ QString pwds = cfg.readEntry("Passwords");
+ if ( QStringList::split(QChar(' '), pwds).contains(cpassword) )
+ return TRUE;
+
+ // Unrecognized system. Be careful...
+
+ if ( (denials > 2 && now < lastdenial + 600)
+ || QMessageBox::warning(0, tr("Sync Connection"),
+ tr("<p>An unrecognized system is requesting access to this device."
+ "<p>If you have just initiated a Sync for the first time, this is normal."),
+ tr("Allow"), tr("Deny"), 0, 1, 1 ) == 1 ) {
+ denials++;
+ lastdenial = now;
+ return FALSE;
+ }
+ else {
+ denials = 0;
+ cfg.writeEntry("Passwords", pwds + " " + cpassword);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+ServerPI::ServerPI( int socket, QObject *parent , const char* name )
+ : QSocket( parent, name ) , dtp( 0 ), serversocket( 0 ), waitsocket( 0 )
+{
+ state = Connected;
+
+ setSocket( socket );
+
+ peerport = peerPort();
+ peeraddress = peerAddress();
+
+#ifndef INSECURE
+
+ if ( !SyncAuthentication::isAuthorized(peeraddress) ) {
+ state = Forbidden;
+ startTimer( 0 );
+ }
+ else
+#endif
+ {
+ connect( this, SIGNAL( readyRead() ), SLOT( read() ) );
+ connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
+
+ passiv = FALSE;
+ for ( int i = 0; i < 4; i++ )
+ wait[i] = FALSE;
+
+ send( "220 Qtopia " QPE_VERSION " FTP Server" );
+ state = Wait_USER;
+
+ dtp = new ServerDTP( this );
+ connect( dtp, SIGNAL( completed() ), SLOT( dtpCompleted() ) );
+ connect( dtp, SIGNAL( failed() ), SLOT( dtpFailed() ) );
+ connect( dtp, SIGNAL( error( int ) ), SLOT( dtpError( int ) ) );
+
+
+ directory = QDir::currentDirPath();
+
+ static int p = 1024;
+
+ while ( !serversocket || !serversocket->ok() ) {
+ delete serversocket;
+ serversocket = new ServerSocket( ++p, this );
+ }
+ connect( serversocket, SIGNAL( newIncomming( int ) ),
+ SLOT( newConnection( int ) ) );
+ }
+}
+
+ServerPI::~ServerPI()
+{
+}
+
+void ServerPI::connectionClosed()
+{
+ // qDebug( "Debug: Connection closed" );
+ delete this;
+}
+
+void ServerPI::send( const QString& msg )
+{
+ QTextStream os( this );
+ os << msg << endl;
+ //qDebug( "Reply: %s", msg.latin1() );
+}
+
+void ServerPI::read()
+{
+ while ( canReadLine() )
+ process( readLine().stripWhiteSpace() );
+}
+
+bool ServerPI::checkReadFile( const QString& file )
+{
+ QString filename;
+
+ if ( file[0] != "/" )
+ filename = directory.path() + "/" + file;
+ else
+ filename = file;
+
+ QFileInfo fi( filename );
+ return ( fi.exists() && fi.isReadable() );
+}
+
+bool ServerPI::checkWriteFile( const QString& file )
+{
+ QString filename;
+
+ if ( file[0] != "/" )
+ filename = directory.path() + "/" + file;
+ else
+ filename = file;
+
+ QFileInfo fi( filename );
+
+ if ( fi.exists() )
+ if ( !QFile( filename ).remove() )
+ return FALSE;
+ return TRUE;
+}
+
+void ServerPI::process( const QString& message )
+{
+ //qDebug( "Command: %s", message.latin1() );
+
+ // split message using "," as separator
+ QStringList msg = QStringList::split( " ", message );
+ if ( msg.isEmpty() )
+ return ;
+
+ // command token
+ QString cmd = msg[0].upper();
+
+ // argument token
+ QString arg;
+ if ( msg.count() >= 2 )
+ arg = msg[1];
+
+ // full argument string
+ QString args;
+ if ( msg.count() >= 2 ) {
+ QStringList copy( msg );
+ // FIXME: for Qt3
+ // copy.pop_front()
+ copy.remove( copy.begin() );
+ args = copy.join( " " );
+ }
+
+ //qDebug( "args: %s", args.latin1() );
+
+ // we always respond to QUIT, regardless of state
+ if ( cmd == "QUIT" ) {
+ send( "211 Good bye!" );
+ delete this;
+ return ;
+ }
+
+ // connected to client
+ if ( Connected == state )
+ return ;
+
+ // waiting for user name
+ if ( Wait_USER == state ) {
+
+ if ( cmd != "USER" || msg.count() < 2 || !SyncAuthentication::checkUser( arg ) ) {
+ send( "530 Please login with USER and PASS" );
+ return ;
+ }
+ send( "331 User name ok, need password" );
+ state = Wait_PASS;
+ return ;
+ }
+
+ // waiting for password
+ if ( Wait_PASS == state ) {
+
+ if ( cmd != "PASS" || !SyncAuthentication::checkPassword( arg ) ) {
+ send( "530 Please login with USER and PASS" );
+ return ;
+ }
+ send( "230 User logged in, proceed" );
+ state = Ready;
+ return ;
+ }
+
+ // ACCESS CONTROL COMMANDS
+
+
+ // account (ACCT)
+ if ( cmd == "ACCT" ) {
+ // even wu-ftp does not support it
+ send( "502 Command not implemented" );
+ }
+
+ // change working directory (CWD)
+ else if ( cmd == "CWD" ) {
+
+ if ( !args.isEmpty() ) {
+ if ( directory.cd( args, TRUE ) )
+ send( "250 Requested file action okay, completed" );
+ else
+ send( "550 Requested action not taken" );
+ }
+ else
+ send( "500 Syntax error, command unrecognized" );
+ }
+
+ // change to parent directory (CDUP)
+ else if ( cmd == "CDUP" ) {
+ if ( directory.cdUp() )
+ send( "250 Requested file action okay, completed" );
+ else
+ send( "550 Requested action not taken" );
+ }
+
+ // structure mount (SMNT)
+ else if ( cmd == "SMNT" ) {
+ // even wu-ftp does not support it
+ send( "502 Command not implemented" );
+ }
+
+ // reinitialize (REIN)
+ else if ( cmd == "REIN" ) {
+ // even wu-ftp does not support it
+ send( "502 Command not implemented" );
+ }
+
+
+ // TRANSFER PARAMETER COMMANDS
+
+
+ // data port (PORT)
+ else if ( cmd == "PORT" ) {
+ if ( parsePort( arg ) )
+ send( "200 Command okay" );
+ else
+ send( "500 Syntax error, command unrecognized" );
+ }
+
+ // passive (PASV)
+ else if ( cmd == "PASV" ) {
+ passiv = TRUE;
+ send( "227 Entering Passive Mode ("
+ + address().toString().replace( QRegExp( "\\." ), "," ) + ","
+ + QString::number( ( serversocket->port() ) >> 8 ) + ","
+ + QString::number( ( serversocket->port() ) & 0xFF ) + ")" );
+ }
+
+ // representation type (TYPE)
+ else if ( cmd == "TYPE" ) {
+ if ( arg.upper() == "A" || arg.upper() == "I" )
+ send( "200 Command okay" );
+ else
+ send( "504 Command not implemented for that parameter" );
+ }
+
+ // file structure (STRU)
+ else if ( cmd == "STRU" ) {
+ if ( arg.upper() == "F" )
+ send( "200 Command okay" );
+ else
+ send( "504 Command not implemented for that parameter" );
+ }
+
+ // transfer mode (MODE)
+ else if ( cmd == "MODE" ) {
+ if ( arg.upper() == "S" )
+ send( "200 Command okay" );
+ else
+ send( "504 Command not implemented for that parameter" );
+ }
+
+
+ // FTP SERVICE COMMANDS
+
+
+ // retrieve (RETR)
+ else if ( cmd == "RETR" )
+ if ( !args.isEmpty() && checkReadFile( absFilePath( args ) )
+ || backupRestoreGzip( absFilePath( args ) ) ) {
+ send( "150 File status okay" );
+ sendFile( absFilePath( args ) );
+ }
+ else {
+ qDebug("550 Requested action not taken");
+ send( "550 Requested action not taken" );
+ }
+
+ // store (STOR)
+ else if ( cmd == "STOR" )
+ if ( !args.isEmpty() && checkWriteFile( absFilePath( args ) ) ) {
+ send( "150 File status okay" );
+ retrieveFile( absFilePath( args ) );
+ }
+ else
+ send( "550 Requested action not taken" );
+
+ // store unique (STOU)
+ else if ( cmd == "STOU" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // append (APPE)
+ else if ( cmd == "APPE" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // allocate (ALLO)
+ else if ( cmd == "ALLO" ) {
+ send( "200 Command okay" );
+ }
+
+ // restart (REST)
+ else if ( cmd == "REST" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // rename from (RNFR)
+ else if ( cmd == "RNFR" ) {
+ renameFrom = QString::null;
+ if ( args.isEmpty() )
+ send( "500 Syntax error, command unrecognized" );
+ else {
+ QFile file( absFilePath( args ) );
+ if ( file.exists() ) {
+ send( "350 File exists, ready for destination name" );
+ renameFrom = absFilePath( args );
+ }
+ else
+ send( "550 Requested action not taken" );
+ }
+ }
+
+ // rename to (RNTO)
+ else if ( cmd == "RNTO" ) {
+ if ( lastCommand != "RNFR" )
+ send( "503 Bad sequence of commands" );
+ else if ( args.isEmpty() )
+ send( "500 Syntax error, command unrecognized" );
+ else {
+ QDir dir( absFilePath( args ) );
+ if ( dir.rename( renameFrom, absFilePath( args ), TRUE ) )
+ send( "250 Requested file action okay, completed." );
+ else
+ send( "550 Requested action not taken" );
+ }
+ }
+
+ // abort (ABOR)
+ else if ( cmd.contains( "ABOR" ) ) {
+ dtp->close();
+ if ( dtp->dtpMode() != ServerDTP::Idle )
+ send( "426 Connection closed; transfer aborted" );
+ else
+ send( "226 Closing data connection" );
+ }
+
+ // delete (DELE)
+ else if ( cmd == "DELE" ) {
+ if ( args.isEmpty() )
+ send( "500 Syntax error, command unrecognized" );
+ else {
+ QFile file( absFilePath( args ) ) ;
+ if ( file.remove() ) {
+ send( "250 Requested file action okay, completed" );
+ QCopEnvelope e("QPE/System", "linkChanged(QString)" );
+ e << file.name();
+ }
+ else {
+ send( "550 Requested action not taken" );
+ }
+ }
+ }
+
+ // remove directory (RMD)
+ else if ( cmd == "RMD" ) {
+ if ( args.isEmpty() )
+ send( "500 Syntax error, command unrecognized" );
+ else {
+ QDir dir;
+ if ( dir.rmdir( absFilePath( args ), TRUE ) )
+ send( "250 Requested file action okay, completed" );
+ else
+ send( "550 Requested action not taken" );
+ }
+ }
+
+ // make directory (MKD)
+ else if ( cmd == "MKD" ) {
+ if ( args.isEmpty() ) {
+ qDebug(" Error: no arg");
+ send( "500 Syntax error, command unrecognized" );
+ }
+ else {
+ QDir dir;
+ if ( dir.mkdir( absFilePath( args ), TRUE ) )
+ send( "250 Requested file action okay, completed." );
+ else
+ send( "550 Requested action not taken" );
+ }
+ }
+
+ // print working directory (PWD)
+ else if ( cmd == "PWD" ) {
+ send( "257 \"" + directory.path() + "\"" );
+ }
+
+ // list (LIST)
+ else if ( cmd == "LIST" ) {
+ if ( sendList( absFilePath( args ) ) )
+ send( "150 File status okay" );
+ else
+ send( "500 Syntax error, command unrecognized" );
+ }
+
+ // size (SIZE)
+ else if ( cmd == "SIZE" ) {
+ QString filePath = absFilePath( args );
+ QFileInfo fi( filePath );
+ bool gzipfile = backupRestoreGzip( filePath );
+ if ( !fi.exists() && !gzipfile )
+ send( "500 Syntax error, command unrecognized" );
+ else {
+ if ( !gzipfile )
+ send( "213 " + QString::number( fi.size() ) );
+ else {
+ Process duproc( QString("du") );
+ duproc.addArgument("-s");
+ QString in, out;
+ if ( !duproc.exec(in, out) ) {
+ qDebug("du process failed; just sending back 1K");
+ send( "213 1024");
+ }
+ else {
+ QString size = out.left( out.find("\t") );
+ int guess = size.toInt() / 5;
+ if ( filePath.contains("doc") )
+ guess *= 1000;
+ qDebug("sending back gzip guess of %d", guess);
+ send( "213 " + QString::number(guess) );
+ }
+ }
+ }
+ }
+ // name list (NLST)
+ else if ( cmd == "NLST" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // site parameters (SITE)
+ else if ( cmd == "SITE" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // system (SYST)
+ else if ( cmd == "SYST" ) {
+ send( "215 UNIX Type: L8" );
+ }
+
+ // status (STAT)
+ else if ( cmd == "STAT" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // help (HELP )
+ else if ( cmd == "HELP" ) {
+ send( "502 Command not implemented" );
+ }
+
+ // noop (NOOP)
+ else if ( cmd == "NOOP" ) {
+ send( "200 Command okay" );
+ }
+
+ // not implemented
+ else
+ send( "502 Command not implemented" );
+
+ lastCommand = cmd;
+}
+
+bool ServerPI::backupRestoreGzip( const QString &file )
+{
+ return (file.find( "backup" ) != -1 &&
+ file.findRev( ".tgz" ) == (int)file.length() - 4 );
+}
+
+bool ServerPI::backupRestoreGzip( const QString &file, QStringList &targets )
+{
+ if ( file.find( "backup" ) != -1 &&
+ file.findRev( ".tgz" ) == (int)file.length() - 4 ) {
+ QFileInfo info( file );
+ targets = info.dirPath( TRUE );
+ qDebug("ServerPI::backupRestoreGzip for %s = %s", file.latin1(),
+ targets.join(" ").latin1() );
+ return true;
+ }
+ return false;
+}
+
+void ServerPI::sendFile( const QString& file )
+{
+ if ( passiv ) {
+ wait[SendFile] = TRUE;
+ waitfile = file;
+ if ( waitsocket )
+ newConnection( waitsocket );
+ }
+ else {
+ QStringList targets;
+ if ( backupRestoreGzip( file, targets ) )
+ dtp->sendGzipFile( file, targets, peeraddress, peerport );
+ else
+ dtp->sendFile( file, peeraddress, peerport );
+ }
+}
+
+void ServerPI::retrieveFile( const QString& file )
+{
+ if ( passiv ) {
+ wait[RetrieveFile] = TRUE;
+ waitfile = file;
+ if ( waitsocket )
+ newConnection( waitsocket );
+ }
+ else {
+ QStringList targets;
+ if ( backupRestoreGzip( file, targets ) )
+ dtp->retrieveGzipFile( file, peeraddress, peerport );
+ else
+ dtp->retrieveFile( file, peeraddress, peerport );
+ }
+}
+
+bool ServerPI::parsePort( const QString& pp )
+{
+ QStringList p = QStringList::split( ",", pp );
+ if ( p.count() != 6 )
+ return FALSE;
+
+ // h1,h2,h3,h4,p1,p2
+ peeraddress = QHostAddress( ( p[0].toInt() << 24 ) + ( p[1].toInt() << 16 ) +
+ ( p[2].toInt() << 8 ) + p[3].toInt() );
+ peerport = ( p[4].toInt() << 8 ) + p[5].toInt();
+ return TRUE;
+}
+
+void ServerPI::dtpCompleted()
+{
+ send( "226 Closing data connection, file transfer successful" );
+ if ( dtp->dtpMode() == ServerDTP::RetrieveFile ) {
+ QString fn = dtp->fileName();
+ if ( fn.right(8) == ".desktop" && fn.find("/Documents/") >= 0 ) {
+ QCopEnvelope e("QPE/System", "linkChanged(QString)" );
+ e << fn;
+ }
+ }
+ waitsocket = 0;
+ dtp->close();
+}
+
+void ServerPI::dtpFailed()
+{
+ dtp->close();
+ waitsocket = 0;
+ send( "451 Requested action aborted: local error in processing" );
+}
+
+void ServerPI::dtpError( int )
+{
+ dtp->close();
+ waitsocket = 0;
+ send( "451 Requested action aborted: local error in processing" );
+}
+
+bool ServerPI::sendList( const QString& arg )
+{
+ QByteArray listing;
+ QBuffer buffer( listing );
+
+ if ( !buffer.open( IO_WriteOnly ) )
+ return FALSE;
+
+ QTextStream ts( &buffer );
+ QString fn = arg;
+
+ if ( fn.isEmpty() )
+ fn = directory.path();
+
+ QFileInfo fi( fn );
+ if ( !fi.exists() )
+ return FALSE;
+
+ // return file listing
+ if ( fi.isFile() ) {
+ ts << fileListing( &fi ) << endl;
+ }
+
+ // return directory listing
+ else if ( fi.isDir() ) {
+ QDir dir( fn );
+ const QFileInfoList *list = dir.entryInfoList( QDir::All | QDir::Hidden );
+
+ QFileInfoListIterator it( *list );
+ QFileInfo *info;
+
+ unsigned long total = 0;
+ while ( ( info = it.current() ) ) {
+ if ( info->fileName() != "." && info->fileName() != ".." )
+ total += info->size();
+ ++it;
+ }
+
+ ts << "total " << QString::number( total / 1024 ) << endl;
+
+ it.toFirst();
+ while ( ( info = it.current() ) ) {
+ if ( info->fileName() == "." || info->fileName() == ".." ) {
+ ++it;
+ continue;
+ }
+ ts << fileListing( info ) << endl;
+ ++it;
+ }
+ }
+
+ if ( passiv ) {
+ waitarray = buffer.buffer();
+ wait[SendByteArray] = TRUE;
+ if ( waitsocket )
+ newConnection( waitsocket );
+ }
+ else
+ dtp->sendByteArray( buffer.buffer(), peeraddress, peerport );
+ return TRUE;
+}
+
+QString ServerPI::fileListing( QFileInfo *info )
+{
+ if ( !info )
+ return QString::null;
+ QString s;
+
+ // type char
+ if ( info->isDir() )
+ s += "d";
+ else if ( info->isSymLink() )
+ s += "l";
+ else
+ s += "-";
+
+ // permisson string
+ s += permissionString( info ) + " ";
+
+ // number of hardlinks
+ int subdirs = 1;
+
+ if ( info->isDir() )
+ subdirs = 2;
+ // FIXME : this is to slow
+ //if ( info->isDir() )
+ //subdirs = QDir( info->absFilePath() ).entryList( QDir::Dirs ).count();
+
+ s += QString::number( subdirs ).rightJustify( 3, ' ', TRUE ) + " ";
+
+ // owner
+ s += info->owner().leftJustify( 8, ' ', TRUE ) + " ";
+
+ // group
+ s += info->group().leftJustify( 8, ' ', TRUE ) + " ";
+
+ // file size in bytes
+ s += QString::number( info->size() ).rightJustify( 9, ' ', TRUE ) + " ";
+
+ // last modified date
+ QDate date = info->lastModified().date();
+ QTime time = info->lastModified().time();
+ s += date.monthName( date.month() ) + " "
+ + QString::number( date.day() ).rightJustify( 2, ' ', TRUE ) + " "
+ + QString::number( time.hour() ).rightJustify( 2, '0', TRUE ) + ":"
+ + QString::number( time.minute() ).rightJustify( 2, '0', TRUE ) + " ";
+
+ // file name
+ s += info->fileName();
+
+ return s;
+}
+
+QString ServerPI::permissionString( QFileInfo *info )
+{
+ if ( !info )
+ return QString( "---------" );
+ QString s;
+
+ // user
+ if ( info->permission( QFileInfo::ReadUser ) )
+ s += "r";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::WriteUser ) )
+ s += "w";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::ExeUser ) )
+ s += "x";
+ else
+ s += "-";
+
+ // group
+ if ( info->permission( QFileInfo::ReadGroup ) )
+ s += "r";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::WriteGroup ) )
+ s += "w";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::ExeGroup ) )
+ s += "x";
+ else
+ s += "-";
+
+ // exec
+ if ( info->permission( QFileInfo::ReadOther ) )
+ s += "r";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::WriteOther ) )
+ s += "w";
+ else
+ s += "-";
+ if ( info->permission( QFileInfo::ExeOther ) )
+ s += "x";
+ else
+ s += "-";
+
+ return s;
+}
+
+void ServerPI::newConnection( int socket )
+{
+ //qDebug( "New incomming connection" );
+
+ if ( !passiv )
+ return ;
+
+ if ( wait[SendFile] ) {
+ QStringList targets;
+ if ( backupRestoreGzip( waitfile, targets ) )
+ dtp->sendGzipFile( waitfile, targets );
+ else
+ dtp->sendFile( waitfile );
+ dtp->setSocket( socket );
+ }
+ else if ( wait[RetrieveFile] ) {
+ qDebug("check retrieve file");
+ if ( backupRestoreGzip( waitfile ) )
+ dtp->retrieveGzipFile( waitfile );
+ else
+ dtp->retrieveFile( waitfile );
+ dtp->setSocket( socket );
+ }
+ else if ( wait[SendByteArray] ) {
+ dtp->sendByteArray( waitarray );
+ dtp->setSocket( socket );
+ }
+ else if ( wait[RetrieveByteArray] ) {
+ qDebug("retrieve byte array");
+ dtp->retrieveByteArray();
+ dtp->setSocket( socket );
+ }
+ else
+ waitsocket = socket;
+
+ for ( int i = 0; i < 4; i++ )
+ wait[i] = FALSE;
+}
+
+QString ServerPI::absFilePath( const QString& file )
+{
+ if ( file.isEmpty() )
+ return file;
+
+ QString filepath( file );
+ if ( file[0] != "/" )
+ filepath = directory.path() + "/" + file;
+
+ return filepath;
+}
+
+
+void ServerPI::timerEvent( QTimerEvent * )
+{
+ connectionClosed();
+}
+
+
+ServerDTP::ServerDTP( QObject *parent, const char* name)
+ : QSocket( parent, name ), mode( Idle ), createTargzProc( 0 ),
+ retrieveTargzProc( 0 ), gzipProc( 0 )
+{
+
+ connect( this, SIGNAL( connected() ), SLOT( connected() ) );
+ connect( this, SIGNAL( connectionClosed() ), SLOT( connectionClosed() ) );
+ connect( this, SIGNAL( bytesWritten( int ) ), SLOT( bytesWritten( int ) ) );
+ connect( this, SIGNAL( readyRead() ), SLOT( readyRead() ) );
+
+ gzipProc = new OProcess( this, "gzipProc" );
+
+ createTargzProc = new OProcess( QString("tar"), this, "createTargzProc");
+ createTargzProc->setWorkingDirectory( QDir::rootDirPath() );
+ connect( createTargzProc, SIGNAL( processExited(OProcess *) ), SLOT( targzDone() ) );
+
+ QStringList args = "tar";
+ args += "-xv";
+ retrieveTargzProc = new OProcess( args, this, "retrieveTargzProc" );
+ retrieveTargzProc->setWorkingDirectory( QDir::rootDirPath() );
+ connect( retrieveTargzProc, SIGNAL( processExited(OProcess *) ),
+ SIGNAL( completed() ) );
+ connect( retrieveTargzProc, SIGNAL( processExited(OProcess *) ),
+ SLOT( extractTarDone() ) );
+}
+
+ServerDTP::~ServerDTP()
+{
+ buf.close();
+ file.close();
+ createTargzProc->kill();
+}
+
+void ServerDTP::extractTarDone()
+{
+ qDebug("extract done");
+#ifndef QT_NO_COP
+
+ QCopEnvelope e( "QPE/Desktop", "restoreDone(QString)" );
+ e << file.name();
+#endif
+}
+
+void ServerDTP::connected()
+{
+ // send file mode
+ switch ( mode ) {
+ case SendFile :
+ if ( !file.exists() || !file.open( IO_ReadOnly) ) {
+ emit failed();
+ mode = Idle;
+ return ;
+ }
+
+ //qDebug( "Debug: Sending file '%s'", file.name().latin1() );
+
+ bytes_written = 0;
+ if ( file.size() == 0 ) {
+ //make sure it doesn't hang on empty files
+ file.close();
+ emit completed();
+ mode = Idle;
+ }
+ else {
+
+ if ( !file.atEnd() ) {
+ QCString s;
+ s.resize( block_size );
+ int bytes = file.readBlock( s.data(), block_size );
+ writeBlock( s.data(), bytes );
+ }
+ }
+ break;
+ case SendGzipFile:
+ if ( createTargzProc->isRunning() ) {
+ // SHOULDN'T GET HERE, BUT DOING A SAFETY CHECK ANYWAY
+ qWarning("Previous tar --gzip process is still running; killing it...");
+ createTargzProc->kill();
+ }
+
+ bytes_written = 0;
+ qDebug("==>start send tar process");
+ if ( !createTargzProc->start(OProcess::NotifyOnExit, OProcess::Stdout) )
+ qWarning("Error starting %s or %s",
+ createTargzProc->args()[0].data(),
+ gzipProc->args()[0].data());
+ break;
+ case SendBuffer:
+ if ( !buf.open( IO_ReadOnly) ) {
+ emit failed();
+ mode = Idle;
+ return ;
+ }
+
+ // qDebug( "Debug: Sending byte array" );
+ bytes_written = 0;
+ while ( !buf.atEnd() )
+ putch( buf.getch() );
+ buf.close();
+ break;
+ case RetrieveFile:
+ // retrieve file mode
+ if ( file.exists() && !file.remove() ) {
+ emit failed();
+ mode = Idle;
+ return ;
+ }
+
+ if ( !file.open( IO_WriteOnly) ) {
+ emit failed();
+ mode = Idle;
+ return ;
+ }
+ // qDebug( "Debug: Retrieving file %s", file.name().latin1() );
+ break;
+ case RetrieveGzipFile:
+ qDebug("=-> starting tar process to receive .tgz file");
+ break;
+ case RetrieveBuffer:
+ // retrieve buffer mode
+ if ( !buf.open( IO_WriteOnly) ) {
+ emit failed();
+ mode = Idle;
+ return ;
+ }
+ // qDebug( "Debug: Retrieving byte array" );
+ break;
+ case Idle:
+ qDebug("connection established but mode set to Idle; BUG!");
+ break;
+ }
+}
+
+void ServerDTP::connectionClosed()
+{
+ //qDebug( "Debug: Data connection closed %ld bytes written", bytes_written );
+
+ // send file mode
+ if ( SendFile == mode ) {
+ if ( bytes_written == file.size() )
+ emit completed();
+ else
+ emit failed();
+ }
+
+ // send buffer mode
+ else if ( SendBuffer == mode ) {
+ if ( bytes_written == buf.size() )
+ emit completed();
+ else
+ emit failed();
+ }
+
+ // retrieve file mode
+ else if ( RetrieveFile == mode ) {
+ file.close();
+ emit completed();
+ }
+
+ else if ( RetrieveGzipFile == mode ) {
+ qDebug("Done writing ungzip file; closing input");
+ gzipProc->flushStdin();
+ gzipProc->closeStdin();
+ }
+
+ // retrieve buffer mode
+ else if ( RetrieveBuffer == mode ) {
+ buf.close();
+ emit completed();
+ }
+
+ mode = Idle;
+}
+
+void ServerDTP::bytesWritten( int bytes )
+{
+ bytes_written += bytes;
+
+ // send file mode
+ if ( SendFile == mode ) {
+
+ if ( bytes_written == file.size() ) {
+ // qDebug( "Debug: Sending complete: %d bytes", file.size() );
+ file.close();
+ emit completed();
+ mode = Idle;
+ }
+ else if ( !file.atEnd() ) {
+ QCString s;
+ s.resize( block_size );
+ int bytes = file.readBlock( s.data(), block_size );
+ writeBlock( s.data(), bytes );
+ }
+ }
+
+ // send buffer mode
+ if ( SendBuffer == mode ) {
+
+ if ( bytes_written == buf.size() ) {
+ // qDebug( "Debug: Sending complete: %d bytes", buf.size() );
+ emit completed();
+ mode = Idle;
+ }
+ }
+}
+
+void ServerDTP::readyRead()
+{
+ // retrieve file mode
+ if ( RetrieveFile == mode ) {
+ QCString s;
+ s.resize( bytesAvailable() );
+ readBlock( s.data(), bytesAvailable() );
+ file.writeBlock( s.data(), s.size() );
+ }
+ else if ( RetrieveGzipFile == mode ) {
+ if ( !gzipProc->isRunning() )
+ gzipProc->start(OProcess::NotifyOnExit, (OProcess::Communication) ( OProcess::Stdin | OProcess::Stdout ));
+
+ QByteArray s;
+ s.resize( bytesAvailable() );
+ readBlock( s.data(), bytesAvailable() );
+ gzipProc->writeStdin( s.data(), s.size() );
+ qDebug("wrote %d bytes to ungzip ", s.size() );
+ }
+ // retrieve buffer mode
+ else if ( RetrieveBuffer == mode ) {
+ QCString s;
+ s.resize( bytesAvailable() );
+ readBlock( s.data(), bytesAvailable() );
+ buf.writeBlock( s.data(), s.size() );
+ }
+}
+
+void ServerDTP::writeTargzBlock(OProcess *, char *buffer, int buflen)
+{
+ writeBlock( buffer, buflen );
+ qDebug("writeTargzBlock %d", buflen);
+ if ( !createTargzProc->isRunning() ) {
+ qDebug("tar and gzip done");
+ emit completed();
+ mode = Idle;
+ disconnect( gzipProc, SIGNAL( receivedStdout(OProcess *, char *, int ) ),
+ this, SLOT( writeTargzBlock(OProcess *, char *, int) ) );
+ }
+}
+
+void ServerDTP::targzDone()
+{
+ //qDebug("targz done");
+ disconnect( createTargzProc, SIGNAL( receivedStdout(OProcess *, char *, int) ),
+ this, SLOT( gzipTarBlock(OProcess *, char *, int) ) );
+ gzipProc->closeStdin();
+}
+
+void ServerDTP::gzipTarBlock(OProcess *, char *buffer, int buflen)
+{
+ //qDebug("gzipTarBlock");
+ if ( !gzipProc->isRunning() ) {
+ //qDebug("auto start gzip proc");
+ gzipProc->start(OProcess::NotifyOnExit, (OProcess::Communication) ( OProcess::Stdin | OProcess::Stdout ));
+ }
+ gzipProc->writeStdin( buffer, buflen );
+}
+
+void ServerDTP::sendFile( const QString fn, const QHostAddress& host, Q_UINT16 port )
+{
+ file.setName( fn );
+ mode = SendFile;
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::sendFile( const QString fn )
+{
+ file.setName( fn );
+ mode = SendFile;
+}
+
+void ServerDTP::sendGzipFile( const QString &fn,
+ const QStringList &archiveTargets,
+ const QHostAddress& host, Q_UINT16 port )
+{
+ sendGzipFile( fn, archiveTargets );
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::sendGzipFile( const QString &fn,
+ const QStringList &archiveTargets )
+{
+ mode = SendGzipFile;
+ file.setName( fn );
+
+ QStringList args = "tar";
+ args += "-cv";
+ args += archiveTargets;
+ qDebug("sendGzipFile %s", args.join(" ").latin1() );
+ createTargzProc->clearArguments( );
+ *createTargzProc << args;
+ connect( createTargzProc,
+ SIGNAL( receivedStdout(OProcess *, char *, int) ), SLOT( gzipTarBlock(OProcess *, char *, int) ) );
+
+ gzipProc->clearArguments( );
+ *gzipProc << "gzip";
+ connect( gzipProc, SIGNAL( receivedStdout(OProcess *, char *, int) ),
+ SLOT( writeTargzBlock(OProcess *, char *, int) ) );
+}
+
+void ServerDTP::gunzipDone()
+{
+ qDebug("gunzipDone");
+ disconnect( gzipProc, SIGNAL( processExited() ),
+ this, SLOT( gunzipDone() ) );
+ retrieveTargzProc->closeStdin();
+ disconnect( gzipProc, SIGNAL( receivedStdout(OProcess *, char *, int) ),
+ this, SLOT( tarExtractBlock(OProcess *, char *, int) ) );
+}
+
+void ServerDTP::tarExtractBlock(OProcess *, char *buffer, int buflen)
+{
+ qDebug("tarExtractBlock");
+ if ( !retrieveTargzProc->isRunning() ) {
+ qDebug("auto start ungzip proc");
+ if ( !retrieveTargzProc->start(OProcess::NotifyOnExit, OProcess::Stdin) )
+ qWarning(" failed to start tar -x process");
+ }
+ retrieveTargzProc->writeStdin( buffer, buflen );
+}
+
+
+void ServerDTP::retrieveFile( const QString fn, const QHostAddress& host, Q_UINT16 port )
+{
+ file.setName( fn );
+ mode = RetrieveFile;
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::retrieveFile( const QString fn )
+{
+ file.setName( fn );
+ mode = RetrieveFile;
+}
+
+void ServerDTP::retrieveGzipFile( const QString &fn )
+{
+ qDebug("retrieveGzipFile %s", fn.latin1());
+ file.setName( fn );
+ mode = RetrieveGzipFile;
+
+ gzipProc->clearArguments();
+ *gzipProc << "gunzip";
+ connect( gzipProc, SIGNAL( readyReadStdout() ),
+ SLOT( tarExtractBlock() ) );
+ connect( gzipProc, SIGNAL( processExited() ),
+ SLOT( gunzipDone() ) );
+}
+
+void ServerDTP::retrieveGzipFile( const QString &fn, const QHostAddress& host, Q_UINT16 port )
+{
+ retrieveGzipFile( fn );
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::sendByteArray( const QByteArray& array, const QHostAddress& host, Q_UINT16 port )
+{
+ buf.setBuffer( array );
+ mode = SendBuffer;
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::sendByteArray( const QByteArray& array )
+{
+ buf.setBuffer( array );
+ mode = SendBuffer;
+}
+
+void ServerDTP::retrieveByteArray( const QHostAddress& host, Q_UINT16 port )
+{
+ buf.setBuffer( QByteArray() );
+ mode = RetrieveBuffer;
+ connectToHost( host.toString(), port );
+}
+
+void ServerDTP::retrieveByteArray()
+{
+ buf.setBuffer( QByteArray() );
+ mode = RetrieveBuffer;
+}
+
+void ServerDTP::setSocket( int socket )
+{
+ QSocket::setSocket( socket );
+ connected();
+}
+
diff --git a/core/qws/transferserver.h b/core/qws/transferserver.h
new file mode 100644
index 0000000..1c5ab4b
--- a/dev/null
+++ b/core/qws/transferserver.h
@@ -0,0 +1,179 @@
+/**********************************************************************
+** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
+**
+** This file is part of the Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+#include <qserversocket.h>
+#include <qsocket.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qbuffer.h>
+
+class QFileInfo;
+class OProcess;
+class TransferServer : public QServerSocket
+{
+ Q_OBJECT
+
+public:
+ TransferServer( Q_UINT16 port, QObject *parent = 0, const char* name = 0 );
+ virtual ~TransferServer();
+
+ void newConnection( int socket );
+};
+
+class SyncAuthentication : QObject
+{
+ Q_OBJECT
+
+public:
+ static int isAuthorized(QHostAddress peeraddress);
+ static bool checkPassword(const QString& pw);
+ static bool checkUser(const QString& user);
+
+ static QString serverId();
+ static QString loginName();
+ static QString ownerName();
+};
+
+
+class ServerDTP : public QSocket
+{
+ Q_OBJECT
+
+public:
+ ServerDTP( QObject *parent = 0, const char* name = 0 );
+ ~ServerDTP();
+
+ enum Mode{ Idle = 0, SendFile, SendGzipFile, SendBuffer,
+ RetrieveFile, RetrieveGzipFile, RetrieveBuffer };
+
+ void sendFile( const QString fn );
+ void sendFile( const QString fn, const QHostAddress& host, Q_UINT16 port );
+ void sendGzipFile( const QString &fn, const QStringList &archiveTargets );
+ void sendGzipFile( const QString &fn, const QStringList &archiveTargets,
+ const QHostAddress& host, Q_UINT16 port );
+ void sendByteArray( const QByteArray& array );
+ void sendByteArray( const QByteArray& array, const QHostAddress& host, Q_UINT16 port );
+
+ void retrieveFile( const QString fn );
+ void retrieveFile( const QString fn, const QHostAddress& host, Q_UINT16 port );
+ void retrieveGzipFile( const QString &fn );
+ void retrieveGzipFile( const QString &fn, const QHostAddress& host, Q_UINT16 port );
+ void retrieveByteArray();
+ void retrieveByteArray( const QHostAddress& host, Q_UINT16 port );
+
+ Mode dtpMode() { return mode; }
+ QByteArray buffer() { return buf.buffer(); }
+ QString fileName() const { return file.name(); }
+
+ void setSocket( int socket );
+
+signals:
+ void completed();
+ void failed();
+
+private slots:
+ void connectionClosed();
+ void connected();
+ void bytesWritten( int bytes );
+ void readyRead();
+ void writeTargzBlock(OProcess *, char *, int);
+ void targzDone();
+
+ void gzipTarBlock(OProcess *, char *, int);
+ void tarExtractBlock(OProcess *, char *, int);
+ void gunzipDone();
+ void extractTarDone();
+
+private:
+
+ unsigned long bytes_written;
+ Mode mode;
+ QFile file;
+ QBuffer buf;
+ OProcess *createTargzProc;
+ OProcess *retrieveTargzProc;
+ OProcess *gzipProc;
+};
+
+class ServerSocket : public QServerSocket
+{
+ Q_OBJECT
+
+public:
+ ServerSocket( Q_UINT16 port, QObject *parent = 0, const char* name = 0 )
+ : QServerSocket( port, 1, parent, name ) {}
+
+ void newConnection( int socket ) { emit newIncomming( socket ); }
+signals:
+ void newIncomming( int socket );
+};
+
+class ServerPI : public QSocket
+{
+ Q_OBJECT
+
+ enum State { Connected, Wait_USER, Wait_PASS, Ready, Forbidden };
+ enum Transfer { SendFile = 0, RetrieveFile = 1, SendByteArray = 2, RetrieveByteArray = 3 };
+
+public:
+ ServerPI( int socket, QObject *parent = 0, const char* name = 0 );
+ virtual ~ServerPI();
+
+protected slots:
+ void read();
+ void send( const QString& msg );
+ void process( const QString& command );
+ void connectionClosed();
+ void dtpCompleted();
+ void dtpFailed();
+ void dtpError( int );
+ void newConnection( int socket );
+
+protected:
+ bool checkReadFile( const QString& file );
+ bool checkWriteFile( const QString& file );
+ bool parsePort( const QString& pw );
+ bool backupRestoreGzip( const QString &file, QStringList &targets );
+ bool backupRestoreGzip( const QString &file );
+
+ bool sendList( const QString& arg );
+ void sendFile( const QString& file );
+ void retrieveFile( const QString& file );
+
+ QString permissionString( QFileInfo *info );
+ QString fileListing( QFileInfo *info );
+ QString absFilePath( const QString& file );
+
+ void timerEvent( QTimerEvent *e );
+
+private:
+ State state;
+ Q_UINT16 peerport;
+ QHostAddress peeraddress;
+ bool passiv;
+ bool wait[4];
+ ServerDTP *dtp;
+ ServerSocket *serversocket;
+ QString waitfile;
+ QDir directory;
+ QByteArray waitarray;
+ QString renameFrom;
+ QString lastCommand;
+ int waitsocket;
+};