• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdelibs

• Sitemap
• Contact Us

 

KIO

job.cpp

Go to the documentation of this file.

/* This file is part of the KDE libraries
    Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
                       David Faure <faure@kde.org>
                       Waldo Bastian <bastian@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.
*/

#include "job.h"
#include "job_p.h"

#include <config.h>

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>

#include <assert.h>

#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
extern "C" {
#include <pwd.h>
#include <grp.h>
}
#include <QtCore/QTimer>
#include <QtCore/QFile>

#include <kapplication.h>
#include <kauthorized.h>
#include <kglobal.h>
#include <klocale.h>
#include <kconfig.h>
#include <kdebug.h>
#include <kde_file.h>

#include <errno.h>

#include "jobuidelegate.h"
#include "kmimetype.h"
#include "slave.h"
#include "scheduler.h"
#include "kdirwatch.h"
#include "kprotocolinfo.h"
#include "kprotocolmanager.h"
#include "filejob.h"

#include "kssl/ksslcsessioncache.h"

#include <kdirnotify.h>
#include <ktemporaryfile.h>

#ifdef Q_OS_UNIX
#include <utime.h>
#endif

using namespace KIO;

static inline Slave *jobSlave(SimpleJob *job)
{
    return SimpleJobPrivate::get(job)->m_slave;
}

//this will update the report dialog with 5 Hz, I think this is fast enough, aleXXX
#define REPORT_TIMEOUT 200

#define KIO_ARGS QByteArray packedArgs; QDataStream stream( &packedArgs, QIODevice::WriteOnly ); stream

Job::Job() : KCompositeJob(*new JobPrivate, 0)
{
    setCapabilities( KJob::Killable | KJob::Suspendable );
}

Job::Job(JobPrivate &dd) : KCompositeJob(dd, 0)
{
    setCapabilities( KJob::Killable | KJob::Suspendable );
}

Job::~Job()
{
}

JobUiDelegate *Job::ui() const
{
    return static_cast<JobUiDelegate*>( uiDelegate() );
}

bool Job::addSubjob(KJob *jobBase)
{
    //kDebug(7007) << "addSubjob(" << jobBase << ") this=" << this;

    bool ok = KCompositeJob::addSubjob( jobBase );
    KIO::Job *job = dynamic_cast<KIO::Job*>( jobBase );
    if (ok && job) {
        // Copy metadata into subjob (e.g. window-id, user-timestamp etc.)
        Q_D(Job);
        job->mergeMetaData(d->m_outgoingMetaData);

        // Forward information from that subjob.
        connect( job, SIGNAL(speed( KJob*, unsigned long )),
                 SLOT(slotSpeed(KJob*, unsigned long)) );

        if (ui() && job->ui()) {
            job->ui()->setWindow( ui()->window() );
            job->ui()->updateUserTimestamp( ui()->userTimestamp() );
        }
    }
    return ok;
}

bool Job::removeSubjob( KJob *jobBase )
{
    //kDebug(7007) << "removeSubjob(" << jobBase << ") this=" << this << "subjobs=" << subjobs().count();
    return KCompositeJob::removeSubjob( jobBase );
}

void JobPrivate::emitMoving(KIO::Job * job, const KUrl &src, const KUrl &dest)
{
    emit job->description(job, i18nc("@title job","Moving"),
                          qMakePair(i18n("Source"), src.prettyUrl()),
                          qMakePair(i18n("Destination"), dest.prettyUrl()));
}

void JobPrivate::emitCopying(KIO::Job * job, const KUrl &src, const KUrl &dest)
{
    emit job->description(job, i18nc("@title job","Copying"),
                          qMakePair(i18n("Source"), src.prettyUrl()),
                          qMakePair(i18n("Destination"), dest.prettyUrl()));
}

void JobPrivate::emitCreatingDir(KIO::Job * job, const KUrl &dir)
{
    emit job->description(job, i18nc("@title job","Creating directory"),
                          qMakePair(i18n("Directory"), dir.prettyUrl()));
}

void JobPrivate::emitDeleting(KIO::Job *job, const KUrl &url)
{
    emit job->description(job, i18nc("@title job","Deleting"),
                          qMakePair(i18n("File"), url.prettyUrl()));
}

void JobPrivate::emitStating(KIO::Job *job, const KUrl &url)
{
    emit job->description(job, i18nc("@title job","Stating"),
                          qMakePair(i18n("File"), url.prettyUrl()));
}

void JobPrivate::emitTransferring(KIO::Job *job, const KUrl &url)
{
    emit job->description(job, i18nc("@title job","Transferring"),
                          qMakePair(i18n("Source"), url.prettyUrl()));
}

void JobPrivate::emitMounting(KIO::Job * job, const QString &dev, const QString &point)
{
    emit job->description(job, i18nc("@title job","Mounting"),
                          qMakePair(i18n("Device"), dev),
                          qMakePair(i18n("Mountpoint"), point));
}

void JobPrivate::emitUnmounting(KIO::Job * job, const QString &point)
{
    emit job->description(job, i18nc("@title job","Unmounting"),
                          qMakePair(i18n("Mountpoint"), point));
}

bool Job::doKill()
{
  // kill all subjobs, without triggering their result slot
  Q_FOREACH( KJob* it, subjobs()) {
      it->kill( KJob::Quietly );
  }
  clearSubjobs();

  return true;
}

bool Job::doSuspend()
{
    Q_FOREACH(KJob* it, subjobs()) {
        if (!it->suspend())
            return false;
    }

    return true;
}

bool Job::doResume()
{
    Q_FOREACH ( KJob* it, subjobs() )
    {
        if (!it->resume())
            return false;
    }

    return true;
}

void JobPrivate::slotSpeed( KJob*, unsigned long speed )
{
    //kDebug(7007) << speed;
    q_func()->emitSpeed( speed );
}

//Job::errorString is implemented in global.cpp

void Job::showErrorDialog( QWidget *parent )
{
    if ( ui() )
    {
        ui()->setWindow( parent );
        ui()->showErrorMessage();
    }
    else
    {
        kError() << errorString();
    }
}

bool Job::isInteractive() const
{
  return uiDelegate() != 0;
}

void Job::setParentJob(Job* job)
{
  Q_D(Job);
  Q_ASSERT(d->m_parentJob == 0L);
  Q_ASSERT(job);
  d->m_parentJob = job;
}

Job* Job::parentJob() const
{
  return d_func()->m_parentJob;
}

MetaData Job::metaData() const
{
    return d_func()->m_incomingMetaData;
}

QString Job::queryMetaData(const QString &key)
{
    return d_func()->m_incomingMetaData.value(key, QString());
}

void Job::setMetaData( const KIO::MetaData &_metaData)
{
    Q_D(Job);
    d->m_outgoingMetaData = _metaData;
}

void Job::addMetaData( const QString &key, const QString &value)
{
    d_func()->m_outgoingMetaData.insert(key, value);
}

void Job::addMetaData( const QMap<QString,QString> &values)
{
    Q_D(Job);
    QMap<QString,QString>::const_iterator it = values.begin();
    for(;it != values.end(); ++it)
        d->m_outgoingMetaData.insert(it.key(), it.value());
}

void Job::mergeMetaData( const QMap<QString,QString> &values)
{
    Q_D(Job);
    QMap<QString,QString>::const_iterator it = values.begin();
    for(;it != values.end(); ++it)
        // there's probably a faster way
        if ( !d->m_outgoingMetaData.contains( it.key() ) )
            d->m_outgoingMetaData.insert( it.key(), it.value() );
}

MetaData Job::outgoingMetaData() const
{
    return d_func()->m_outgoingMetaData;
}

SimpleJob::SimpleJob(SimpleJobPrivate &dd)
  : Job(dd)
{
    d_func()->simpleJobInit();
}

void SimpleJobPrivate::simpleJobInit()
{
    Q_Q(SimpleJob);
    if (!m_url.isValid())
    {
        q->setError( ERR_MALFORMED_URL );
        q->setErrorText( m_url.url() );
        QTimer::singleShot(0, q, SLOT(slotFinished()) );
        return;
    }

    Scheduler::doJob(q);
}


bool SimpleJob::doKill()
{
    //kDebug() << this;
    Q_D(SimpleJob);
    Scheduler::cancelJob( this ); // deletes the slave if not 0
    d->m_slave = 0; // -> set to 0
    return Job::doKill();
}

bool SimpleJob::doSuspend()
{
    Q_D(SimpleJob);
    if ( d->m_slave )
        d->m_slave->suspend();
    return Job::doSuspend();
}

bool SimpleJob::doResume()
{
    Q_D(SimpleJob);
    if ( d->m_slave )
        d->m_slave->resume();
    return Job::doResume();
}

const KUrl& SimpleJob::url() const
{
    return d_func()->m_url;
}

void SimpleJob::putOnHold()
{
    Q_D(SimpleJob);
    Q_ASSERT( d->m_slave );
    if ( d->m_slave )
    {
        Scheduler::putSlaveOnHold(this, d->m_url);
        d->m_slave = 0;
    }
    kill( Quietly );
}

void SimpleJob::removeOnHold()
{
    Scheduler::removeSlaveOnHold();
}

SimpleJob::~SimpleJob()
{
    Q_D(SimpleJob);
    if (d->m_slave) // was running
    {
        kDebug(7007) << "Killing running job in destructor!"  << kBacktrace();
#if 0
        d->m_slave->kill();
        Scheduler::jobFinished( this, d->m_slave ); // deletes the slave
#endif
        Scheduler::cancelJob( this );
        d->m_slave = 0; // -> set to 0
    }
}

void SimpleJobPrivate::start(Slave *slave)
{
    Q_Q(SimpleJob);
    m_slave = slave;

    q->connect( slave, SIGNAL( error( int , const QString & ) ),
                SLOT( slotError( int , const QString & ) ) );

    q->connect( slave, SIGNAL( warning( const QString & ) ),
                SLOT( slotWarning( const QString & ) ) );

    q->connect( slave, SIGNAL( infoMessage( const QString & ) ),
                SLOT( _k_slotSlaveInfoMessage( const QString & ) ) );

    q->connect( slave, SIGNAL( connected() ),
                SLOT( slotConnected() ) );

    q->connect( slave, SIGNAL( finished() ),
                SLOT( slotFinished() ) );

    if ((m_extraFlags & EF_TransferJobDataSent) == 0)
    {
        q->connect( slave, SIGNAL( totalSize( KIO::filesize_t ) ),
                    SLOT( slotTotalSize( KIO::filesize_t ) ) );

        q->connect( slave, SIGNAL( processedSize( KIO::filesize_t ) ),
                    SLOT( slotProcessedSize( KIO::filesize_t ) ) );

        q->connect( slave, SIGNAL( speed( unsigned long ) ),
                    SLOT( slotSpeed( unsigned long ) ) );
    }
    q->connect( slave, SIGNAL(metaData( const KIO::MetaData& ) ),
                SLOT( slotMetaData( const KIO::MetaData& ) ) );

    if (ui() && ui()->window())
    {
        m_outgoingMetaData.insert("window-id", QString::number((long)ui()->window()->winId()));
    }

    if (ui() && ui()->userTimestamp())
    {
        m_outgoingMetaData.insert("user-timestamp", QString::number(ui()->userTimestamp()));
    }

    QString sslSession = KSSLCSessionCache::getSessionForUrl(m_url);
    if ( !sslSession.isNull() )
    {
        m_outgoingMetaData.insert("ssl_session_id", sslSession);
    }

    if (ui() == 0)              // not interactive
    {
        m_outgoingMetaData.insert("no-auth-prompt", "true");
    }

    if (!m_outgoingMetaData.isEmpty())
    {
        KIO_ARGS << m_outgoingMetaData;
        slave->send( CMD_META_DATA, packedArgs );
    }

    if (!m_subUrl.isEmpty())
    {
       KIO_ARGS << m_subUrl;
       slave->send( CMD_SUBURL, packedArgs );
    }

    slave->send( m_command, m_packedArgs );
}

void SimpleJobPrivate::slaveDone()
{
    Q_Q(SimpleJob);
    if (!m_slave) return;
    if (m_command == CMD_OPEN) m_slave->send(CMD_CLOSE);
    q->disconnect(m_slave); // Remove all signals between slave and job
    Scheduler::jobFinished( q, m_slave );
    m_slave = 0;
}

void SimpleJob::slotFinished( )
{
    Q_D(SimpleJob);
    // Return slave to the scheduler
    d->slaveDone();

    if (!hasSubjobs())
    {
        if ( !error() && (d->m_command == CMD_MKDIR || d->m_command == CMD_RENAME ) )
        {
            if ( d->m_command == CMD_MKDIR )
            {
                KUrl urlDir( url() );
                urlDir.setPath( urlDir.directory() );
                org::kde::KDirNotify::emitFilesAdded( urlDir.url() );
            }
            else /*if ( m_command == CMD_RENAME )*/
            {
                KUrl src, dst;
                QDataStream str( d->m_packedArgs );
                str >> src >> dst;
                if( src.directory() == dst.directory() ) // For the user, moving isn't renaming. Only renaming is.
                    org::kde::KDirNotify::emitFileRenamed( src.url(), dst.url() );

                org::kde::KDirNotify::emitFileMoved( src.url(), dst.url() );
            }
        }
        emitResult();
    }
}

void SimpleJob::slotError( int err, const QString & errorText )
{
    Q_D(SimpleJob);
    setError( err );
    setErrorText( errorText );
    if ((error() == ERR_UNKNOWN_HOST) && d->m_url.host().isEmpty())
       setErrorText( QString() );
    // error terminates the job
    slotFinished();
}

void SimpleJob::slotWarning( const QString & errorText )
{
    emit warning( this, errorText );
}

void SimpleJobPrivate::_k_slotSlaveInfoMessage( const QString & msg )
{
    emit q_func()->infoMessage( q_func(), msg );
}

void SimpleJobPrivate::slotConnected()
{
    emit q_func()->connected( q_func() );
}

void SimpleJobPrivate::slotTotalSize( KIO::filesize_t size )
{
    Q_Q(SimpleJob);
    if (size > q->totalAmount(KJob::Bytes))
    {
        q->setTotalAmount(KJob::Bytes, size);
    }
}

void SimpleJobPrivate::slotProcessedSize( KIO::filesize_t size )
{
    Q_Q(SimpleJob);
    //kDebug(7007) << KIO::number(size);
    q->setProcessedAmount(KJob::Bytes, size);
}

void SimpleJobPrivate::slotSpeed( unsigned long speed )
{
    //kDebug(7007) << speed;
    q_func()->emitSpeed( speed );
}

void SimpleJob::slotMetaData( const KIO::MetaData &_metaData )
{
    Q_D(SimpleJob);
    d->m_incomingMetaData += _metaData;
}

void SimpleJob::storeSSLSessionFromJob(const KUrl &redirectionURL)
{
    Q_D(SimpleJob);
    QString sslSession = queryMetaData("ssl_session_id");

    if ( !sslSession.isNull() ) {
        const KUrl &queryURL = redirectionURL.isEmpty() ? d->m_url : redirectionURL;
        KSSLCSessionCache::putSessionForUrl(queryURL, sslSession);
    }
}

class KIO::MkdirJobPrivate: public SimpleJobPrivate
{
public:
    MkdirJobPrivate(const KUrl& url, int command, const QByteArray &packedArgs)
        : SimpleJobPrivate(url, command, packedArgs)
        { }
    KUrl m_redirectionURL;
    void slotRedirection(const KUrl &url);

    virtual void start( Slave *slave );

    Q_DECLARE_PUBLIC(MkdirJob)

    static inline MkdirJob *newJob(const KUrl& url, int command, const QByteArray &packedArgs)
    {
        MkdirJob *job = new MkdirJob(*new MkdirJobPrivate(url, command, packedArgs));
        job->setUiDelegate(new JobUiDelegate);
        return job;
    }
};

MkdirJob::MkdirJob(MkdirJobPrivate &dd)
    : SimpleJob(dd)
{
}

MkdirJob::~MkdirJob()
{
}

void MkdirJobPrivate::start(Slave *slave)
{
    Q_Q(MkdirJob);
    q->connect( slave, SIGNAL( redirection(const KUrl &) ),
                SLOT( slotRedirection(const KUrl &) ) );

    SimpleJobPrivate::start(slave);
}

// Slave got a redirection request
void MkdirJobPrivate::slotRedirection( const KUrl &url)
{
     Q_Q(MkdirJob);
     kDebug(7007) << url;
     if (!KAuthorized::authorizeUrlAction("redirect", m_url, url))
     {
         kWarning(7007) << "Redirection from" << m_url << "to" << url << "REJECTED!";
         q->setError( ERR_ACCESS_DENIED );
         q->setErrorText( url.prettyUrl() );
         return;
     }
     m_redirectionURL = url; // We'll remember that when the job finishes
     if (m_url.hasUser() && !url.hasUser() && (m_url.host().toLower() == url.host().toLower()))
         m_redirectionURL.setUser(m_url.user()); // Preserve user
     // Tell the user that we haven't finished yet
     emit q->redirection(q, m_redirectionURL);
}

void MkdirJob::slotFinished()
{
    Q_D(MkdirJob);
    if ( d->m_redirectionURL.isEmpty() || !d->m_redirectionURL.isValid())
    {
        // Return slave to the scheduler
        SimpleJob::slotFinished();
    } else {
        //kDebug(7007) << "MkdirJob: Redirection to " << m_redirectionURL;
        if (queryMetaData("permanent-redirect")=="true")
            emit permanentRedirection(this, d->m_url, d->m_redirectionURL);
        KUrl dummyUrl;
        int permissions;
        QDataStream istream( d->m_packedArgs );
        istream >> dummyUrl >> permissions;

        d->m_url = d->m_redirectionURL;
        d->m_redirectionURL = KUrl();
        d->m_packedArgs.truncate(0);
        QDataStream stream( &d->m_packedArgs, QIODevice::WriteOnly );
        stream << d->m_url << permissions;

        // Return slave to the scheduler
        d->slaveDone();
        Scheduler::doJob(this);
    }
}

SimpleJob *KIO::mkdir( const KUrl& url, int permissions )
{
    //kDebug(7007) << "mkdir " << url;
    KIO_ARGS << url << permissions;
    return MkdirJobPrivate::newJob(url, CMD_MKDIR, packedArgs);
}

SimpleJob *KIO::rmdir( const KUrl& url )
{
    //kDebug(7007) << "rmdir " << url;
    KIO_ARGS << url << qint8(false); // isFile is false
    return SimpleJobPrivate::newJob(url, CMD_DEL, packedArgs);
}

SimpleJob *KIO::chmod( const KUrl& url, int permissions )
{
    //kDebug(7007) << "chmod " << url;
    KIO_ARGS << url << permissions;
    return SimpleJobPrivate::newJob(url, CMD_CHMOD, packedArgs);
}

SimpleJob *KIO::chown( const KUrl& url, const QString& owner, const QString& group )
{
    KIO_ARGS << url << owner << group;
    return SimpleJobPrivate::newJob(url, CMD_CHOWN, packedArgs);
}

SimpleJob *KIO::setModificationTime( const KUrl& url, const QDateTime& mtime )
{
    //kDebug(7007) << "setModificationTime " << url << " " << mtime;
    KIO_ARGS << url << mtime;
    return SimpleJobPrivate::newJobNoUi(url, CMD_SETMODIFICATIONTIME, packedArgs);
}

SimpleJob *KIO::rename( const KUrl& src, const KUrl & dest, JobFlags flags )
{
    //kDebug(7007) << "rename " << src << " " << dest;
    KIO_ARGS << src << dest << (qint8) (flags & Overwrite);
    return SimpleJobPrivate::newJob(src, CMD_RENAME, packedArgs);
}

SimpleJob *KIO::symlink( const QString& target, const KUrl & dest, JobFlags flags )
{
    //kDebug(7007) << "symlink target=" << target << " " << dest;
    KIO_ARGS << target << dest << (qint8) (flags & Overwrite);
    return SimpleJobPrivate::newJob(dest, CMD_SYMLINK, packedArgs, flags);
}

SimpleJob *KIO::special(const KUrl& url, const QByteArray & data, JobFlags flags)
{
    //kDebug(7007) << "special " << url;
    return SimpleJobPrivate::newJob(url, CMD_SPECIAL, data, flags);
}

SimpleJob *KIO::mount( bool ro, const QByteArray& fstype, const QString& dev, const QString& point, JobFlags flags )
{
    KIO_ARGS << int(1) << qint8( ro ? 1 : 0 )
             << QString::fromLatin1(fstype) << dev << point;
    SimpleJob *job = special( KUrl("file:/"), packedArgs, flags );
    if (!(flags & HideProgressInfo)) {
        KIO::JobPrivate::emitMounting(job, dev, point);
    }
    return job;
}

SimpleJob *KIO::unmount( const QString& point, JobFlags flags )
{
    KIO_ARGS << int(2) << point;
    SimpleJob *job = special( KUrl("file:/"), packedArgs, flags );
    if (!(flags & HideProgressInfo)) {
        KIO::JobPrivate::emitUnmounting(job, point);
    }
    return job;
}




class KIO::StatJobPrivate: public SimpleJobPrivate
{
public:
    inline StatJobPrivate(const KUrl& url, int command, const QByteArray &packedArgs)
        : SimpleJobPrivate(url, command, packedArgs), m_bSource(true), m_details(2)
        {}

    UDSEntry m_statResult;
    KUrl m_redirectionURL;
    bool m_bSource;
    short int m_details;
    void slotStatEntry( const KIO::UDSEntry & entry );
    void slotRedirection( const KUrl &url);

    virtual void start( Slave *slave );

    Q_DECLARE_PUBLIC(StatJob)

    static inline StatJob *newJob(const KUrl& url, int command, const QByteArray &packedArgs,
        JobFlags flags )
    {
        StatJob *job = new StatJob(*new StatJobPrivate(url, command, packedArgs));
        job->setUiDelegate(new JobUiDelegate);
        if (!(flags & HideProgressInfo)) {
            KIO::getJobTracker()->registerJob(job);
            emitStating(job, url);
        }
        return job;
    }
};

StatJob::StatJob(StatJobPrivate &dd)
    : SimpleJob(dd)
{
}

StatJob::~StatJob()
{
}

void StatJob::setSide( bool source )
{
    d_func()->m_bSource = source;
}

void StatJob::setSide( StatSide side )
{
    d_func()->m_bSource = side == SourceSide;
}

void StatJob::setDetails( short int details )
{
    d_func()->m_details = details;
}

const UDSEntry & StatJob::statResult() const
{
    return d_func()->m_statResult;
}

void StatJobPrivate::start(Slave *slave)
{
    Q_Q(StatJob);
    m_outgoingMetaData.insert( "statSide", m_bSource ? "source" : "dest" );
    m_outgoingMetaData.insert( "details", QString::number(m_details) );

    q->connect( slave, SIGNAL( statEntry( const KIO::UDSEntry& ) ),
             SLOT( slotStatEntry( const KIO::UDSEntry & ) ) );
    q->connect( slave, SIGNAL( redirection(const KUrl &) ),
             SLOT( slotRedirection(const KUrl &) ) );

    SimpleJobPrivate::start(slave);
}

void StatJobPrivate::slotStatEntry( const KIO::UDSEntry & entry )
{
    //kDebug(7007);
    m_statResult = entry;
}

// Slave got a redirection request
void StatJobPrivate::slotRedirection( const KUrl &url)
{
     Q_Q(StatJob);
     kDebug(7007) << url;
     if (!KAuthorized::authorizeUrlAction("redirect", m_url, url))
     {
       kWarning(7007) << "Redirection from " << m_url << " to " << url << " REJECTED!";
       q->setError( ERR_ACCESS_DENIED );
       q->setErrorText( url.prettyUrl() );
       return;
     }
     m_redirectionURL = url; // We'll remember that when the job finishes
     if (m_url.hasUser() && !url.hasUser() && (m_url.host().toLower() == url.host().toLower()))
        m_redirectionURL.setUser(m_url.user()); // Preserve user
     // Tell the user that we haven't finished yet
     emit q->redirection(q, m_redirectionURL);
}

void StatJob::slotFinished()
{
    Q_D(StatJob);
    if ( d->m_redirectionURL.isEmpty() || !d->m_redirectionURL.isValid())
    {
        // Return slave to the scheduler
        SimpleJob::slotFinished();
    } else {
        //kDebug(7007) << "StatJob: Redirection to " << m_redirectionURL;
        if (queryMetaData("permanent-redirect")=="true")
            emit permanentRedirection(this, d->m_url, d->m_redirectionURL);
        d->m_url = d->m_redirectionURL;
        d->m_redirectionURL = KUrl();
        d->m_packedArgs.truncate(0);
        QDataStream stream( &d->m_packedArgs, QIODevice::WriteOnly );
        stream << d->m_url;

        // Return slave to the scheduler
        d->slaveDone();
        Scheduler::doJob(this);
    }
}

void StatJob::slotMetaData( const KIO::MetaData &_metaData)
{
    Q_D(StatJob);
    SimpleJob::slotMetaData(_metaData);
    storeSSLSessionFromJob(d->m_redirectionURL);
}

StatJob *KIO::stat(const KUrl& url, JobFlags flags)
{
    // Assume sideIsSource. Gets are more common than puts.
    return stat( url, StatJob::SourceSide, 2, flags );
}

StatJob *KIO::stat(const KUrl& url, bool sideIsSource, short int details, JobFlags flags )
{
    //kDebug(7007) << "stat" << url;
    KIO_ARGS << url;
    StatJob * job = StatJobPrivate::newJob(url, CMD_STAT, packedArgs, flags);
    job->setSide( sideIsSource ? StatJob::SourceSide : StatJob::DestinationSide );
    job->setDetails( details );
    return job;
}

StatJob *KIO::stat(const KUrl& url, KIO::StatJob::StatSide side, short int details, JobFlags flags )
{
    //kDebug(7007) << "stat" << url;
    KIO_ARGS << url;
    StatJob * job = StatJobPrivate::newJob(url, CMD_STAT, packedArgs, flags);
    job->setSide( side );
    job->setDetails( details );
    return job;
}

SimpleJob *KIO::http_update_cache( const KUrl& url, bool no_cache, time_t expireDate)
{
    assert( (url.protocol() == "http") || (url.protocol() == "https") );
    // Send http update_cache command (2)
    KIO_ARGS << (int)2 << url << no_cache << qlonglong(expireDate);
    SimpleJob * job = SimpleJobPrivate::newJob(url, CMD_SPECIAL, packedArgs);
    job->