00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "forwardingslavebase.h"
00021
00022 #include "deletejob.h"
00023 #include "job.h"
00024
00025 #include <kdebug.h>
00026 #include <kmimetype.h>
00027 #include <kprotocolinfo.h>
00028
00029 #include <QtGui/QApplication>
00030 #include <QtCore/QEventLoop>
00031
00032 namespace KIO
00033 {
00034
00035 class ForwardingSlaveBasePrivate
00036 {
00037 public:
00038 ForwardingSlaveBasePrivate(QObject * eventLoopParent) :
00039 eventLoop(eventLoopParent)
00040 {}
00041 ForwardingSlaveBase *q;
00042
00043 KUrl m_processedURL;
00044 KUrl m_requestedURL;
00045 QEventLoop eventLoop;
00046
00047 bool internalRewriteUrl(const KUrl &url, KUrl &newURL);
00048
00049 void connectJob(Job *job);
00050 void connectSimpleJob(SimpleJob *job);
00051 void connectListJob(ListJob *job);
00052 void connectTransferJob(TransferJob *job);
00053
00054 void _k_slotResult(KJob *job);
00055 void _k_slotWarning(KJob *job, const QString &msg);
00056 void _k_slotInfoMessage(KJob *job, const QString &msg);
00057 void _k_slotTotalSize(KJob *job, qulonglong size);
00058 void _k_slotProcessedSize(KJob *job, qulonglong size);
00059 void _k_slotSpeed(KJob *job, unsigned long bytesPerSecond);
00060
00061
00062 void _k_slotRedirection(KIO::Job *job, const KUrl &url);
00063
00064
00065 void _k_slotEntries(KIO::Job *job, const KIO::UDSEntryList &entries);
00066
00067
00068 void _k_slotData(KIO::Job *job, const QByteArray &data);
00069 void _k_slotDataReq(KIO::Job *job, QByteArray &data);
00070 void _k_slotMimetype (KIO::Job *job, const QString &type);
00071 void _k_slotCanResume (KIO::Job *job, KIO::filesize_t offset);
00072 };
00073
00074 ForwardingSlaveBase::ForwardingSlaveBase(const QByteArray &protocol,
00075 const QByteArray &poolSocket,
00076 const QByteArray &appSocket)
00077 : QObject(), SlaveBase(protocol, poolSocket, appSocket),
00078 d( new ForwardingSlaveBasePrivate(this) )
00079 {
00080 d->q = this;
00081 }
00082
00083 ForwardingSlaveBase::~ForwardingSlaveBase()
00084 {
00085 delete d;
00086 }
00087
00088 bool ForwardingSlaveBasePrivate::internalRewriteUrl(const KUrl &url, KUrl &newURL)
00089 {
00090 bool result = true;
00091
00092 if ( url.protocol() == q->mProtocol )
00093 {
00094 result = q->rewriteUrl(url, newURL);
00095 }
00096 else
00097 {
00098 newURL = url;
00099 }
00100
00101 m_processedURL = newURL;
00102 m_requestedURL = url;
00103 return result;
00104 }
00105
00106 void ForwardingSlaveBase::prepareUDSEntry(KIO::UDSEntry &entry,
00107 bool listing) const
00108 {
00109
00110
00111 const QString name = entry.stringValue( KIO::UDSEntry::UDS_NAME );
00112 QString mimetype = entry.stringValue( KIO::UDSEntry::UDS_MIME_TYPE );
00113 KUrl url;
00114 const QString urlStr = entry.stringValue( KIO::UDSEntry::UDS_URL );
00115 const bool url_found = !urlStr.isEmpty();
00116 if ( url_found )
00117 {
00118 url = urlStr;
00119 KUrl new_url = d->m_requestedURL;
00120 if (listing)
00121 new_url.addPath(url.fileName());
00122
00123 entry.insert( KIO::UDSEntry::UDS_URL, new_url.url() );
00124 kDebug() << "URL =" << url;
00125 kDebug() << "New URL =" << urlStr;
00126 }
00127
00128 if (mimetype.isEmpty())
00129 {
00130 KUrl new_url = d->m_processedURL;
00131 if (url_found && listing)
00132 {
00133 new_url.addPath( url.fileName() );
00134 }
00135 else if (listing)
00136 {
00137 new_url.addPath( name );
00138 }
00139
00140 mimetype = KMimeType::findByUrl(new_url)->name();
00141
00142 entry.insert( KIO::UDSEntry::UDS_MIME_TYPE, mimetype );
00143
00144 kDebug() << "New Mimetype = " << mimetype;
00145 }
00146
00147 if ( d->m_processedURL.isLocalFile() )
00148 {
00149 KUrl new_url = d->m_processedURL;
00150 if (listing)
00151 {
00152 new_url.addPath( name );
00153 }
00154
00155 entry.insert( KIO::UDSEntry::UDS_LOCAL_PATH, new_url.path() );
00156 }
00157 }
00158
00159 KUrl ForwardingSlaveBase::processedUrl() const
00160 {
00161 return d->m_processedURL;
00162 }
00163
00164 KUrl ForwardingSlaveBase::requestedUrl() const
00165 {
00166 return d->m_requestedURL;
00167 }
00168
00169 void ForwardingSlaveBase::get(const KUrl &url)
00170 {
00171 kDebug() << url;
00172
00173 KUrl new_url;
00174 if ( d->internalRewriteUrl(url, new_url) )
00175 {
00176 KIO::TransferJob *job = KIO::get(new_url, NoReload, HideProgressInfo);
00177 d->connectTransferJob(job);
00178
00179 d->eventLoop.exec();
00180 }
00181 }
00182
00183 void ForwardingSlaveBase::put(const KUrl &url, int permissions,
00184 JobFlags flags)
00185 {
00186 kDebug() << url;
00187
00188 KUrl new_url;
00189 if ( d->internalRewriteUrl(url, new_url) )
00190 {
00191 KIO::TransferJob *job = KIO::put(new_url, permissions,
00192 flags | HideProgressInfo);
00193 d->connectTransferJob(job);
00194
00195 d->eventLoop.exec();
00196 }
00197 }
00198
00199 void ForwardingSlaveBase::stat(const KUrl &url)
00200 {
00201 kDebug() << url;
00202
00203 KUrl new_url;
00204 if ( d->internalRewriteUrl(url, new_url) )
00205 {
00206 KIO::SimpleJob *job = KIO::stat(new_url, KIO::HideProgressInfo);
00207 d->connectSimpleJob(job);
00208
00209 d->eventLoop.exec();
00210 }
00211 }
00212
00213 void ForwardingSlaveBase::mimetype(const KUrl &url)
00214 {
00215 kDebug() << url;
00216
00217 KUrl new_url;
00218 if ( d->internalRewriteUrl(url, new_url) )
00219 {
00220 KIO::TransferJob *job = KIO::mimetype(new_url, KIO::HideProgressInfo);
00221 d->connectTransferJob(job);
00222
00223 d->eventLoop.exec();
00224 }
00225 }
00226
00227 void ForwardingSlaveBase::listDir(const KUrl &url)
00228 {
00229 kDebug() << url;
00230
00231 KUrl new_url;
00232 if ( d->internalRewriteUrl(url, new_url) )
00233 {
00234 KIO::ListJob *job = KIO::listDir(new_url, KIO::HideProgressInfo);
00235 d->connectListJob(job);
00236
00237 d->eventLoop.exec();
00238 }
00239 }
00240
00241 void ForwardingSlaveBase::mkdir(const KUrl &url, int permissions)
00242 {
00243 kDebug() << url;
00244
00245 KUrl new_url;
00246 if ( d->internalRewriteUrl(url, new_url) )
00247 {
00248 KIO::SimpleJob *job = KIO::mkdir(new_url, permissions);
00249 d->connectSimpleJob(job);
00250
00251 d->eventLoop.exec();
00252 }
00253 }
00254
00255 void ForwardingSlaveBase::rename(const KUrl &src, const KUrl &dest,
00256 JobFlags flags)
00257 {
00258 kDebug() << src << "," << dest;
00259
00260 KUrl new_src, new_dest;
00261 if ( d->internalRewriteUrl(src, new_src) && d->internalRewriteUrl(dest, new_dest) )
00262 {
00263 KIO::Job *job = KIO::rename(new_src, new_dest, flags);
00264 d->connectJob(job);
00265
00266 d->eventLoop.exec();
00267 }
00268 }
00269
00270 void ForwardingSlaveBase::symlink(const QString &target, const KUrl &dest,
00271 JobFlags flags)
00272 {
00273 kDebug() << target << ", " << dest;
00274
00275 KUrl new_dest;
00276 if ( d->internalRewriteUrl(dest, new_dest) )
00277 {
00278 KIO::SimpleJob *job = KIO::symlink(target, new_dest, flags & HideProgressInfo);
00279 d->connectSimpleJob(job);
00280
00281 d->eventLoop.exec();
00282 }
00283 }
00284
00285 void ForwardingSlaveBase::chmod(const KUrl &url, int permissions)
00286 {
00287 kDebug() << url;
00288
00289 KUrl new_url;
00290 if ( d->internalRewriteUrl(url, new_url) )
00291 {
00292 KIO::SimpleJob *job = KIO::chmod(new_url, permissions);
00293 d->connectSimpleJob(job);
00294
00295 d->eventLoop.exec();
00296 }
00297 }
00298
00299 void ForwardingSlaveBase::setModificationTime(const KUrl& url, const QDateTime& mtime)
00300 {
00301 kDebug() << url;
00302
00303 KUrl new_url;
00304 if ( d->internalRewriteUrl(url, new_url) )
00305 {
00306 KIO::SimpleJob *job = KIO::setModificationTime(new_url, mtime);
00307 d->connectSimpleJob(job);
00308
00309 d->eventLoop.exec();
00310 }
00311 }
00312
00313 void ForwardingSlaveBase::copy(const KUrl &src, const KUrl &dest,
00314 int permissions, JobFlags flags)
00315 {
00316 kDebug() << src << "," << dest;
00317
00318 KUrl new_src, new_dest;
00319 if ( d->internalRewriteUrl(src, new_src) && d->internalRewriteUrl(dest, new_dest) )
00320 {
00321
00322 KIO::Job *job = KIO::file_copy(new_src, new_dest, permissions,
00323 (flags & (~Overwrite) & (~HideProgressInfo)) );
00324 d->connectJob(job);
00325
00326 d->eventLoop.exec();
00327 }
00328 }
00329
00330 void ForwardingSlaveBase::del(const KUrl &url, bool isfile)
00331 {
00332 kDebug() << url;
00333
00334 KUrl new_url;
00335 if ( d->internalRewriteUrl(url, new_url) )
00336 {
00337 if (isfile)
00338 {
00339 KIO::DeleteJob *job = KIO::del(new_url, HideProgressInfo);
00340 d->connectJob(job);
00341 }
00342 else
00343 {
00344 KIO::SimpleJob *job = KIO::rmdir(new_url);
00345 d->connectSimpleJob(job);
00346 }
00347
00348 d->eventLoop.exec();
00349 }
00350 }
00351
00352
00354
00355 void ForwardingSlaveBasePrivate::connectJob(KIO::Job *job)
00356 {
00357
00358
00359 job->setUiDelegate( 0 );
00360
00361
00362 job->setMetaData( q->allMetaData() );
00363 #if 0 // debug code
00364 kDebug() << "transferring metadata:";
00365 const MetaData md = allMetaData();
00366 for ( MetaData::const_iterator it = md.begin(); it != md.end(); ++it )
00367 kDebug() << it.key() << " = " << it.data();
00368 #endif
00369
00370 q->connect( job, SIGNAL( result(KJob *) ),
00371 SLOT( _k_slotResult(KJob *) ) );
00372 q->connect( job, SIGNAL( warning(KJob *, const QString &, const QString &) ),
00373 SLOT( _k_slotWarning(KJob *, const QString &) ) );
00374 q->connect( job, SIGNAL( infoMessage(KJob *, const QString &, const QString &) ),
00375 SLOT( _k_slotInfoMessage(KJob *, const QString &) ) );
00376 q->connect( job, SIGNAL( totalSize(KJob *, qulonglong) ),
00377 SLOT( _k_slotTotalSize(KJob *, qulonglong) ) );
00378 q->connect( job, SIGNAL( processedSize(KJob *, qulonglong) ),
00379 SLOT( _k_slotProcessedSize(KJob *, qulonglong) ) );
00380 q->connect( job, SIGNAL( speed(KJob *, unsigned long) ),
00381 SLOT( _k_slotSpeed(KJob *, unsigned long) ) );
00382 }
00383
00384 void ForwardingSlaveBasePrivate::connectSimpleJob(KIO::SimpleJob *job)
00385 {
00386 connectJob(job);
00387 q->connect( job, SIGNAL( redirection(KIO::Job *, const KUrl &) ),
00388 SLOT( _k_slotRedirection(KIO::Job *, const KUrl &) ) );
00389 }
00390
00391 void ForwardingSlaveBasePrivate::connectListJob(KIO::ListJob *job)
00392 {
00393 connectSimpleJob(job);
00394 q->connect( job, SIGNAL( entries(KIO::Job *, const KIO::UDSEntryList &) ),
00395 SLOT( _k_slotEntries(KIO::Job *, const KIO::UDSEntryList &) ) );
00396 }
00397
00398 void ForwardingSlaveBasePrivate::connectTransferJob(KIO::TransferJob *job)
00399 {
00400 connectSimpleJob(job);
00401 q->connect( job, SIGNAL( data(KIO::Job *, const QByteArray &) ),
00402 SLOT( _k_slotData(KIO::Job *, const QByteArray &) ) );
00403 q->connect( job, SIGNAL( dataReq(KIO::Job *, QByteArray &) ),
00404 SLOT( _k_slotDataReq(KIO::Job *, QByteArray &) ) );
00405 q->connect( job, SIGNAL( mimetype(KIO::Job *, const QString &) ),
00406 SLOT( _k_slotMimetype(KIO::Job *, const QString &) ) );
00407 q->connect( job, SIGNAL( canResume(KIO::Job *, KIO::filesize_t) ),
00408 SLOT( _k_slotCanResume(KIO::Job *, KIO::filesize_t) ) );
00409 }
00410
00412
00413 void ForwardingSlaveBasePrivate::_k_slotResult(KJob *job)
00414 {
00415 if ( job->error() != 0)
00416 {
00417 q->error( job->error(), job->errorText() );
00418 }
00419 else
00420 {
00421 KIO::StatJob *stat_job = qobject_cast<KIO::StatJob *>(job);
00422 if ( stat_job!=0L )
00423 {
00424 KIO::UDSEntry entry = stat_job->statResult();
00425 q->prepareUDSEntry(entry);
00426 q->statEntry( entry );
00427 }
00428 q->finished();
00429 }
00430
00431 eventLoop.exit();
00432 }
00433
00434 void ForwardingSlaveBasePrivate::_k_slotWarning(KJob* , const QString &msg)
00435 {
00436 q->warning(msg);
00437 }
00438
00439 void ForwardingSlaveBasePrivate::_k_slotInfoMessage(KJob* , const QString &msg)
00440 {
00441 q->infoMessage(msg);
00442 }
00443
00444 void ForwardingSlaveBasePrivate::_k_slotTotalSize(KJob* , qulonglong size)
00445 {
00446 q->totalSize(size);
00447 }
00448
00449 void ForwardingSlaveBasePrivate::_k_slotProcessedSize(KJob* , qulonglong size)
00450 {
00451 q->processedSize(size);
00452 }
00453
00454 void ForwardingSlaveBasePrivate::_k_slotSpeed(KJob* , unsigned long bytesPerSecond)
00455 {
00456 q->speed(bytesPerSecond);
00457 }
00458
00459 void ForwardingSlaveBasePrivate::_k_slotRedirection(KIO::Job *job, const KUrl &url)
00460 {
00461 q->redirection(url);
00462
00463
00464 job->kill( KJob::Quietly );
00465 q->finished();
00466
00467 eventLoop.exit();
00468 }
00469
00470 void ForwardingSlaveBasePrivate::_k_slotEntries(KIO::Job* ,
00471 const KIO::UDSEntryList &entries)
00472 {
00473 KIO::UDSEntryList final_entries = entries;
00474
00475 KIO::UDSEntryList::iterator it = final_entries.begin();
00476 const KIO::UDSEntryList::iterator end = final_entries.end();
00477
00478 for(; it!=end; ++it)
00479 {
00480 q->prepareUDSEntry(*it, true);
00481 }
00482
00483 q->listEntries( final_entries );
00484 }
00485
00486 void ForwardingSlaveBasePrivate::_k_slotData(KIO::Job* , const QByteArray &_data)
00487 {
00488 q->data(_data);
00489 }
00490
00491 void ForwardingSlaveBasePrivate::_k_slotDataReq(KIO::Job* , QByteArray &data)
00492 {
00493 q->dataReq();
00494 q->readData(data);
00495 }
00496
00497 void ForwardingSlaveBasePrivate::_k_slotMimetype (KIO::Job* , const QString &type)
00498 {
00499 q->mimeType(type);
00500 }
00501
00502 void ForwardingSlaveBasePrivate::_k_slotCanResume (KIO::Job* , KIO::filesize_t offset)
00503 {
00504 q->canResume(offset);
00505 }
00506
00507 }
00508
00509 #include "forwardingslavebase.moc"
00510