00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <stdlib.h>
00025 #include <stdio.h>
00026 #include <signal.h>
00027 #include <unistd.h>
00028
00029 #include <qstring.h>
00030 #include <qapplication.h>
00031 #include <qfile.h>
00032
00033 #include <kapplication.h>
00034 #include <klocale.h>
00035 #include <ktempfile.h>
00036 #include <kdebug.h>
00037 #include <kurl.h>
00038 #include <kio/job.h>
00039 #include <kio/scheduler.h>
00040
00041 #include "kio/netaccess.h"
00042
00043 using namespace KIO;
00044
00045 QString * NetAccess::lastErrorMsg;
00046 QStringList* NetAccess::tmpfiles;
00047
00048 bool NetAccess::download(const KURL& u, QString & target)
00049 {
00050 return NetAccess::download (u, target, 0);
00051 }
00052
00053 bool NetAccess::download(const KURL& u, QString & target, QWidget* window)
00054 {
00055 if (u.isLocalFile()) {
00056
00057 target = u.path();
00058 bool accessible = checkAccess(target, R_OK);
00059 if(!accessible)
00060 {
00061 if(!lastErrorMsg)
00062 lastErrorMsg = new QString;
00063 *lastErrorMsg = i18n("File '%1' is not readable").arg(target);
00064 }
00065 return accessible;
00066 }
00067
00068 if (target.isEmpty())
00069 {
00070 KTempFile tmpFile;
00071 target = tmpFile.name();
00072 if (!tmpfiles)
00073 tmpfiles = new QStringList;
00074 tmpfiles->append(target);
00075 }
00076
00077 NetAccess kioNet;
00078 KURL dest;
00079 dest.setPath( target );
00080 return kioNet.filecopyInternal( u, dest, -1, true ,
00081 false, window, false );
00082 }
00083
00084 bool NetAccess::upload(const QString& src, const KURL& target)
00085 {
00086 return NetAccess::upload(src, target, 0);
00087 }
00088
00089 bool NetAccess::upload(const QString& src, const KURL& target, QWidget* window)
00090 {
00091 if (target.isEmpty())
00092 return false;
00093
00094
00095
00096
00097 if (target.isLocalFile() && target.path() == src)
00098 return true;
00099
00100 NetAccess kioNet;
00101 KURL s;
00102 s.setPath(src);
00103 return kioNet.filecopyInternal( s, target, -1, true ,
00104 false, window, false );
00105 }
00106
00107 bool NetAccess::copy( const KURL & src, const KURL & target )
00108 {
00109 return NetAccess::file_copy( src, target, -1, false , false, 0L );
00110 }
00111
00112 bool NetAccess::copy( const KURL & src, const KURL & target, QWidget* window )
00113 {
00114 return NetAccess::file_copy( src, target, -1, false , false, window );
00115 }
00116
00117 bool NetAccess::file_copy( const KURL& src, const KURL& target, int permissions,
00118 bool overwrite, bool resume, QWidget* window )
00119 {
00120 NetAccess kioNet;
00121 return kioNet.filecopyInternal( src, target, permissions, overwrite, resume,
00122 window, false );
00123 }
00124
00125
00126 bool NetAccess::file_move( const KURL& src, const KURL& target, int permissions,
00127 bool overwrite, bool resume, QWidget* window )
00128 {
00129 NetAccess kioNet;
00130 return kioNet.filecopyInternal( src, target, permissions, overwrite, resume,
00131 window, true );
00132 }
00133
00134 bool NetAccess::dircopy( const KURL & src, const KURL & target )
00135 {
00136 return NetAccess::dircopy( src, target, 0 );
00137 }
00138
00139 bool NetAccess::dircopy( const KURL & src, const KURL & target, QWidget* window )
00140 {
00141 KURL::List srcList;
00142 srcList.append( src );
00143 return NetAccess::dircopy( srcList, target, window );
00144 }
00145
00146 bool NetAccess::dircopy( const KURL::List & srcList, const KURL & target, QWidget* window )
00147 {
00148 NetAccess kioNet;
00149 return kioNet.dircopyInternal( srcList, target, window, false );
00150 }
00151
00152 bool NetAccess::move( const KURL& src, const KURL& target, QWidget* window )
00153 {
00154 KURL::List srcList;
00155 srcList.append( src );
00156 return NetAccess::move( srcList, target, window );
00157 }
00158
00159 bool NetAccess::move( const KURL::List& srcList, const KURL& target, QWidget* window )
00160 {
00161 NetAccess kioNet;
00162 return kioNet.dircopyInternal( srcList, target, window, true );
00163 }
00164
00165 bool NetAccess::exists( const KURL & url )
00166 {
00167 return NetAccess::exists( url, false, 0 );
00168 }
00169
00170 bool NetAccess::exists( const KURL & url, QWidget* window )
00171 {
00172 return NetAccess::exists( url, false, window );
00173 }
00174
00175 bool NetAccess::exists( const KURL & url, bool source )
00176 {
00177 return NetAccess::exists( url, source, 0 );
00178 }
00179
00180 bool NetAccess::exists( const KURL & url, bool source, QWidget* window )
00181 {
00182 if ( url.isLocalFile() )
00183 return QFile::exists( url.path() );
00184 NetAccess kioNet;
00185 return kioNet.statInternal( url, 0 , source, window );
00186 }
00187
00188 bool NetAccess::stat( const KURL & url, KIO::UDSEntry & entry )
00189 {
00190 return NetAccess::stat( url, entry, 0 );
00191 }
00192
00193 bool NetAccess::stat( const KURL & url, KIO::UDSEntry & entry, QWidget* window )
00194 {
00195 NetAccess kioNet;
00196 bool ret = kioNet.statInternal( url, 2 , true , window );
00197 if (ret)
00198 entry = kioNet.m_entry;
00199 return ret;
00200 }
00201
00202 bool NetAccess::del( const KURL & url )
00203 {
00204 return NetAccess::del( url, 0 );
00205 }
00206
00207 bool NetAccess::del( const KURL & url, QWidget* window )
00208 {
00209 NetAccess kioNet;
00210 return kioNet.delInternal( url, window );
00211 }
00212
00213 bool NetAccess::mkdir( const KURL & url, int permissions )
00214 {
00215 return NetAccess::mkdir( url, 0, permissions );
00216 }
00217
00218 bool NetAccess::mkdir( const KURL & url, QWidget* window, int permissions )
00219 {
00220 NetAccess kioNet;
00221 return kioNet.mkdirInternal( url, permissions, window );
00222 }
00223
00224 QString NetAccess::fish_execute( const KURL & url, const QString command, QWidget* window )
00225 {
00226 NetAccess kioNet;
00227 return kioNet.fish_executeInternal( url, command, window );
00228 }
00229
00230 QString NetAccess::mimetype( const KURL& url )
00231 {
00232 NetAccess kioNet;
00233 return kioNet.mimetypeInternal( url, 0 );
00234 }
00235
00236 QString NetAccess::mimetype( const KURL& url, QWidget* window )
00237 {
00238 NetAccess kioNet;
00239 return kioNet.mimetypeInternal( url, window );
00240 }
00241
00242 void NetAccess::removeTempFile(const QString& name)
00243 {
00244 if (!tmpfiles)
00245 return;
00246 if (tmpfiles->contains(name))
00247 {
00248 unlink(QFile::encodeName(name));
00249 tmpfiles->remove(name);
00250 }
00251 }
00252
00253 bool NetAccess::filecopyInternal(const KURL& src, const KURL& target, int permissions,
00254 bool overwrite, bool resume, QWidget* window, bool move)
00255 {
00256 bJobOK = true;
00257
00258 KIO::Scheduler::checkSlaveOnHold(true);
00259 KIO::Job * job = move
00260 ? KIO::file_move( src, target, permissions, overwrite, resume )
00261 : KIO::file_copy( src, target, permissions, overwrite, resume );
00262 job->setWindow (window);
00263 connect( job, SIGNAL( result (KIO::Job *) ),
00264 this, SLOT( slotResult (KIO::Job *) ) );
00265
00266 enter_loop();
00267 return bJobOK;
00268 }
00269
00270 bool NetAccess::dircopyInternal(const KURL::List& src, const KURL& target,
00271 QWidget* window, bool move)
00272 {
00273 bJobOK = true;
00274
00275 KIO::Job * job = move
00276 ? KIO::move( src, target )
00277 : KIO::copy( src, target );
00278 job->setWindow (window);
00279 connect( job, SIGNAL( result (KIO::Job *) ),
00280 this, SLOT( slotResult (KIO::Job *) ) );
00281
00282 enter_loop();
00283 return bJobOK;
00284 }
00285
00286 bool NetAccess::statInternal( const KURL & url, int details, bool source,
00287 QWidget* window )
00288 {
00289 bJobOK = true;
00290 KIO::StatJob * job = KIO::stat( url, !url.isLocalFile() );
00291 job->setWindow (window);
00292 job->setDetails( details );
00293 job->setSide( source );
00294 connect( job, SIGNAL( result (KIO::Job *) ),
00295 this, SLOT( slotResult (KIO::Job *) ) );
00296 enter_loop();
00297 return bJobOK;
00298 }
00299
00300 bool NetAccess::delInternal( const KURL & url, QWidget* window )
00301 {
00302 bJobOK = true;
00303 KIO::Job * job = KIO::del( url );
00304 job->setWindow (window);
00305 connect( job, SIGNAL( result (KIO::Job *) ),
00306 this, SLOT( slotResult (KIO::Job *) ) );
00307 enter_loop();
00308 return bJobOK;
00309 }
00310
00311 bool NetAccess::mkdirInternal( const KURL & url, int permissions,
00312 QWidget* window )
00313 {
00314 bJobOK = true;
00315 KIO::Job * job = KIO::mkdir( url, permissions );
00316 job->setWindow (window);
00317 connect( job, SIGNAL( result (KIO::Job *) ),
00318 this, SLOT( slotResult (KIO::Job *) ) );
00319 enter_loop();
00320 return bJobOK;
00321 }
00322
00323 QString NetAccess::mimetypeInternal( const KURL & url, QWidget* window )
00324 {
00325 bJobOK = true;
00326 m_mimetype = QString::fromLatin1("unknown");
00327 KIO::Job * job = KIO::mimetype( url );
00328 job->setWindow (window);
00329 connect( job, SIGNAL( result (KIO::Job *) ),
00330 this, SLOT( slotResult (KIO::Job *) ) );
00331 connect( job, SIGNAL( mimetype (KIO::Job *, const QString &) ),
00332 this, SLOT( slotMimetype (KIO::Job *, const QString &) ) );
00333 enter_loop();
00334 return m_mimetype;
00335 }
00336
00337 void NetAccess::slotMimetype( KIO::Job *, const QString & type )
00338 {
00339 m_mimetype = type;
00340 }
00341
00342 QString NetAccess::fish_executeInternal(const KURL & url, const QString command, QWidget* window)
00343 {
00344 QString target, remoteTempFileName, resultData;
00345 KURL tempPathUrl;
00346 KTempFile tmpFile;
00347 tmpFile.setAutoDelete( true );
00348
00349 if( url.protocol() == "fish" )
00350 {
00351
00352 tempPathUrl = url;
00353 remoteTempFileName = tmpFile.name();
00354
00355
00356 int pos = remoteTempFileName.findRev('/');
00357 remoteTempFileName = "/tmp/fishexec_" + remoteTempFileName.mid(pos + 1);
00358 tempPathUrl.setPath( remoteTempFileName );
00359 bJobOK = true;
00360 QByteArray packedArgs;
00361 QDataStream stream( packedArgs, IO_WriteOnly );
00362
00363 stream << int('X') << tempPathUrl << command;
00364
00365 KIO::Job * job = KIO::special( tempPathUrl, packedArgs, true );
00366 job->setWindow( window );
00367 connect( job, SIGNAL( result (KIO::Job *) ),
00368 this, SLOT( slotResult (KIO::Job *) ) );
00369 enter_loop();
00370
00371
00372 if( NetAccess::download( tempPathUrl, target, window ) )
00373 {
00374 QFile resultFile( target );
00375
00376 if (resultFile.open( IO_ReadOnly ))
00377 {
00378 QTextStream ts( &resultFile );
00379 ts.setEncoding( QTextStream::Locale );
00380 resultData = ts.read();
00381 resultFile.close();
00382 NetAccess::del( tempPathUrl, window );
00383 }
00384 }
00385 }
00386 else
00387 {
00388 resultData = QString( "ERROR: Unknown protocol '%1'" ).arg( url.protocol() );
00389 }
00390 return resultData;
00391 }
00392
00393
00394 void qt_enter_modal( QWidget *widget );
00395 void qt_leave_modal( QWidget *widget );
00396
00397 void NetAccess::enter_loop()
00398 {
00399 QWidget dummy(0,0,WType_Dialog | WShowModal);
00400 dummy.setFocusPolicy( QWidget::NoFocus );
00401 qt_enter_modal(&dummy);
00402 qApp->enter_loop();
00403 qt_leave_modal(&dummy);
00404 }
00405
00406 void NetAccess::slotResult( KIO::Job * job )
00407 {
00408 bJobOK = !job->error();
00409 if ( !bJobOK )
00410 {
00411 if ( !lastErrorMsg )
00412 lastErrorMsg = new QString;
00413 *lastErrorMsg = job->errorString();
00414 }
00415 if ( job->isA("KIO::StatJob") )
00416 m_entry = static_cast<KIO::StatJob *>(job)->statResult();
00417 qApp->exit_loop();
00418 }
00419
00420 #include "netaccess.moc"