slavebase.h

/*
   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 <kurl.h>
#include <tdeconfigbase.h>
#include <tdeio/global.h>
#include <tdeio/authinfo.h>
 
class DCOPClient;
class KRemoteEncoding;
 
namespace TDEIO {
 
class Connection;
class SlaveBasePrivate;

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

    void exit();

    void dispatchLoop();

    void setConnection( Connection* connection ) { m_pConnection = connection; }
    Connection *connection() const { return m_pConnection; }
 

    // Message Signals to send to the job

    void data( const TQByteArray &data );

    void dataReq( );

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

    void connected();

    void finished();

    void needSubURLData();

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

    void statEntry( const UDSEntry& _entry );

    void listEntries( const UDSEntryList& _entry );

    bool canResume( TDEIO::filesize_t offset );
 
    /*
     * Call this at the beginning of get(), if the "resume" metadata was set
     * and resuming is implemented by this protocol.
     */
    void canResume();

    // Info Signals to send to the job

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

    void processedPercent( float percent );

    void speed( unsigned long _bytes_per_second );

    void redirection( const KURL &_url );

    void errorPage();

    void mimeType( const TQString &_type );

    void warning( const TQString &msg );

    void infoMessage( const TQString &msg );
 
    enum MessageBoxType { QuestionYesNo = 1, WarningYesNo = 2, WarningContinueCancel = 3, WarningYesNoCancel = 4, Information = 5, SSLMessageBox = 6 };

    int messageBox( MessageBoxType type, const TQString &text,
                    const TQString &caption = TQString::null,
                    const TQString &buttonYes = TQString::null,
                    const TQString &buttonNo = TQString::null );

    int messageBox( const TQString &text, MessageBoxType type,
                    const TQString &caption = TQString::null,
                    const TQString &buttonYes = TQString::null,
                    const TQString &buttonNo = TQString::null,
                    const TQString &dontAskAgainName = TQString::null );

    void setMetaData(const TQString &key, const TQString &value);

    bool hasMetaData(const TQString &key) const;

    TQString metaData(const TQString &key) const;

    bool hasMetaData(const TQString &key);

    TQString metaData(const TQString &key);

    MetaData allMetaData() const { return mIncomingMetaData; }

    TDEConfigBase* config();

    KRemoteEncoding* remoteEncoding();
 

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

    virtual void setHost(const TQString& host, int port, const TQString& user, const TQString& pass);

    virtual void setSubURL(const KURL&url);

    virtual void openConnection();

    virtual void closeConnection();

    virtual void get( const KURL& url );

    virtual void put( const KURL& url, int permissions, bool overwrite, bool resume );

    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, bool overwrite );

    virtual void symlink( const TQString& target, const KURL& dest, bool overwrite );

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

    virtual void copy( const KURL &src, const KURL &dest, int permissions, bool overwrite );

    virtual void del( const KURL &url, bool isfile);
 
    // TODO KDE4: add setLinkDest() or something, to modify symlink targets.
    // Will be used for tdeio_file but also tdeio_remote (#97129)

    virtual void special( const TQByteArray & data );

    virtual void multiGet( const TQByteArray & data );

    virtual void slave_status();

    virtual void reparseConfiguration();

    virtual void localURL( const KURL& remoteURL );

    int connectTimeout();

    int proxyConnectTimeout();

    int responseTimeout();

    int readTimeout();

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

    static void sigsegv_handler(int);
    static void sigpipe_handler(int);

    // Dispatching (internal)

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

    int readData( TQByteArray &buffer );

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

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

    bool openPassDlg( TDEIO::AuthInfo& info, const TQString &errorMsg );

    bool openPassDlg( TDEIO::AuthInfo& info );

    bool checkCachedAuthentication( AuthInfo& info );

    bool cacheAuthentication( const AuthInfo& info );

    bool pingCacheDaemon() const;

    TQString createAuthCacheKey( const KURL& url );

    void sendAuthenticationKey( const TQCString& gKey, const TQCString& key, bool keep );

    void delCachedAuthentication( const TQString& key );

    void setMultipleAuthCaching( bool ) {};

    bool multipleAuthCaching() const { return false; }

    bool requestNetwork(const TQString& host = TQString::null);

    void dropNetwork(const TQString& host = TQString::null);

    DCOPClient *dcopClient();

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

    void sendMetaData();

    TQCString mProtocol;
 
    Connection * m_pConnection;
 
    MetaData mOutgoingMetaData;
    MetaData mIncomingMetaData;

    bool wasKilled() const;

    void setKillFlag();
 
protected:
    UDSEntryList pendingListEntries;
    uint listEntryCurrentSize;
    long listEntry_sec, listEntry_usec;
    Connection *appconn;
    TQString mPoolSocket;
    TQString mAppSocket;
    bool mConnectedToApp;
    static long s_seqNr;
    virtual void virtual_hook( int id, void* data );
 
private:
    SlaveBasePrivate *d;
};
 
}
 
#endif