00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include <kdebug.h>
00021
#include <kio/job.h>
00022
#include <kmimetype.h>
00023
#include <kprotocolinfo.h>
00024
00025
#include <qapplication.h>
00026
#include <qeventloop.h>
00027
00028
#include "forwardingslavebase.h"
00029
00030
namespace KIO
00031 {
00032
00033
class ForwardingSlaveBasePrivate
00034 {
00035 };
00036
00037 ForwardingSlaveBase::ForwardingSlaveBase(
const QCString &protocol,
00038
const QCString &poolSocket,
00039
const QCString &appSocket)
00040 :
QObject(),
SlaveBase(protocol, poolSocket, appSocket)
00041 {
00042 }
00043
00044 ForwardingSlaveBase::~ForwardingSlaveBase()
00045 {
00046 }
00047
00048
bool ForwardingSlaveBase::internalRewriteURL(
const KURL &url,
KURL &newURL)
00049 {
00050
bool result =
true;
00051
00052
if ( url.
protocol().
ascii()==mProtocol )
00053 {
00054 result = rewriteURL(url, newURL);
00055 }
00056
else
00057 {
00058 newURL = url;
00059 }
00060
00061 m_processedURL = newURL;
00062 m_requestedURL = url;
00063
return result;
00064 }
00065
00066 void ForwardingSlaveBase::prepareUDSEntry(
KIO::UDSEntry &entry,
00067
bool listing)
const
00068
{
00069
kdDebug() <<
"ForwardingSlaveBase::prepareUDSEntry: listing=="
00070 << listing <<
endl;
00071
00072
bool mimetype_found =
false;
00073
bool name_found =
false;
00074
bool url_found =
false;
00075
QString name,
mimetype;
00076
KURL url;
00077
00078 KIO::UDSEntry::iterator it = entry.
begin();
00079 KIO::UDSEntry::iterator end = entry.
end();
00080
00081
for(; it!=end; ++it)
00082 {
00083
KURL new_url = m_processedURL;
00084
00085
switch( (*it).m_uds )
00086 {
00087
case KIO::UDS_NAME:
00088 name_found =
true;
00089 name = (*it).m_str;
00090
kdDebug() <<
"Name = " << name <<
endl;
00091
break;
00092
case KIO::UDS_URL:
00093 url_found =
true;
00094 url = (*it).m_str;
00095
if (listing)
00096 {
00097 new_url.
addPath(url.
fileName());
00098 }
00099 (*it).m_str = new_url.
url();
00100
kdDebug() <<
"URL = " << url <<
endl;
00101
kdDebug() <<
"New URL = " << (*it).m_str <<
endl;
00102
break;
00103
case KIO::UDS_MIME_TYPE:
00104 mimetype_found =
true;
00105
mimetype = (*it).m_str;
00106
kdDebug() <<
"Mimetype = " << (*it).m_str <<
endl;
00107
break;
00108 }
00109 }
00110
00111
if (!mimetype_found)
00112 {
00113
KURL new_url = m_processedURL;
00114
if (url_found && listing)
00115 {
00116 new_url.
addPath( url.
fileName() );
00117 }
00118
else if (name_found && listing)
00119 {
00120 new_url.
addPath( name );
00121 }
00122
00123
KMimeType::Ptr mime = KMimeType::findByURL(new_url);
00124
mimetype = mime->name();
00125
00126 KIO::UDSAtom atom;
00127 atom.m_uds = KIO::UDS_MIME_TYPE;
00128 atom.m_long = 0;
00129 atom.m_str =
mimetype;
00130 entry.
append(atom);
00131
00132
kdDebug() <<
"New Mimetype = " << mime->name() <<
endl;
00133 }
00134
00135
if (
mimetype==
"application/x-desktop" && name_found
00136 && m_processedURL.
isLocalFile() )
00137 {
00138
QString prot_class = KProtocolInfo::protocolClass( mProtocol );
00139
00140
if ( prot_class==
":local" )
00141 {
00142
KURL new_url = m_processedURL;
00143
if (listing)
00144 {
00145 new_url.
addPath( name );
00146 }
00147
00148 KIO::UDSAtom atom;
00149 atom.m_uds = KIO::UDS_URL;
00150 atom.m_long = 0;
00151 atom.m_str = new_url.
url();
00152 entry.
append(atom);
00153 }
00154 }
00155
00156
if ( m_processedURL.
isLocalFile() )
00157 {
00158
KURL new_url = m_processedURL;
00159
if (listing)
00160 {
00161 new_url.
addPath( name );
00162 }
00163
00164 KIO::UDSAtom atom;
00165 atom.m_uds = KIO::UDS_LOCAL_PATH;
00166 atom.m_long = 0;
00167 atom.m_str = new_url.
path();
00168 entry.
append(atom);
00169 }
00170 }
00171
00172 void ForwardingSlaveBase::get(
const KURL &url)
00173 {
00174
kdDebug() <<
"ForwardingSlaveBase::get: " << url <<
endl;
00175
00176
KURL new_url;
00177
if ( internalRewriteURL(url, new_url) )
00178 {
00179
KIO::TransferJob *job =
KIO::get(new_url,
false,
false);
00180 connectTransferJob(job);
00181
00182 qApp->eventLoop()->enterLoop();
00183 }
00184 }
00185
00186 void ForwardingSlaveBase::put(
const KURL &url,
int permissions,
00187
bool overwrite,
bool resume )
00188 {
00189
kdDebug() <<
"ForwardingSlaveBase::put: " << url <<
endl;
00190
00191
KURL new_url;
00192
if ( internalRewriteURL(url, new_url) )
00193 {
00194
KIO::TransferJob *job =
KIO::put(new_url, permissions, overwrite,
00195 resume,
false);
00196 connectTransferJob(job);
00197
00198 qApp->eventLoop()->enterLoop();
00199 }
00200 }
00201
00202 void ForwardingSlaveBase::stat(
const KURL &url)
00203 {
00204
kdDebug() <<
"ForwardingSlaveBase::stat: " << url <<
endl;
00205
00206
KURL new_url;
00207
if ( internalRewriteURL(url, new_url) )
00208 {
00209
KIO::SimpleJob *job =
KIO::stat(new_url,
false);
00210 connectSimpleJob(job);
00211
00212 qApp->eventLoop()->enterLoop();
00213 }
00214 }
00215
00216 void ForwardingSlaveBase::mimetype(
const KURL &url)
00217 {
00218
kdDebug() <<
"ForwardingSlaveBase::mimetype: " << url <<
endl;
00219
00220
KURL new_url;
00221
if ( internalRewriteURL(url, new_url) )
00222 {
00223
KIO::TransferJob *job =
KIO::mimetype(new_url,
false);
00224 connectTransferJob(job);
00225
00226 qApp->eventLoop()->enterLoop();
00227 }
00228 }
00229
00230 void ForwardingSlaveBase::listDir(
const KURL &url)
00231 {
00232
kdDebug() <<
"ForwardingSlaveBase::listDir: " << url <<
endl;
00233
00234
KURL new_url;
00235
if ( internalRewriteURL(url, new_url) )
00236 {
00237
KIO::ListJob *job =
KIO::listDir(new_url,
false);
00238 connectListJob(job);
00239
00240 qApp->eventLoop()->enterLoop();
00241 }
00242 }
00243
00244 void ForwardingSlaveBase::mkdir(
const KURL &url,
int permissions)
00245 {
00246
kdDebug() <<
"ForwardingSlaveBase::mkdir: " << url <<
endl;
00247
00248
KURL new_url;
00249
if ( internalRewriteURL(url, new_url) )
00250 {
00251
KIO::SimpleJob *job =
KIO::mkdir(new_url, permissions);
00252 connectSimpleJob(job);
00253
00254 qApp->eventLoop()->enterLoop();
00255 }
00256 }
00257
00258 void ForwardingSlaveBase::rename(
const KURL &src,
const KURL &dest,
00259
bool overwrite)
00260 {
00261
kdDebug() <<
"ForwardingSlaveBase::rename: " << src <<
", " << dest <<
endl;
00262
00263
KURL new_src, new_dest;
00264
if ( internalRewriteURL(src, new_src) && internalRewriteURL(dest, new_dest) )
00265 {
00266
KIO::Job *job =
KIO::rename(new_src, new_dest, overwrite);
00267 connectJob(job);
00268
00269 qApp->eventLoop()->enterLoop();
00270 }
00271 }
00272
00273 void ForwardingSlaveBase::symlink(
const QString &target,
const KURL &dest,
00274
bool overwrite)
00275 {
00276
kdDebug() <<
"ForwardingSlaveBase::symlink: " << target <<
", " << dest <<
endl;
00277
00278
KURL new_dest;
00279
if ( internalRewriteURL(dest, new_dest) )
00280 {
00281
KIO::SimpleJob *job =
KIO::symlink(target, new_dest, overwrite,
false);
00282 connectSimpleJob(job);
00283
00284 qApp->eventLoop()->enterLoop();
00285 }
00286 }
00287
00288 void ForwardingSlaveBase::chmod(
const KURL &url,
int permissions)
00289 {
00290
kdDebug() <<
"ForwardingSlaveBase::chmod: " << url <<
endl;
00291
00292
KURL new_url;
00293
if ( internalRewriteURL(url, new_url) )
00294 {
00295
KIO::SimpleJob *job =
KIO::chmod(new_url, permissions);
00296 connectSimpleJob(job);
00297
00298 qApp->eventLoop()->enterLoop();
00299 }
00300 }
00301
00302 void ForwardingSlaveBase::copy(
const KURL &src,
const KURL &dest,
00303
int permissions,
bool overwrite)
00304 {
00305
kdDebug() <<
"ForwardingSlaveBase::copy: " << src <<
", " << dest <<
endl;
00306
00307
KURL new_src, new_dest;
00308
if ( internalRewriteURL(src, new_src) && internalRewriteURL(dest, new_dest) )
00309 {
00310
KIO::Job *job =
KIO::file_copy(new_src, new_dest, permissions,
00311 overwrite,
false);
00312 connectJob(job);
00313
00314 qApp->eventLoop()->enterLoop();
00315 }
00316 }
00317
00318 void ForwardingSlaveBase::del(
const KURL &url,
bool isfile)
00319 {
00320
kdDebug() <<
"ForwardingSlaveBase::del: " << url <<
endl;
00321
00322
KURL new_url;
00323
if ( internalRewriteURL(url, new_url) )
00324 {
00325
if (isfile)
00326 {
00327
KIO::DeleteJob *job =
KIO::del(new_url,
false,
false);
00328 connectJob(job);
00329 }
00330
else
00331 {
00332
KIO::SimpleJob *job =
KIO::rmdir(new_url);
00333 connectSimpleJob(job);
00334 }
00335
00336 qApp->eventLoop()->enterLoop();
00337 }
00338 }
00339
00340
00342
00343
void ForwardingSlaveBase::connectJob(
KIO::Job *job)
00344 {
00345 connect( job, SIGNAL( result(
KIO::Job *) ),
00346
this, SLOT( slotResult(
KIO::Job *) ) );
00347 connect( job, SIGNAL( infoMessage(
KIO::Job *,
const QString &) ),
00348
this, SLOT( slotInfoMessage(
KIO::Job *,
const QString &) ) );
00349 connect( job, SIGNAL( totalSize(
KIO::Job *,
KIO::filesize_t) ),
00350
this, SLOT( slotTotalSize(
KIO::Job *, KIO::filesize_t) ) );
00351 connect( job, SIGNAL( processedSize(
KIO::Job *, KIO::filesize_t) ),
00352
this, SLOT( slotProcessedSize(
KIO::Job *, KIO::filesize_t) ) );
00353 connect( job, SIGNAL( speed(
KIO::Job *,
unsigned long) ),
00354
this, SLOT( slotSpeed(
KIO::Job *,
unsigned long) ) );
00355 }
00356
00357
void ForwardingSlaveBase::connectSimpleJob(
KIO::SimpleJob *job)
00358 {
00359 connectJob(job);
00360 connect( job, SIGNAL( redirection(
KIO::Job *,
const KURL &) ),
00361
this, SLOT( slotRedirection(
KIO::Job *,
const KURL &) ) );
00362 }
00363
00364
void ForwardingSlaveBase::connectListJob(
KIO::ListJob *job)
00365 {
00366 connectSimpleJob(job);
00367
connect( job, SIGNAL( entries(
KIO::Job *,
const KIO::UDSEntryList &) ),
00368
this, SLOT( slotEntries(
KIO::Job *,
const KIO::UDSEntryList &) ) );
00369 }
00370
00371
void ForwardingSlaveBase::connectTransferJob(
KIO::TransferJob *job)
00372 {
00373 connectSimpleJob(job);
00374
connect( job, SIGNAL(
data(
KIO::Job *,
const QByteArray &) ),
00375
this, SLOT( slotData(
KIO::Job *,
const QByteArray &) ) );
00376
connect( job, SIGNAL(
dataReq(
KIO::Job *,
QByteArray &) ),
00377
this, SLOT( slotDataReq(
KIO::Job *,
QByteArray &) ) );
00378
connect( job, SIGNAL(
mimetype(
KIO::Job *,
const QString &) ),
00379
this, SLOT( slotMimetype(
KIO::Job *,
const QString &) ) );
00380
connect( job, SIGNAL(
canResume(
KIO::Job *, KIO::filesize_t) ),
00381
this, SLOT( slotCanResume(
KIO::Job *, KIO::filesize_t) ) );
00382 }
00383
00385
00386
void ForwardingSlaveBase::slotResult(
KIO::Job *job)
00387 {
00388
if ( job->
error() != 0)
00389 {
00390
error( job->
error(), job->
errorText() );
00391 }
00392
else
00393 {
00394
KIO::StatJob *stat_job = dynamic_cast<KIO::StatJob *>(job);
00395
if ( stat_job!=0L )
00396 {
00397
KIO::UDSEntry entry = stat_job->
statResult();
00398
prepareUDSEntry(entry);
00399
statEntry( entry );
00400 }
00401
finished();
00402 }
00403
00404 qApp->eventLoop()->exitLoop();
00405 }
00406
00407
void ForwardingSlaveBase::slotInfoMessage(
KIO::Job* ,
const QString &msg)
00408 {
00409
infoMessage(msg);
00410 }
00411
00412
void ForwardingSlaveBase::slotTotalSize(
KIO::Job* , KIO::filesize_t size)
00413 {
00414
totalSize(size);
00415 }
00416
00417
void ForwardingSlaveBase::slotProcessedSize(
KIO::Job* , KIO::filesize_t size)
00418 {
00419
processedSize(size);
00420 }
00421
00422
void ForwardingSlaveBase::slotSpeed(
KIO::Job* ,
unsigned long bytesPerSecond)
00423 {
00424
speed(bytesPerSecond);
00425 }
00426
00427
void ForwardingSlaveBase::slotRedirection(
KIO::Job* ,
const KURL &url)
00428 {
00429
redirection(url);
00430 }
00431
00432
void ForwardingSlaveBase::slotEntries(
KIO::Job* ,
00433
const KIO::UDSEntryList &entries)
00434 {
00435
KIO::UDSEntryList final_entries = entries;
00436
00437 KIO::UDSEntryList::iterator it = final_entries.
begin();
00438 KIO::UDSEntryList::iterator
end = final_entries.
end();
00439
00440
for(; it!=
end; ++it)
00441 {
00442
prepareUDSEntry(*it,
true);
00443 }
00444
00445
listEntries( final_entries );
00446 }
00447
00448
void ForwardingSlaveBase::slotData(
KIO::Job* ,
const QByteArray &d)
00449 {
00450
data(d);
00451 }
00452
00453
void ForwardingSlaveBase::slotDataReq(
KIO::Job* ,
QByteArray &data)
00454 {
00455
dataReq();
00456
readData(data);
00457 }
00458
00459
void ForwardingSlaveBase::slotMimetype (
KIO::Job* ,
const QString &type)
00460 {
00461
mimeType(type);
00462 }
00463
00464
void ForwardingSlaveBase::slotCanResume (
KIO::Job* , KIO::filesize_t offset)
00465 {
00466
canResume(offset);
00467 }
00468
00469 }
00470
00471
#include "forwardingslavebase.moc"
00472