slavebase.h

Go to the documentation of this file.

/*
   Copyright (C) 2000 David Faure <faure@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef SLAVEBASE_H
#define SLAVEBASE_H

#include <kio/global.h>
#include <kio/udsentry.h>
#include <kio/authinfo.h>
#include <kio/jobclasses.h> // for KIO::JobFlags
#include <klocale.h>

#include <QtCore/QByteArray>
#include <QtNetwork/QHostInfo>

class KConfigGroup;
class KRemoteEncoding;
class KUrl;

namespace KIO {

class Connection;
class SlaveBasePrivate;

class KIO_EXPORT SlaveBase
{
public:
    SlaveBase( const QByteArray &protocol, const QByteArray &pool_socket, const QByteArray &app_socket);
    virtual ~SlaveBase();

    void exit();

    void dispatchLoop();

    // Message Signals to send to the job

    void data( const QByteArray &data );

    void dataReq( );

    void opened();

    void error( int _errid, const QString &_text );

    void connected();

    void finished();

    void needSubUrlData();

    void slaveStatus(const QString &host, bool connected);

    void statEntry( const UDSEntry& _entry );

    void listEntries( const UDSEntryList& _entry );

    bool canResume( KIO::filesize_t offset );

    void canResume();

    // Info Signals to send to the job

    void totalSize( KIO::filesize_t _bytes );
    void processedSize( KIO::filesize_t _bytes );

    void position( KIO::filesize_t _pos );

    void written( KIO::filesize_t _bytes );

    void processedPercent( float percent );

    void speed( unsigned long _bytes_per_second );

    void redirection( const KUrl &_url );

    void errorPage();

    void mimeType( const QString &_type );

    void warning( const QString &msg );

    void infoMessage( const QString &msg );

    enum MessageBoxType { QuestionYesNo = 1, WarningYesNo = 2, WarningContinueCancel = 3, WarningYesNoCancel = 4, Information = 5, SSLMessageBox = 6 };

    int messageBox( MessageBoxType type, const QString &text,
                    const QString &caption = QString(),
                    const QString &buttonYes = i18n("&Yes"),
                    const QString &buttonNo = i18n("&No"));

    int messageBox( const QString &text, MessageBoxType type,
                    const QString &caption = QString(),
                    const QString &buttonYes = i18n("&Yes"),
                    const QString &buttonNo = i18n("&No"),
                    const QString &dontAskAgainName = QString() );

    void setMetaData(const QString &key, const QString &value);
    
    bool hasMetaData(const QString &key) const;

    QString metaData(const QString &key) const;


    MetaData allMetaData() const;

    KConfigGroup* config();

    KRemoteEncoding* remoteEncoding();


    // Commands sent by the job, the slave has to
    // override what it wants to implement

    virtual void setHost(const QString& host, quint16 port, const QString& user, const QString& pass);

    virtual void setSubUrl(const KUrl&url);

    virtual void openConnection();

    virtual void closeConnection();

    virtual void get( const KUrl& url );

    virtual void open( const KUrl &url, QIODevice::OpenMode mode );

    virtual void read( KIO::filesize_t size );
    virtual void write( const QByteArray &data );
    virtual void seek( KIO::filesize_t offset );
    virtual void close();

    virtual void put( const KUrl& url, int permissions, JobFlags flags );

    virtual void stat( const KUrl& url );

    virtual void mimetype( const KUrl& url );

    virtual void listDir( const KUrl& url );

    virtual void mkdir( const KUrl&url, int permissions );

    virtual void rename( const KUrl& src, const KUrl& dest, JobFlags flags );

    virtual void symlink( const QString& target, const KUrl& dest, JobFlags flags );

    virtual void chmod( const KUrl& url, int permissions );

    virtual void chown( const KUrl& url, const QString& owner, const QString& group );

    virtual void setModificationTime( const KUrl& url, const QDateTime& mtime );

    virtual void copy( const KUrl &src, const KUrl &dest, int permissions, JobFlags flags );

    virtual void del( const KUrl &url, bool isfile);

    virtual void setLinkDest( const KUrl& url, const QString& target );

    virtual void special( const QByteArray & data );

    virtual void multiGet( const QByteArray & data );

    virtual void slave_status();

    virtual void reparseConfiguration();


    int connectTimeout();

    int proxyConnectTimeout();

    int responseTimeout();

    int readTimeout();

    void setTimeoutSpecialCommand(int timeout, const QByteArray &data=QByteArray());

    // Dispatching (internal)

    virtual void dispatch( int command, const QByteArray &data );

    virtual void dispatchOpenCommand( int command, const QByteArray &data );

    int readData( QByteArray &buffer );

    void listEntry( const UDSEntry& _entry, bool ready);

    void connectSlave(const QString& path);
    void disconnectSlave();

    bool openPasswordDialog( KIO::AuthInfo& info, const QString &errorMsg = QString() );

    bool checkCachedAuthentication( AuthInfo& info );

    bool cacheAuthentication( const AuthInfo& info );

    bool requestNetwork(const QString& host = QString());

    void dropNetwork(const QString& host = QString());

    int waitForAnswer( int expected1, int expected2, QByteArray & data, int * pCmd = 0 );

    void sendMetaData();

    void sendAndKeepMetaData();

    bool wasKilled() const;

    void setKillFlag();

    void lookupHost(const QString& host);

    int waitForHostInfo(QHostInfo& info);

protected:
    QByteArray mProtocol;
    //Often used by TcpSlaveBase and unlikely to change
    MetaData mOutgoingMetaData;
    MetaData mIncomingMetaData;

    enum VirtualFunctionId {
        AppConnectionMade = 0
    };
    virtual void virtual_hook( int id, void* data );

private:
#if 0 // TODO KDE5: enable
    // This helps catching missing tr() calls in error().
    void error( int _errid, const QByteArray &_text );
#endif
    void send(int cmd, const QByteArray& arr = QByteArray());
    SlaveBasePrivate* const d;
    friend class SlaveBasePrivate;
};

}

#endif