kio Library API Documentation

netaccess.cpp

00001 /*  $Id: netaccess.cpp,v 1.48 2004/06/15 13:15:51 waba Exp $
00002 
00003     This file is part of the KDE libraries
00004     Copyright (C) 1997 Torben Weis (weis@kde.org)
00005     Copyright (C) 1998 Matthias Ettrich (ettrich@kde.org)
00006     Copyright (C) 1999 David Faure (faure@kde.org)
00007 
00008     This library is free software; you can redistribute it and/or
00009     modify it under the terms of the GNU Library General Public
00010     License as published by the Free Software Foundation; either
00011     version 2 of the License, or (at your option) any later version.
00012 
00013     This library is distributed in the hope that it will be useful,
00014     but WITHOUT ANY WARRANTY; without even the implied warranty of
00015     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016     Library General Public License for more details.
00017 
00018     You should have received a copy of the GNU Library General Public License
00019     along with this library; see the file COPYING.LIB.  If not, write to
00020     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00021     Boston, MA 02111-1307, USA.
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 int NetAccess::lastErrorCode = 0;
00047 QStringList* NetAccess::tmpfiles;
00048 
00049 bool NetAccess::download(const KURL& u, QString & target)
00050 {
00051   return NetAccess::download (u, target, 0);
00052 }
00053 
00054 bool NetAccess::download(const KURL& u, QString & target, QWidget* window)
00055 {
00056   if (u.isLocalFile()) {
00057     // file protocol. We do not need the network
00058     target = u.path();
00059     bool accessible = checkAccess(target, R_OK);
00060     if(!accessible)
00061     {
00062         if(!lastErrorMsg)
00063             lastErrorMsg = new QString;
00064         *lastErrorMsg = i18n("File '%1' is not readable").arg(target);
00065         lastErrorCode = ERR_COULD_NOT_READ;
00066     }
00067     return accessible;
00068   }
00069 
00070   if (target.isEmpty())
00071   {
00072       KTempFile tmpFile;
00073       target = tmpFile.name();
00074       if (!tmpfiles)
00075           tmpfiles = new QStringList;
00076       tmpfiles->append(target);
00077   }
00078 
00079   NetAccess kioNet;
00080   KURL dest;
00081   dest.setPath( target );
00082   return kioNet.filecopyInternal( u, dest, -1, true /*overwrite*/,
00083                                   false, window, false /*copy*/);
00084 }
00085 
00086 bool NetAccess::upload(const QString& src, const KURL& target)
00087 {
00088   return NetAccess::upload(src, target, 0);
00089 }
00090 
00091 bool NetAccess::upload(const QString& src, const KURL& target, QWidget* window)
00092 {
00093   if (target.isEmpty())
00094     return false;
00095 
00096   // If target is local... well, just copy. This can be useful
00097   // when the client code uses a temp file no matter what.
00098   // Let's make sure it's not the exact same file though
00099   if (target.isLocalFile() && target.path() == src)
00100     return true;
00101 
00102   NetAccess kioNet;
00103   KURL s;
00104   s.setPath(src);
00105   return kioNet.filecopyInternal( s, target, -1, true /*overwrite*/,
00106                                   false, window, false /*copy*/ );
00107 }
00108 
00109 bool NetAccess::copy( const KURL & src, const KURL & target )
00110 {
00111   return NetAccess::file_copy( src, target, -1, false /*not overwrite*/, false, 0L );
00112 }
00113 
00114 bool NetAccess::copy( const KURL & src, const KURL & target, QWidget* window )
00115 {
00116   return NetAccess::file_copy( src, target, -1, false /*not overwrite*/, false, window );
00117 }
00118 
00119 bool NetAccess::file_copy( const KURL& src, const KURL& target, int permissions,
00120                            bool overwrite, bool resume, QWidget* window )
00121 {
00122   NetAccess kioNet;
00123   return kioNet.filecopyInternal( src, target, permissions, overwrite, resume,
00124                                   window, false /*copy*/ );
00125 }
00126 
00127 
00128 bool NetAccess::file_move( const KURL& src, const KURL& target, int permissions,
00129                            bool overwrite, bool resume, QWidget* window )
00130 {
00131   NetAccess kioNet;
00132   return kioNet.filecopyInternal( src, target, permissions, overwrite, resume,
00133                                   window, true /*move*/ );
00134 }
00135 
00136 bool NetAccess::dircopy( const KURL & src, const KURL & target )
00137 {
00138   return NetAccess::dircopy( src, target, 0 );
00139 }
00140 
00141 bool NetAccess::dircopy( const KURL & src, const KURL & target, QWidget* window )
00142 {
00143   KURL::List srcList;
00144   srcList.append( src );
00145   return NetAccess::dircopy( srcList, target, window );
00146 }
00147 
00148 bool NetAccess::dircopy( const KURL::List & srcList, const KURL & target, QWidget* window )
00149 {
00150   NetAccess kioNet;
00151   return kioNet.dircopyInternal( srcList, target, window, false /*copy*/ );
00152 }
00153 
00154 bool NetAccess::move( const KURL& src, const KURL& target, QWidget* window )
00155 {
00156   KURL::List srcList;
00157   srcList.append( src );
00158   return NetAccess::move( srcList, target, window );
00159 }
00160 
00161 bool NetAccess::move( const KURL::List& srcList, const KURL& target, QWidget* window )
00162 {
00163   NetAccess kioNet;
00164   return kioNet.dircopyInternal( srcList, target, window, true /*move*/ );
00165 }
00166 
00167 bool NetAccess::exists( const KURL & url )
00168 {
00169   return NetAccess::exists( url, false, 0 );
00170 }
00171 
00172 bool NetAccess::exists( const KURL & url, QWidget* window )
00173 {
00174   return NetAccess::exists( url, false, window );
00175 }
00176 
00177 bool NetAccess::exists( const KURL & url, bool source )
00178 {
00179   return NetAccess::exists( url, source, 0 );
00180 }
00181 
00182 bool NetAccess::exists( const KURL & url, bool source, QWidget* window )
00183 {
00184   if ( url.isLocalFile() )
00185     return QFile::exists( url.path() );
00186   NetAccess kioNet;
00187   return kioNet.statInternal( url, 0 /*no details*/, source, window );
00188 }
00189 
00190 bool NetAccess::stat( const KURL & url, KIO::UDSEntry & entry )
00191 {
00192   return NetAccess::stat( url, entry, 0 );
00193 }
00194 
00195 bool NetAccess::stat( const KURL & url, KIO::UDSEntry & entry, QWidget* window )
00196 {
00197   NetAccess kioNet;
00198   bool ret = kioNet.statInternal( url, 2 /*all details*/, true /*source*/, window );
00199   if (ret)
00200     entry = kioNet.m_entry;
00201   return ret;
00202 }
00203 
00204 bool NetAccess::del( const KURL & url )
00205 {
00206   return NetAccess::del( url, 0 );
00207 }
00208 
00209 bool NetAccess::del( const KURL & url, QWidget* window )
00210 {
00211   NetAccess kioNet;
00212   return kioNet.delInternal( url, window );
00213 }
00214 
00215 bool NetAccess::mkdir( const KURL & url, int permissions )
00216 {
00217   return NetAccess::mkdir( url, 0, permissions );
00218 }
00219 
00220 bool NetAccess::mkdir( const KURL & url, QWidget* window, int permissions )
00221 {
00222   NetAccess kioNet;
00223   return kioNet.mkdirInternal( url, permissions, window );
00224 }
00225 
00226 QString NetAccess::fish_execute( const KURL & url, const QString command, QWidget* window )
00227 {
00228   NetAccess kioNet;
00229   return kioNet.fish_executeInternal( url, command, window );
00230 }
00231 
00232 QString NetAccess::mimetype( const KURL& url )
00233 {
00234   NetAccess kioNet;
00235   return kioNet.mimetypeInternal( url, 0 );
00236 }
00237 
00238 QString NetAccess::mimetype( const KURL& url, QWidget* window )
00239 {
00240   NetAccess kioNet;
00241   return kioNet.mimetypeInternal( url, window );
00242 }
00243 
00244 void NetAccess::removeTempFile(const QString& name)
00245 {
00246   if (!tmpfiles)
00247     return;
00248   if (tmpfiles->contains(name))
00249   {
00250     unlink(QFile::encodeName(name));
00251     tmpfiles->remove(name);
00252   }
00253 }
00254 
00255 bool NetAccess::filecopyInternal(const KURL& src, const KURL& target, int permissions,
00256                                  bool overwrite, bool resume, QWidget* window, bool move)
00257 {
00258   bJobOK = true; // success unless further error occurs
00259 
00260   KIO::Scheduler::checkSlaveOnHold(true);
00261   KIO::Job * job = move
00262                    ? KIO::file_move( src, target, permissions, overwrite, resume )
00263                    : KIO::file_copy( src, target, permissions, overwrite, resume );
00264   job->setWindow (window);
00265   connect( job, SIGNAL( result (KIO::Job *) ),
00266            this, SLOT( slotResult (KIO::Job *) ) );
00267 
00268   enter_loop();
00269   return bJobOK;
00270 }
00271 
00272 bool NetAccess::dircopyInternal(const KURL::List& src, const KURL& target,
00273                                 QWidget* window, bool move)
00274 {
00275   bJobOK = true; // success unless further error occurs
00276 
00277   KIO::Job * job = move
00278                    ? KIO::move( src, target )
00279                    : KIO::copy( src, target );
00280   job->setWindow (window);
00281   connect( job, SIGNAL( result (KIO::Job *) ),
00282            this, SLOT( slotResult (KIO::Job *) ) );
00283 
00284   enter_loop();
00285   return bJobOK;
00286 }
00287 
00288 bool NetAccess::statInternal( const KURL & url, int details, bool source,
00289                               QWidget* window )
00290 {
00291   bJobOK = true; // success unless further error occurs
00292   KIO::StatJob * job = KIO::stat( url, !url.isLocalFile() );
00293   job->setWindow (window);
00294   job->setDetails( details );
00295   job->setSide( source );
00296   connect( job, SIGNAL( result (KIO::Job *) ),
00297            this, SLOT( slotResult (KIO::Job *) ) );
00298   enter_loop();
00299   return bJobOK;
00300 }
00301 
00302 bool NetAccess::delInternal( const KURL & url, QWidget* window )
00303 {
00304   bJobOK = true; // success unless further error occurs
00305   KIO::Job * job = KIO::del( url );
00306   job->setWindow (window);
00307   connect( job, SIGNAL( result (KIO::Job *) ),
00308            this, SLOT( slotResult (KIO::Job *) ) );
00309   enter_loop();
00310   return bJobOK;
00311 }
00312 
00313 bool NetAccess::mkdirInternal( const KURL & url, int permissions,
00314                                QWidget* window )
00315 {
00316   bJobOK = true; // success unless further error occurs
00317   KIO::Job * job = KIO::mkdir( url, permissions );
00318   job->setWindow (window);
00319   connect( job, SIGNAL( result (KIO::Job *) ),
00320            this, SLOT( slotResult (KIO::Job *) ) );
00321   enter_loop();
00322   return bJobOK;
00323 }
00324 
00325 QString NetAccess::mimetypeInternal( const KURL & url, QWidget* window )
00326 {
00327   bJobOK = true; // success unless further error occurs
00328   m_mimetype = QString::fromLatin1("unknown");
00329   KIO::Job * job = KIO::mimetype( url );
00330   job->setWindow (window);
00331   connect( job, SIGNAL( result (KIO::Job *) ),
00332            this, SLOT( slotResult (KIO::Job *) ) );
00333   connect( job, SIGNAL( mimetype (KIO::Job *, const QString &) ),
00334            this, SLOT( slotMimetype (KIO::Job *, const QString &) ) );
00335   enter_loop();
00336   return m_mimetype;
00337 }
00338 
00339 void NetAccess::slotMimetype( KIO::Job *, const QString & type  )
00340 {
00341   m_mimetype = type;
00342 }
00343 
00344 QString NetAccess::fish_executeInternal(const KURL & url, const QString command, QWidget* window)
00345 {
00346   QString target, remoteTempFileName, resultData;
00347   KURL tempPathUrl;
00348   KTempFile tmpFile;
00349   tmpFile.setAutoDelete( true );
00350 
00351   if( url.protocol() == "fish" )
00352   {
00353     // construct remote temp filename
00354     tempPathUrl = url;
00355     remoteTempFileName = tmpFile.name();
00356     // only need the filename KTempFile adds some KDE specific dirs
00357     // that probably does not exist on the remote side
00358     int pos = remoteTempFileName.findRev('/');
00359     remoteTempFileName = "/tmp/fishexec_" + remoteTempFileName.mid(pos + 1);
00360     tempPathUrl.setPath( remoteTempFileName );
00361     bJobOK = true; // success unless further error occurs
00362     QByteArray packedArgs;
00363     QDataStream stream( packedArgs, IO_WriteOnly );
00364 
00365     stream << int('X') << tempPathUrl << command;
00366 
00367     KIO::Job * job = KIO::special( tempPathUrl, packedArgs, true );
00368     job->setWindow( window );
00369     connect( job, SIGNAL( result (KIO::Job *) ),
00370              this, SLOT( slotResult (KIO::Job *) ) );
00371     enter_loop();
00372 
00373     // since the KIO::special does not provide feedback we need to download the result
00374     if( NetAccess::download( tempPathUrl, target, window ) )
00375     {
00376       QFile resultFile( target );
00377 
00378       if (resultFile.open( IO_ReadOnly ))
00379       {
00380         QTextStream ts( &resultFile );
00381         ts.setEncoding( QTextStream::Locale ); // Locale??
00382         resultData = ts.read();
00383         resultFile.close();
00384         NetAccess::del( tempPathUrl, window );
00385       }
00386     }
00387   }
00388   else
00389   {
00390     resultData = QString( "ERROR: Unknown protocol '%1'" ).arg( url.protocol() );
00391   }
00392   return resultData;
00393 }
00394 
00395 // If a troll sees this, he kills me
00396 void qt_enter_modal( QWidget *widget );
00397 void qt_leave_modal( QWidget *widget );
00398 
00399 void NetAccess::enter_loop()
00400 {
00401   QWidget dummy(0,0,WType_Dialog | WShowModal);
00402   dummy.setFocusPolicy( QWidget::NoFocus );
00403   qt_enter_modal(&dummy);
00404   qApp->enter_loop();
00405   qt_leave_modal(&dummy);
00406 }
00407 
00408 void NetAccess::slotResult( KIO::Job * job )
00409 {
00410   lastErrorCode = job->error();
00411   bJobOK = !job->error();
00412   if ( !bJobOK )
00413   {
00414     if ( !lastErrorMsg )
00415       lastErrorMsg = new QString;
00416     *lastErrorMsg = job->errorString();
00417   }
00418   if ( job->isA("KIO::StatJob") )
00419     m_entry = static_cast<KIO::StatJob *>(job)->statResult();
00420   qApp->exit_loop();
00421 }
00422 
00423 #include "netaccess.moc"
KDE Logo
This file is part of the documentation for kio Library Version 3.3.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Sep 23 17:12:24 2004 by doxygen 1.3.8-20040913 written by Dimitri van Heesch, © 1997-2003