runtime/kioslave/remote/kio_remote.cpp

   1 /* This file is part of the KDE project
   2    Copyright (c) 2004 Kevin Ottens <ervin ipsquad net>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public
   6    License as published by the Free Software Foundation; either
   7    version 2 of the License, or (at your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public License
  15    along with this library; see the file COPYING.LIB.  If not, write to
  16    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17    Boston, MA 02110-1301, USA.
  18 */
  19
  20 #include "kio_remote.h"
  21
  22 #include <stdlib.h>
  23
  24 #include <kdebug.h>
  25 #include <klocale.h>
  26 #include <kapplication.h>
  27 #include <kcmdlineargs.h>
  28 #include <kglobal.h>
  29
  30 #include <QFile>
  31
  32 extern "C" {
  33         int KDE_EXPORT kdemain( int argc, char **argv )
  34         {
  35         // necessary to use other kio slaves
  36         KComponentData componentData("kio_remote" );
  37         QCoreApplication app(argc, argv);
  38
  39         // start the slave
  40         RemoteProtocol slave( argv[1], argv[2], argv[3] );
  41         slave.dispatchLoop();
  42         return 0;
  43         }
  44 }
  45
  46
  47 RemoteProtocol::RemoteProtocol(const QByteArray &protocol,
  48                                const QByteArray &pool, const QByteArray &app)
  49         : SlaveBase(protocol, pool, app)
  50 {
  51 }
  52
  53 RemoteProtocol::~RemoteProtocol()
  54 {
  55 }
  56
  57 void RemoteProtocol::listDir(const KUrl &url)
  58 {
  59         kDebug(1220) << "RemoteProtocol::listDir: " << url;
  60
  61         if ( url.path().length() <= 1 )
  62         {
  63                 listRoot();
  64                 return;
  65         }
  66
  67         int second_slash_idx = url.path().indexOf( '/', 1 );
  68         QString root_dirname = url.path().mid( 1, second_slash_idx-1 );
  69
  70         KUrl target = m_impl.findBaseURL( root_dirname );
  71         kDebug(1220) << "possible redirection target : " << target;
  72         if( target.isValid() )
  73         {
  74                 target.addPath( url.path().remove(0, second_slash_idx) );
  75                 redirection(target);
  76                 finished();
  77                 return;
  78         }
  79
  80         error(KIO::ERR_MALFORMED_URL, url.prettyUrl());
  81 }
  82
  83 void RemoteProtocol::listRoot()
  84 {
  85         KIO::UDSEntry entry;
  86
  87         KIO::UDSEntryList remote_entries;
  88         m_impl.listRoot(remote_entries);
  89
  90         totalSize(remote_entries.count()+2);
  91
  92         m_impl.createTopLevelEntry(entry);
  93         listEntry(entry, false);
  94
  95         m_impl.createWizardEntry(entry);
  96         listEntry(entry, false);
  97
  98         KIO::UDSEntryList::ConstIterator it = remote_entries.constBegin();
  99         const KIO::UDSEntryList::ConstIterator end = remote_entries.constEnd();
 100         for(; it!=end; ++it)
 101         {
 102                 listEntry(*it, false);
 103         }
 104
 105         entry.clear();
 106         listEntry(entry, true);
 107
 108         finished();
 109 }
 110
 111 void RemoteProtocol::stat(const KUrl &url)
 112 {
 113         kDebug(1220) << "RemoteProtocol::stat: " << url;
 114
 115         QString path = url.path();
 116         if ( path.isEmpty() || path == "/" )
 117         {
 118                 // The root is "virtual" - it's not a single physical directory
 119                 KIO::UDSEntry entry;
 120                 m_impl.createTopLevelEntry( entry );
 121                 statEntry( entry );
 122                 finished();
 123                 return;
 124         }
 125
 126         if (m_impl.isWizardURL(url))
 127         {
 128                 KIO::UDSEntry entry;
 129                 if (m_impl.createWizardEntry(entry))
 130                 {
 131                         statEntry(entry);
 132                         finished();
 133                 }
 134                 else
 135                 {
 136                         error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
 137                 }
 138                 return;
 139         }
 140
 141         int second_slash_idx = url.path().indexOf( '/', 1 );
 142         QString root_dirname = url.path().mid( 1, second_slash_idx-1 );
 143
 144         if ( second_slash_idx==-1 || ( (int)url.path().length() )==second_slash_idx+1 )
 145         {
 146                 KIO::UDSEntry entry;
 147                 if (m_impl.statNetworkFolder(entry, root_dirname))
 148                 {
 149                         statEntry(entry);
 150                         finished();
 151                         return;
 152                 }
 153         }
 154         else
 155         {
 156                 KUrl target = m_impl.findBaseURL(  root_dirname );
 157                 kDebug( 1220 ) << "possible redirection target : " << target;
 158                 if (  target.isValid() )
 159                 {
 160                         target.addPath( url.path().remove( 0, second_slash_idx ) );
 161                         redirection( target );
 162                         finished();
 163                         return;
 164                 }
 165         }
 166
 167         error(KIO::ERR_MALFORMED_URL, url.prettyUrl());
 168 }
 169
 170 void RemoteProtocol::del(const KUrl &url, bool /*isFile*/)
 171 {
 172         kDebug(1220) << "RemoteProtocol::del: " << url;
 173
 174         if (!m_impl.isWizardURL(url)
 175          && m_impl.deleteNetworkFolder(url.fileName()))
 176         {
 177                 finished();
 178                 return;
 179         }
 180
 181         error(KIO::ERR_CANNOT_DELETE, url.prettyUrl());
 182 }
 183
 184 void RemoteProtocol::get(const KUrl &url)
 185 {
 186         kDebug(1220) << "RemoteProtocol::get: " << url;
 187
 188         QString file = m_impl.findDesktopFile( url.fileName() );
 189         kDebug(1220) << "desktop file : " << file;
 190
 191         if (!file.isEmpty())
 192         {
 193                 KUrl desktop;
 194                 desktop.setPath(file);
 195
 196                 redirection(desktop);
 197                 finished();
 198                 return;
 199         }
 200
 201         error(KIO::ERR_MALFORMED_URL, url.prettyUrl());
 202 }
 203
 204 void RemoteProtocol::rename(const KUrl &src, const KUrl &dest,
 205                             KIO::JobFlags flags)
 206 {
 207         if (src.protocol()!="remote" || dest.protocol()!="remote"
 208          || m_impl.isWizardURL(src) || m_impl.isWizardURL(dest))
 209         {
 210                 error(KIO::ERR_UNSUPPORTED_ACTION, src.prettyUrl());
 211                 return;
 212         }
 213
 214         if (m_impl.renameFolders(src.fileName(), dest.fileName(), flags & KIO::Overwrite))
 215         {
 216                 finished();
 217                 return;
 218         }
 219
 220         error(KIO::ERR_CANNOT_RENAME, src.prettyUrl());
 221 }