Added old KDE3 version of Krusader

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/krusader@1094427 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1668 insertions, 0 deletions

diff --git a/krArc/krarc.cpp b/krArc/krarc.cpp
new file mode 100644
index 0000000..663236a
--- /dev/null
+++ b/krArc/krarc.cpp
@@ -0,0 +1,1668 @@
+/***************************************************************************
+                                 krarc.cpp
+                             -------------------
+    begin                : Sat Jun 14 14:42:49 IDT 2003
+    copyright            : (C) 2003 by Rafi Yanai & Shie Erlich
+    email                : [email protected]
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <stdlib.h>
+
+#include <qdir.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+#include <qdir.h>
+
+#include <kfileitem.h>
+#include <kdebug.h>
+#include <kmessagebox.h>
+#include <kinstance.h>
+#include <klocale.h>
+#include <kurl.h>
+#include <ktempfile.h>
+#include <klargefile.h>
+#include <kstandarddirs.h>
+#include <kio/job.h>
+#include <ktar.h>
+
+#include <iostream>
+#include "krarc.h"
+
+#define MAX_IPC_SIZE           (1024*32)
+#define TRIES_WITH_PASSWORDS   3
+
+#if 0
+#define KRDEBUG(X...) do{   \
+	QFile f("/tmp/debug");    \
+	f.open(IO_WriteOnly | IO_Append);     \
+	QTextStream stream( &f ); \
+  stream << "Pid:" << (int)getpid() << " " <<__FUNCTION__<<"(" <<__LINE__<<"): "; \
+  stream << X << endl;      \
+	f.close();                \
+} while(0);
+#else
+#define KRDEBUG(X...)
+#endif
+
+using namespace KIO;
+extern "C" {
+
+int kdemain( int argc, char **argv ){
+	KInstance instance( "kio_krarc" );
+	
+	if (argc != 4) {
+		kdWarning() << "Usage: kio_krarc  protocol domain-socket1 domain-socket2" << endl;
+		exit(-1);
+	}
+	
+	kio_krarcProtocol slave(argv[2], argv[3]);
+	slave.dispatchLoop();
+	
+	return 0;
+}
+
+} // extern "C" 
+
+kio_krarcProtocol::kio_krarcProtocol(const QCString &pool_socket, const QCString &app_socket)
+	: SlaveBase("kio_krarc", pool_socket, app_socket), archiveChanged(true), arcFile(0L),extArcReady(false),
+		password(QString::null) {
+	
+	krConfig = new KConfig( "krusaderrc" );
+	krConfig->setGroup( "Dependencies" );
+	
+	dirDict.setAutoDelete(true);
+	
+	arcTempDir = locateLocal("tmp",QString::null);
+	QString dirName = "krArc"+QDateTime::currentDateTime().toString(Qt::ISODate);
+	dirName.replace(QRegExp(":"),"_");
+	QDir(arcTempDir).mkdir(dirName);
+	arcTempDir = arcTempDir+dirName+"/";
+}
+
+/* ---------------------------------------------------------------------------------- */
+kio_krarcProtocol::~kio_krarcProtocol(){
+	// delete the temp directory
+	KrShellProcess proc;
+	proc << "rm -rf "<< arcTempDir;
+	proc.start(KProcess::Block);
+}
+
+/* ---------------------------------------------------------------------------------- */
+void kio_krarcProtocol::receivedData(KProcess*,char* buf,int len){
+	QByteArray d(len);
+	d.setRawData(buf,len);
+	data(d);
+	d.resetRawData(buf,len);
+	processedSize(len);	
+	decompressedLen += len;
+}
+
+void kio_krarcProtocol::mkdir(const KURL& url,int permissions){
+	KRDEBUG(url.path());
+	
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( newArchiveURL && !initDirDict(url) ){ 
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	
+	if( putCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Creating directories is not supported with %1 archives").arg(arcType) );
+		return;
+	}
+	
+	if( arcType == "arj" || arcType == "lha" ) {
+		QString arcDir = url.path().mid(arcFile->url().path().length());
+		if( arcDir.right(1) != "/") arcDir = arcDir+"/";
+		
+		if( dirDict.find( arcDir ) == 0 )
+			addNewDir( arcDir );
+		finished();
+		return;
+	}
+	
+	//QString tmpDir = arcTempDir+url.path();
+	QString arcDir  = findArcDirectory(url);
+	QString tmpDir = arcTempDir + arcDir.mid(1) + url.path().mid(url.path().findRev("/")+1);
+	if( tmpDir.right(1) != "/" ) tmpDir = tmpDir+"/";
+	
+	if( permissions == -1 ) permissions = 0777; //set default permissions
+	for( unsigned int i=arcTempDir.length();i<tmpDir.length(); i=tmpDir.find("/",i+1)){
+		::mkdir(tmpDir.left(i).local8Bit(),permissions);
+	}
+	
+	if( tmpDir.endsWith( "/" ) )
+		tmpDir.truncate( tmpDir.length() - 1 );
+	
+	// pack the directory
+	KrShellProcess proc;
+	proc << putCmd << convertName( arcFile->url().path() ) + " " << convertFileName( tmpDir.mid(arcTempDir.length()) );
+	infoMessage(i18n("Creating %1 ...").arg( url.fileName() ) );
+	QDir::setCurrent(arcTempDir);
+	proc.start(KProcess::Block,KProcess::AllOutput);
+	
+	// delete the temp directory
+	QDir().rmdir(arcTempDir);
+	
+	if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) )  {
+		error(ERR_COULD_NOT_WRITE,url.path() + "\n\n" + proc.getErrorMsg() );
+		return;
+	}
+	
+	//  force a refresh of archive information
+	initDirDict(url,true);
+	finished();
+}
+
+void kio_krarcProtocol::put(const KURL& url,int permissions,bool overwrite,bool resume){
+	KRDEBUG(url.path());
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( newArchiveURL && !initDirDict(url) ){ 
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	
+	if( putCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Writing to %1 archives is not supported").arg(arcType) );
+		return;
+	} 
+	if( !overwrite && findFileEntry(url) ){
+		error( ERR_FILE_ALREADY_EXIST,url.path() );
+		return;
+	}
+	
+	QString arcDir  = findArcDirectory(url);
+	QString tmpFile = arcTempDir + arcDir.mid(1) + url.path().mid(url.path().findRev("/")+1);
+	
+	QString tmpDir = arcTempDir+arcDir.mid(1)+"/";
+	for( unsigned int i=arcTempDir.length();i<tmpDir.length(); i=tmpDir.find("/",i+1)){
+		QDir("/").mkdir(tmpDir.left(i));
+	}
+	int fd;
+	if ( resume ) {
+		fd = KDE_open( tmpFile.local8Bit(), O_RDWR );  // append if resuming
+		KDE_lseek(fd, 0, SEEK_END); // Seek to end
+	} else {
+		// WABA: Make sure that we keep writing permissions ourselves,
+		// otherwise we can be in for a surprise on NFS.
+		mode_t initialMode;
+		if ( permissions != -1)
+			initialMode = permissions | S_IWUSR | S_IRUSR;
+		else
+			initialMode = 0666;
+		
+		fd = KDE_open(tmpFile.local8Bit(), O_CREAT | O_TRUNC | O_WRONLY, initialMode);
+	}
+	QByteArray buffer;
+	int readResult;
+	do{
+		dataReq();
+		readResult = readData(buffer);
+		write(fd,buffer.data(),buffer.size());
+ 	} while( readResult > 0 );
+	close(fd);
+	// pack the file
+	KrShellProcess proc;
+	proc << putCmd << convertName( arcFile->url().path() )+ " " <<convertFileName( tmpFile.mid(arcTempDir.length()) );
+	infoMessage(i18n("Packing %1 ...").arg( url.fileName() ) );
+	QDir::setCurrent(arcTempDir);
+	proc.start(KProcess::Block,KProcess::AllOutput);
+	// remove the file
+	QFile::remove(tmpFile);
+
+	if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) )  {
+		error(ERR_COULD_NOT_WRITE,url.path() + "\n\n" + proc.getErrorMsg() );
+		return;
+	}
+	//  force a refresh of archive information
+	initDirDict(url,true);
+	finished();
+}
+
+void kio_krarcProtocol::get(const KURL& url ){
+	get( url, TRIES_WITH_PASSWORDS );
+}
+
+void kio_krarcProtocol::get(const KURL& url, int tries ){
+	bool decompressToFile = false;
+	KRDEBUG(url.path());
+	
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( newArchiveURL && !initDirDict(url) ){ 
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	
+	if( getCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Retrieving data from %1 archives is not supported").arg(arcType) );
+		return;
+	} 
+	UDSEntry* entry = findFileEntry(url);
+	if( !entry ){
+		error(KIO::ERR_DOES_NOT_EXIST,url.path());
+		return;
+	}
+	if(KFileItem(*entry,url).isDir()){
+		error(KIO::ERR_IS_DIRECTORY,url.path());
+		return;
+	}
+	KIO::filesize_t expectedSize = KFileItem(*entry,url).size();
+	// for RPM files extract the cpio file first
+	if( !extArcReady && arcType == "rpm"){
+		KrShellProcess cpio;
+		cpio << "rpm2cpio" << convertName( arcFile->url().path(-1) ) << " > " << arcTempDir+"contents.cpio";
+		cpio.start(KProcess::Block,KProcess::AllOutput);
+		if( !cpio.normalExit() || cpio.exitStatus() != 0 )  {
+			error(ERR_COULD_NOT_READ,url.path() + "\n\n" + cpio.getErrorMsg() );
+			return;
+		}
+		extArcReady = true;
+	}
+	// for DEB files extract the tar file first
+	if ( !extArcReady && arcType == "deb" ) {
+		KrShellProcess dpkg;
+		dpkg << cmd + " --fsys-tarfile" << convertName( arcFile->url().path( -1 ) ) << " > " << arcTempDir + "contents.cpio";
+		dpkg.start( KProcess::Block, KProcess::AllOutput );
+		if( !dpkg.normalExit() || dpkg.exitStatus() != 0 )  {
+			error(ERR_COULD_NOT_READ,url.path() + "\n\n" + dpkg.getErrorMsg() );
+			return;
+		}
+		extArcReady = true;
+	}
+
+	// Use the external unpacker to unpack the file
+	QString file = url.path().mid(arcFile->url().path().length()+1);
+	KrShellProcess proc;
+	if( extArcReady ){
+		proc << getCmd << arcTempDir+"contents.cpio " << convertName( "*"+file );
+	} else if( arcType == "arj" || arcType == "ace" || arcType == "7z" ) {
+		proc << getCmd << convertName( arcFile->url().path(-1) )+ " " << convertFileName( file );
+		if( arcType == "ace" && QFile( "/dev/ptmx" ).exists() ) // Don't remove, unace crashes if missing!!!
+		proc << "<" << "/dev/ptmx"; 
+		file = url.fileName();
+		decompressToFile = true;
+	} else {
+		decompressedLen = 0;
+		// Determine the mimetype of the file to be retrieved, and emit it.
+		// This is mandatory in all slaves (for KRun/BrowserRun to work).
+		KMimeType::Ptr mt = KMimeType::findByURL( arcTempDir+file, 0, false /* NOT local URL */ );
+		emit mimeType( mt->name() );
+		proc << getCmd << convertName( arcFile->url().path() )+" ";
+		if( arcType != "gzip" && arcType != "bzip2" ) proc << convertFileName( file );
+		connect(&proc,SIGNAL(receivedStdout(KProcess*,char*,int)),
+				this,SLOT(receivedData(KProcess*,char*,int)) );
+	}
+	infoMessage(i18n("Unpacking %1 ...").arg( url.fileName() ) );
+	// change the working directory to our arcTempDir
+	QDir::setCurrent(arcTempDir);
+	proc.start(KProcess::Block,KProcess::AllOutput);
+	
+	if( !extArcReady && !decompressToFile ) {  
+		if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) || ( arcType != "bzip2" && expectedSize != decompressedLen ) ) {
+			if( encrypted && tries ) {
+				invalidatePassword();
+				get( url, tries - 1 );
+				return;
+			}
+			error( KIO::ERR_ACCESS_DENIED, url.path() + "\n\n" + proc.getErrorMsg() );
+			return;
+		}
+	}
+	else{
+		if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) || !QFileInfo( arcTempDir+file ).exists() ) {
+			if( decompressToFile )
+				QFile(arcTempDir+file).remove();
+			if( encrypted && tries ) {
+				invalidatePassword();
+				get( url, tries - 1 );
+				return;
+			}
+			error( KIO::ERR_ACCESS_DENIED, url.path() );
+			return;
+		}
+		// the follwing block is ripped from KDE file KIO::Slave
+		// $Id: krarc.cpp,v 1.43 2007/01/13 13:39:51 ckarai Exp $
+		QCString _path( QFile::encodeName(arcTempDir+file) );
+		KDE_struct_stat buff;
+		if( KDE_lstat( _path.data(), &buff ) == -1 ) {
+			if ( errno == EACCES )
+				error( KIO::ERR_ACCESS_DENIED, url.path() );
+			else
+				error( KIO::ERR_DOES_NOT_EXIST, url.path() );
+			return;
+		}
+		if ( S_ISDIR( buff.st_mode ) ) {
+			error( KIO::ERR_IS_DIRECTORY, url.path() );
+			return;
+		}
+		if ( !S_ISREG(buff.st_mode) ) {
+			error( KIO::ERR_CANNOT_OPEN_FOR_READING, url.path() );
+			return;
+		}
+		int fd = KDE_open( _path.data(), O_RDONLY );
+		if ( fd < 0 ) {
+			error( KIO::ERR_CANNOT_OPEN_FOR_READING, url.path() );
+			return;
+		}
+		// Determine the mimetype of the file to be retrieved, and emit it.
+		// This is mandatory in all slaves (for KRun/BrowserRun to work).
+		KMimeType::Ptr mt = KMimeType::findByURL( arcTempDir+file, buff.st_mode, true /* local URL */ );
+		emit mimeType( mt->name() );
+		
+		KIO::filesize_t processed_size = 0;
+		
+		QString resumeOffset = metaData("resume");
+		if ( !resumeOffset.isEmpty() ){
+			bool ok;
+#if QT_VERSION >= 0x030200
+			KIO::fileoffset_t offset = resumeOffset.toLongLong(&ok);
+#else
+			KIO::fileoffset_t offset = resumeOffset.toULong(&ok);
+#endif
+			if (ok && (offset > 0) && (offset < buff.st_size)){
+				if (KDE_lseek(fd, offset, SEEK_SET) == offset){
+					canResume ();
+					processed_size = offset;
+				}
+			}
+		}
+		
+		totalSize( buff.st_size );
+		
+		char buffer[ MAX_IPC_SIZE ];
+		QByteArray array;
+		while( 1 ){
+			int n = ::read( fd, buffer, MAX_IPC_SIZE );
+			if (n == -1){
+				if (errno == EINTR)
+					continue;
+				error( KIO::ERR_COULD_NOT_READ, url.path());
+				close(fd);
+				return;
+			}
+			if (n == 0)
+				break; // Finished
+			
+			array.setRawData(buffer, n);
+			data( array );
+			array.resetRawData(buffer, n);
+			
+			processed_size += n;
+		}
+		
+		data( QByteArray() );
+		close( fd );
+		processedSize( buff.st_size );
+		finished();
+		
+		if( decompressToFile )
+			QFile(arcTempDir+file).remove();
+		return;
+	}
+	// send empty buffer to mark EOF
+	data(QByteArray());
+	finished();
+}
+
+void kio_krarcProtocol::del(KURL const & url, bool isFile){
+	KRDEBUG(url.path());
+	
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( newArchiveURL && !initDirDict(url) ){ 
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	
+	if( delCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Deleting files from %1 archives is not supported").arg(arcType) );
+		return;
+	}
+	if( !findFileEntry(url) ){
+		if( ( arcType != "arj" && arcType != "lha" ) || isFile ) {
+			error(KIO::ERR_DOES_NOT_EXIST,url.path());
+			return;
+		}
+	}
+	
+	QString file = url.path().mid(arcFile->url().path().length()+1);
+	if( !isFile && file.right(1) != "/" ) {
+		if(arcType == "zip") file = file + "/";
+	}
+	KrShellProcess proc;
+	proc << delCmd << convertName( arcFile->url().path() )+" " << convertFileName( file );
+	infoMessage(i18n("Deleting %1 ...").arg( url.fileName() ) );
+	proc.start(KProcess::Block, KProcess::AllOutput);
+	if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) )  {
+		error(ERR_COULD_NOT_WRITE,url.path() + "\n\n" + proc.getErrorMsg() );
+		return;
+	}
+	//  force a refresh of archive information
+	initDirDict(url,true);
+	finished();
+}
+
+void kio_krarcProtocol::stat( const KURL & url ){  
+	KRDEBUG(url.path());
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( newArchiveURL && !initDirDict(url) ){ 
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	
+	if( listCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Accessing files is not supported with the %1 archives").arg(arcType) );
+		return;
+	}    
+	QString path = url.path(-1);
+	KURL newUrl = url;
+	
+	// but treat the archive itself as the archive root
+	if( path == arcFile->url().path(-1) ){
+		newUrl.setPath(path+"/");
+		path = newUrl.path();
+	}
+	// we might be stating a real file
+	if( QFileInfo(path).exists() ){
+		KDE_struct_stat buff;
+		KDE_stat( path.local8Bit(), &buff );
+		QString mime = KMimeType::findByPath(path,buff.st_mode)->name();
+		statEntry(KFileItem(path,mime,buff.st_mode).entry());
+		finished();
+		return;
+	}
+	UDSEntry* entry = findFileEntry(newUrl);
+	if( entry ){
+		statEntry( *entry );
+		finished();
+	} else error( KIO::ERR_DOES_NOT_EXIST, path );
+}
+
+void kio_krarcProtocol::copy (const KURL &url, const KURL &dest, int, bool overwrite) {
+	KRDEBUG(url.path());
+  
+	// KDE HACK: opening the password dlg in copy causes error for the COPY, and further problems
+	// that's why encrypted files are not allowed to copy
+	if( !encrypted && dest.isLocalFile() )
+		do {
+			if( url.fileName() != dest.fileName() )
+				break;
+			
+			//the file exists and we don't want to overwrite
+			if ((!overwrite) && ( QFile( dest.path() ).exists() ) ) {
+				error(ERR_FILE_ALREADY_EXIST, QFile::encodeName(dest.path()) );
+				return;
+			};
+			
+			if( !setArcFile( url ) ) {
+				error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+				return;
+			}
+			if( newArchiveURL && !initDirDict(url) ){ 
+				error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+				return;
+			}
+			
+			UDSEntry* entry = findFileEntry(url);
+			if( copyCmd.isEmpty() || !entry )
+				break;
+			
+			QString file = url.path().mid(arcFile->url().path().length()+1);
+			
+			QString destDir = dest.path( -1 );
+			if( !QDir( destDir ).exists() ) {
+				int ndx = destDir.findRev( '/' );
+				if( ndx != -1 )
+					destDir.truncate( ndx+1 );
+			}
+			
+			QDir::setCurrent( destDir.local8Bit() );
+			
+			KrShellProcess proc;
+			proc << copyCmd << convertName( arcFile->url().path(-1) )+" " << convertFileName( file );
+			if( arcType == "ace" && QFile( "/dev/ptmx" ).exists() ) // Don't remove, unace crashes if missing!!!
+				proc << "<" << "/dev/ptmx"; 
+			
+			infoMessage(i18n("Unpacking %1 ...").arg( url.fileName() ) );
+			proc.start(KProcess::Block, KProcess::AllOutput);
+			if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) )  {
+				error(KIO::ERR_COULD_NOT_WRITE, dest.path(-1) + "\n\n" + proc.getErrorMsg() );
+				return;
+			}
+			if( !QFileInfo( dest.path(-1) ).exists() ) {
+				error( KIO::ERR_COULD_NOT_WRITE, dest.path(-1) );
+				return;
+			}
+			
+			processedSize( KFileItem(*entry,url).size() );
+			finished();
+			QDir::setCurrent( "/" ); /* for being able to umount devices after copying*/
+			return;
+		}while( 0 );
+	
+	error(  ERR_UNSUPPORTED_ACTION, unsupportedActionErrorString(mProtocol, CMD_COPY));
+}
+
+void kio_krarcProtocol::listDir(const KURL& url){
+	KRDEBUG(url.path());
+	if( !setArcFile( url ) ) {
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	if( listCmd.isEmpty() ){
+		error(ERR_UNSUPPORTED_ACTION,
+		i18n("Listing directories is not supported for %1 archives").arg(arcType) );
+		return;
+	}  
+	QString path = url.path();
+	if( path.right(1) != "/" ) path = path+"/";
+	
+	// it might be a real dir !
+	if( QFileInfo(path).exists() ){
+		if( QFileInfo(path).isDir() ){
+			KURL redir;
+			redir.setPath( url.path() );
+			redirection(redir);
+			finished();
+		} else { // maybe it's an archive !
+			error(ERR_IS_FILE,path);
+		}
+		return;
+	}
+	if( !initDirDict(url) ){ 
+		error( ERR_CANNOT_ENTER_DIRECTORY, url.path());
+		return;
+	}
+	QString arcDir = path.mid(arcFile->url().path().length());
+	arcDir.truncate(arcDir.findRev("/"));
+	if(arcDir.right(1) != "/") arcDir = arcDir+"/";
+	
+	UDSEntryList* dirList = dirDict.find(arcDir);
+	if( dirList == 0 ){
+		error(ERR_CANNOT_ENTER_DIRECTORY,url.path());
+		return;
+	}
+	totalSize(dirList->size());
+	listEntries(*dirList);
+	finished();
+}
+
+bool kio_krarcProtocol::setArcFile(const KURL& url){
+	QString path = url.path();
+	time_t currTime = time( 0 );
+	archiveChanged = true;
+	newArchiveURL = true;
+	// is the file already set ?
+	if( arcFile && arcFile->url().path(-1) == path.left(arcFile->url().path(-1).length()) ){
+		newArchiveURL = false;        
+		// Has it changed ?
+		KFileItem* newArcFile = new KFileItem(arcFile->url(),QString::null,arcFile->mode());
+		if( !newArcFile->cmp( *arcFile ) ){
+			delete arcFile;
+			password = QString::null;
+			extArcReady = false;
+			arcFile = newArcFile;
+		} else { // same old file
+			delete newArcFile;
+			archiveChanged = false;
+			if( encrypted && password.isNull() )
+				initArcParameters();
+		}
+	} else { // it's a new file...
+		extArcReady = false;
+		if( arcFile ){
+			delete arcFile;
+			password = QString::null;
+			arcFile = 0L;
+		}
+		QString newPath = path;
+		if(newPath.right(1) != "/") newPath = newPath+"/";
+		for(int pos=0; pos >= 0; pos = newPath.find("/",pos+1)){
+			QFileInfo qfi(newPath.left(pos));
+			if( qfi.exists() && !qfi.isDir() ){
+				KDE_struct_stat stat_p;
+				KDE_lstat(newPath.left(pos).local8Bit(),&stat_p);
+				arcFile = new KFileItem(KURL::fromPathOrURL( newPath.left(pos) ),QString::null,stat_p.st_mode);
+				break;
+			}
+		}
+		if( !arcFile ){
+			error( ERR_DOES_NOT_EXIST,path );
+			return false; // file not found
+		}
+	}
+	
+	/* FIX: file change can only be detected if the timestamp between the two consequent 
+	   changes is more than 1s. If the archive is continuously changing (check: move files 
+	   inside the archive), krarc may erronously think, that the archive file is unchanged, 
+	   because the timestamp is the same as the previous one. This situation can only occur
+	   if the modification time equals with the current time. While this condition is true,
+	   we can say, that the archive is changing, so content reread is always necessary 
+	   during that period. */
+	if( archiveChanging )
+		archiveChanged = true;
+	archiveChanging = ( currTime == arcFile->time( UDS_MODIFICATION_TIME ) );
+	
+	arcPath = arcFile->url().path(-1);
+	arcType = detectArchive( encrypted, arcPath );
+	
+	if( arcType == "tbz" )
+		arcType = "bzip2";
+	else if( arcType == "tgz" )
+		arcType = "gzip";
+	
+	if( arcType.isEmpty() ) {
+		arcType = arcFile->mimetype();
+		arcType = arcType.mid(arcType.findRev("-")+1);
+		
+		if( arcType == "jar" )
+			arcType = "zip";
+	}
+	
+	return initArcParameters();
+}
+
+bool kio_krarcProtocol::initDirDict(const KURL&url, bool forced){
+	// set the archive location
+	//if( !setArcFile(url.path()) ) return false;
+	// no need to rescan the archive if it's not changed
+	if( !archiveChanged && !forced ) return true;
+	extArcReady = false;
+	
+	if( !setArcFile( url ) )
+		return false;   /* if the archive was changed refresh the file information */
+	
+	// write the temp file
+	KrShellProcess proc;
+	KTempFile temp( QString::null, "tmp" );
+	temp.setAutoDelete(true);
+	if( arcType != "bzip2" ){
+		if( arcType == "rpm" )
+			proc << listCmd << convertName( arcPath ) <<" > " << temp.name();
+		else        
+			proc << listCmd << convertName( arcFile->url().path(-1) ) <<" > " << temp.name();
+		if( arcType == "ace" && QFile( "/dev/ptmx" ).exists() ) // Don't remove, unace crashes if missing!!!
+			proc << "<" << "/dev/ptmx";
+		proc.start(KProcess::Block,KProcess::AllOutput);
+		if( !proc.normalExit() || !checkStatus( proc.exitStatus() ) ) return false;
+	}
+	// clear the dir dictionary
+	dirDict.clear();
+	
+	// add the "/" directory
+	UDSEntryList* root = new UDSEntryList();
+	dirDict.insert("/",root);
+	// and the "/" UDSEntry
+	UDSEntry entry;
+	UDSAtom atom;
+	atom.m_uds = UDS_NAME;
+	atom.m_str = ".";
+	entry.append(atom);
+	mode_t mode = parsePermString("drwxr-xr-x");
+	atom.m_uds = UDS_FILE_TYPE;
+	atom.m_long = mode & S_IFMT; // keep file type only
+	entry.append( atom );
+	atom.m_uds = UDS_ACCESS;
+	atom.m_long = mode & 07777; // keep permissions only
+	entry.append( atom );
+	
+	root->append(entry);
+	
+	if( arcType == "bzip2" ){
+		KRDEBUG("Got me here...");
+		parseLine(0,"",temp.file());
+		return true;
+	}
+	
+	// parse the temp file
+	temp.file()->open(IO_ReadOnly);
+	char buf[1000];
+	QString line;
+	
+	int lineNo = 0;
+	bool invalidLine = false;
+	// the rar list is started with a ------ line.
+	if(arcType == "rar" || arcType == "arj" || arcType == "lha" || arcType == "7z" ){
+		while(temp.file()->readLine(buf,1000) != -1){
+			line = QString::fromLocal8Bit(buf);
+			if( line.startsWith("----------") ) break;
+		}
+	} 
+	while(temp.file()->readLine(buf,1000) != -1) {
+		line = QString::fromLocal8Bit(buf);
+		if( arcType == "rar" ) {
+			// the rar list is ended with a ------ line.
+			if( line.startsWith("----------") ) {
+				invalidLine = !invalidLine;
+				continue;
+			}
+			if( invalidLine )
+				continue;
+			else{
+				temp.file()->readLine(buf,1000);
+				line = line+QString::fromLocal8Bit(buf);
+				if( line[0]=='*' ) // encrypted archives starts with '*'
+					line[0]=' ';
+			}
+		}
+		if( arcType == "ace" ) {
+			// the ace list begins with a number.
+			if( !line[0].isDigit() ) continue;
+		}
+		if( arcType == "arj" ) {
+			// the arj list is ended with a ------ line.
+			if( line.startsWith("----------") ) {
+				invalidLine = !invalidLine;
+				continue;
+			}
+			if( invalidLine )
+				continue;
+			else {
+				temp.file()->readLine(buf,1000);
+				line = line+QString::fromLocal8Bit(buf);
+				temp.file()->readLine(buf,1000);
+				line = line+QString::fromLocal8Bit(buf);
+				temp.file()->readLine(buf,1000);
+				line = line+QString::fromLocal8Bit(buf);
+			}
+		}
+		if( arcType == "lha" || arcType == "7z" ) {
+			// the arj list is ended with a ------ line.
+			if( line.startsWith("----------") ) break;
+		}
+		parseLine(lineNo++,line.stripWhiteSpace(),temp.file());
+	}
+	// close and delete our file
+	temp.file()->close();
+	
+	archiveChanged = false;
+	return true;
+}
+
+QString kio_krarcProtocol::findArcDirectory(const KURL& url){
+	QString path = url.path();
+	if( path.right(1) == "/" ) path.truncate(path.length()-1);
+	
+	if( !initDirDict(url) ){
+		return QString::null;
+	}
+	QString arcDir = path.mid(arcFile->url().path().length());
+	arcDir.truncate(arcDir.findRev("/"));
+	if(arcDir.right(1) != "/") arcDir = arcDir+"/";
+	
+	return arcDir;
+}
+
+UDSEntry* kio_krarcProtocol::findFileEntry(const KURL& url){
+	QString arcDir = findArcDirectory(url);
+	if( arcDir.isEmpty() ) return 0;
+	
+	UDSEntryList* dirList = dirDict.find(arcDir);
+	if( !dirList ){
+		return 0;
+	}
+	QString name = url.path();
+	if( arcFile->url().path(-1) == url.path(-1) ) name = "."; // the "/" case
+	else{
+		if( name.right(1) == "/" ) name.truncate(name.length()-1);
+		name = name.mid(name.findRev("/")+1);
+	}
+	
+	UDSEntryList::iterator entry;
+	UDSEntry::iterator atom;
+	
+	for ( entry = dirList->begin(); entry != dirList->end(); ++entry ){
+		for( atom = (*entry).begin(); atom != (*entry).end(); ++atom ){
+			if( (*atom).m_uds == UDS_NAME ){
+				if((*atom).m_str == name){
+					return &(*entry);
+				} else break;
+			}
+		}
+	}
+	return 0;
+}
+
+QString kio_krarcProtocol::nextWord(QString &s,char d) {
+	s=s.stripWhiteSpace();
+	int j=s.find(d,0);
+	QString temp=s.left(j); // find the leftmost word.
+	s.remove(0,j);
+	return temp;
+}
+
+mode_t kio_krarcProtocol::parsePermString(QString perm){
+	mode_t mode=0;
+	// file type
+	if(perm[0] == 'd') mode |= S_IFDIR;
+	if(perm[0] == 'l') mode |= S_IFLNK;
+	if(perm[0] == '-') mode |= S_IFREG;
+	// owner permissions
+	if(perm[1] != '-') mode |= S_IRUSR;
+	if(perm[2] != '-') mode |= S_IWUSR;
+	if(perm[3] != '-') mode |= S_IXUSR;
+	// group permissions
+	if(perm[4] != '-') mode |= S_IRGRP;
+	if(perm[5] != '-') mode |= S_IWGRP;
+	if(perm[6] != '-') mode |= S_IXGRP;
+	// other permissions
+	if(perm[7] != '-') mode |= S_IROTH;
+	if(perm[8] != '-') mode |= S_IWOTH;
+	if(perm[9] != '-') mode |= S_IXOTH;
+	
+	return mode;
+}
+
+UDSEntryList* kio_krarcProtocol::addNewDir(QString path){
+	UDSEntryList* dir;
+	
+	// check if the current dir exists
+	dir = dirDict.find(path);
+	if(dir != 0) return dir; // dir exists- return it !
+	
+	// set dir to the parent dir
+	dir = addNewDir(path.left(path.findRev("/",-2)+1));
+	
+	// add a new entry in the parent dir
+	QString name = path.mid(path.findRev("/",-2)+1);
+	name = name.left(name.length()-1);
+	
+	UDSEntry entry;
+	UDSAtom atom;
+	atom.m_uds = UDS_NAME;
+	atom.m_str = name;
+	entry.append(atom);
+	
+	mode_t mode = parsePermString("drwxr-xr-x");
+	
+	atom.m_uds = UDS_FILE_TYPE;
+	atom.m_long = mode & S_IFMT; // keep file type only
+	entry.append( atom );
+	
+	atom.m_uds = UDS_ACCESS;
+	atom.m_long = mode & 07777; // keep permissions only
+	entry.append( atom );
+	
+	atom.m_uds = UDS_SIZE;
+	atom.m_long = 0;
+	entry.append( atom );
+	
+	atom.m_uds = UDS_MODIFICATION_TIME;
+	atom.m_long = arcFile->time(UDS_MODIFICATION_TIME);
+	entry.append( atom );
+	
+	dir->append(entry);
+	
+	// create a new directory entry and add it..
+	dir = new UDSEntryList();
+	dirDict.insert(path,dir);
+	
+	return dir;
+}
+
+void kio_krarcProtocol::parseLine(int lineNo, QString line, QFile*) {
+	UDSEntryList* dir;
+	UDSEntry entry;
+	UDSAtom atom;
+	
+	QString owner        = QString::null;
+	QString group        = QString::null;
+	QString symlinkDest  = QString::null;
+	QString perm         = QString::null;
+	mode_t mode          = 0666;
+	size_t size          = 0;
+	time_t time          = ::time(0);
+	QString fullName     = QString::null;
+	
+	if(arcType == "zip"){
+		// permissions
+		perm = nextWord(line);
+		// ignore the next 2 fields
+		nextWord(line); nextWord(line);
+		// size
+		size = nextWord(line).toLong();
+		// ignore the next 2 fields
+		nextWord(line);nextWord(line);
+		// date & time
+		QString d = nextWord(line);
+		QDate qdate(d.mid(0,4).toInt(),d.mid(4,2).toInt(),d.mid(6,2).toInt());
+		QTime qtime(d.mid(9,2).toInt(),d.mid(11,2).toInt(),d.mid(13,2).toInt());
+		time = QDateTime(qdate,qtime).toTime_t();
+		// full name
+		fullName = nextWord(line,'\n');
+		
+		if(perm.length() != 10) 
+			perm = (perm.at(0)=='d' || fullName.endsWith( "/" )) ? "drwxr-xr-x" : "-rw-r--r--" ;
+		mode = parsePermString(perm);
+	}
+	if(arcType == "rar") {
+		// full name
+		fullName = nextWord(line,'\n');
+		// size
+		size = nextWord(line).toLong();
+		// ignore the next 2 fields
+		nextWord(line); nextWord(line);
+		// date & time
+		QString d = nextWord(line);
+		int year = 1900 + d.mid(6,2).toInt();
+		if( year < 1930 ) year+=100;
+		QDate qdate( year, d.mid(3,2).toInt(), d.mid(0,2).toInt() );
+		QString t = nextWord(line);
+		QTime qtime(t.mid(0,2).toInt(),t.mid(3,2).toInt(),0);
+		time = QDateTime(qdate,qtime).toTime_t();    
+		// permissions
+		perm = nextWord(line);
+		
+		if( perm.length() == 7 ) // windows rar permission format
+		{
+			bool isDir  = ( perm.at(1).lower() == 'd' );
+			bool isReadOnly = ( perm.at(2).lower() == 'r' );
+			
+			perm = isDir ? "drwxr-xr-x" : "-rw-r--r--";
+			
+			if( isReadOnly )
+				perm.at( 2 ) = '-';
+		}        
+		
+		if(perm.length() != 10) perm = (perm.at(0)=='d')? "drwxr-xr-x" : "-rw-r--r--" ;    
+		mode = parsePermString(perm);
+	}
+	if(arcType == "arj"){
+		nextWord(line);
+		// full name
+		fullName = nextWord(line,'\n');
+		// ignore the next 2 fields
+		nextWord(line); nextWord(line);
+		// size
+		size = nextWord(line).toLong();
+		// ignore the next 2 fields
+		nextWord(line); nextWord(line);
+		// date & time
+		QString d = nextWord(line);
+		int year = 1900 + d.mid(0,2).toInt();
+		if( year < 1930 ) year+=100;
+		QDate qdate( year, d.mid(3,2).toInt(), d.mid(6,2).toInt() );
+		QString t = nextWord(line);
+		QTime qtime(t.mid(0,2).toInt(),t.mid(3,2).toInt(),0);
+		time = QDateTime(qdate,qtime).toTime_t();    
+		// permissions
+		perm = nextWord(line);
+		if(perm.length() != 10) perm = (perm.at(0)=='d')? "drwxr-xr-x" : "-rw-r--r--" ;
+		mode = parsePermString(perm);
+	}
+	if(arcType == "rpm"){
+		// full name
+		fullName = nextWord(line);
+		// size
+		size = nextWord(line).toULong();
+		// date & time
+		time = nextWord(line).toULong();
+		// next field is md5sum, ignore it
+		nextWord(line);
+		// permissions
+		mode = nextWord(line).toULong(0,8);
+		// Owner & Group
+		owner = nextWord(line);
+		group = nextWord(line);
+		// symlink destination
+		if( S_ISLNK(mode) ){
+			// ignore the next 3 fields
+			nextWord(line); nextWord(line); nextWord(line);
+			symlinkDest = nextWord(line);
+		}
+	}
+	if( arcType == "gzip" ){
+		if( !lineNo ) return; //ignore the first line
+		// first field is uncompressed size - ignore it
+		nextWord(line);
+		// size
+		size = nextWord(line).toULong();
+		// ignore the next field
+		nextWord(line);
+		// full name
+		fullName = nextWord(line);
+		fullName = fullName.mid(fullName.findRev("/")+1);
+	}
+	if( arcType == "bzip2" ){
+		// There is no way to list bzip2 files, so we take our information from
+		// the archive itself...
+		fullName = arcFile->name();
+		if( fullName.endsWith("bz2") ) fullName.truncate(fullName.length()-4);
+		mode = arcFile->mode();
+		size = arcFile->size();
+	}
+	if(arcType == "lha"){
+		// permissions
+		perm = nextWord(line);
+		if(perm.length() != 10) perm = (perm.at(0)=='d')? "drwxr-xr-x" : "-rw-r--r--" ;
+		mode = parsePermString(perm);
+		// ignore the next field
+		nextWord(line);
+		// size
+		size = nextWord(line).toLong();
+		// ignore the next field
+		nextWord(line);
+		// date & time
+		int month = (QStringList::split(',', "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec")).findIndex( nextWord(line) ) + 1;
+		int day = nextWord(line).toInt();
+		int year = QDate::currentDate().year();
+		QString third = nextWord(line);
+		QTime qtime;
+		
+		if( third.contains(":" ) )
+			qtime = QTime::fromString( third );
+		else
+			year = third.toInt();
+		
+		QDate qdate(year, month, day );
+		
+		time = QDateTime(qdate, qtime).toTime_t();    
+		// full name
+		fullName = nextWord(line,'\n');
+	}
+	if(arcType == "ace"){
+		// date & time
+		QString d = nextWord(line);
+		int year = 1900 + d.mid(6,2).toInt();
+		if( year < 1930 ) year+=100;
+		QDate qdate( year, d.mid(3,2).toInt(), d.mid(0,2).toInt() );
+		QString t = nextWord(line);
+		QTime qtime(t.mid(0,2).toInt(),t.mid(3,2).toInt(),0);
+		time = QDateTime(qdate,qtime).toTime_t();    
+		// ignore the next field
+		nextWord(line);
+		// size
+		size = nextWord(line).toLong();
+		// ignore the next field
+		nextWord(line);
+		// full name
+		fullName = nextWord(line,'\n');
+		if( fullName[ 0 ] == '*' ) // encrypted archives starts with '*'
+			fullName = fullName.mid( 1 );
+	}
+	if( arcType == "deb" ){
+		// permissions
+		perm = nextWord( line );
+		mode = parsePermString( perm );
+		// Owner & Group
+		owner = nextWord( line,'/' );
+		group = nextWord( line ).mid(1);
+		// size
+		size = nextWord( line ).toLong();
+		// date & time
+		QString d = nextWord( line );
+		QDate qdate( d.mid( 0, 4 ).toInt(), d.mid( 5, 2 ).toInt(), d.mid( 8, 2 ).toInt() );
+		QString t = nextWord( line );
+		QTime qtime( t.mid( 0, 2 ).toInt(), t.mid( 3, 2 ).toInt(), 0 );
+		time = QDateTime( qdate, qtime ).toTime_t();
+		// full name
+		fullName = nextWord( line, '\n' ).mid( 1 );
+		//if ( fullName.right( 1 ) == "/" ) return;
+		if( fullName.contains("->") ){
+			symlinkDest = fullName.mid(fullName.find("->")+2);
+			fullName = fullName.left(fullName.find("->")-1);
+		}
+	}
+	if(arcType == "7z"){
+		// date & time
+		QString d = nextWord(line);
+		QDate qdate( d.mid(0,4).toInt(), d.mid(5,2).toInt(), d.mid(8,2).toInt() );
+		QString t = nextWord(line);
+		QTime qtime(t.mid(0,2).toInt(),t.mid(3,2).toInt(),t.mid(6,2).toInt() );
+		time = QDateTime(qdate,qtime).toTime_t();
+		
+		// permissions
+		perm = nextWord(line);
+		bool isDir  = ( perm.at(0).lower() == 'd' );
+		bool isReadOnly = ( perm.at(1).lower() == 'r' );
+		perm = isDir ? "drwxr-xr-x" : "-rw-r--r--";
+		if( isReadOnly )
+			perm.at( 2 ) = '-';
+		
+		mode = parsePermString(perm);
+		
+		// size
+		size = nextWord(line).toLong();
+		
+		// ignore the next 15 characters
+		line = line.mid( 15 );
+		
+		// full name
+		fullName = nextWord(line,'\n');
+	}
+
+	if( fullName.right(1) == "/" ) fullName = fullName.left(fullName.length()-1);
+	if( !fullName.startsWith("/") ) fullName = "/"+fullName;
+	QString path = fullName.left(fullName.findRev("/")+1);
+	// set/create the directory UDSEntryList
+	dir = dirDict.find(path);
+	if(dir == 0) dir = addNewDir(path);
+	QString name = fullName.mid(fullName.findRev("/")+1);
+	// file name
+	atom.m_uds = UDS_NAME;
+	atom.m_str = name;
+	entry.append(atom);
+	// file type
+	atom.m_uds = UDS_FILE_TYPE;
+	atom.m_long = mode & S_IFMT; // keep file type only
+	entry.append( atom );
+	// file permissions
+	atom.m_uds = UDS_ACCESS;
+	atom.m_long = mode & 07777; // keep permissions only
+	entry.append( atom );
+	// file size
+	atom.m_uds = UDS_SIZE;
+	atom.m_long = size;
+	entry.append( atom );
+	// modification time
+	atom.m_uds = UDS_MODIFICATION_TIME;
+	atom.m_long = time;
+	entry.append( atom );
+	// link destination
+	if( !symlinkDest.isEmpty() ){
+		atom.m_uds = UDS_LINK_DEST;
+		atom.m_str = symlinkDest;
+		entry.append( atom );
+	}
+	if( S_ISDIR(mode) ){
+		fullName=fullName+"/";
+		if(dirDict.find(fullName) == 0)
+			dirDict.insert(fullName,new UDSEntryList());
+		else {
+			// try to overwrite an existing entry
+			UDSEntryList::iterator entryIt;
+			UDSEntry::iterator atomIt;
+			
+			for ( entryIt = dir->begin(); entryIt != dir->end(); ++entryIt )
+				for( atomIt = (*entryIt).begin(); atomIt != (*entryIt).end(); ++atomIt )
+					if( (*atomIt).m_uds == UDS_NAME )
+						if((*atomIt).m_str == name) {
+							for( atomIt = (*entryIt).begin(); atomIt != (*entryIt).end(); ++atomIt ) {
+								switch( (*atomIt).m_uds ) {
+								case UDS_MODIFICATION_TIME:
+									(*atomIt).m_long = time;
+									break;
+								case UDS_ACCESS:
+									(*atomIt).m_long = mode & 07777;
+									break;
+								}
+							}
+							return;
+						}
+			return; // there is alreay an entry for this directory
+		}
+	}
+	
+	// multi volume archives can add a file twice, use only one
+	UDSEntryList::iterator dirEntryIt;
+	UDSEntry::iterator dirAtomIt;
+	for ( dirEntryIt = dir->begin(); dirEntryIt != dir->end(); ++dirEntryIt )
+		for( dirAtomIt = (*dirEntryIt).begin(); dirAtomIt != (*dirEntryIt).end(); ++dirAtomIt )
+			if( (*dirAtomIt).m_uds == UDS_NAME && (*dirAtomIt).m_str == name )
+				return;
+	
+	dir->append(entry);
+}
+
+bool kio_krarcProtocol::initArcParameters() {
+	KRDEBUG("arcType: "<<arcType);
+	
+	if(arcType == "zip"){
+		cmd     = fullPathName( "unzip" );
+		listCmd = fullPathName( "unzip" ) + " -ZTs-z-t-h ";
+		getCmd  = fullPathName( "unzip" ) + " -p ";
+		copyCmd = fullPathName( "unzip" ) + " -jo ";
+		
+		if( KStandardDirs::findExe( "zip" ).isEmpty() ) {
+			delCmd  = QString::null;
+			putCmd  = QString::null;
+		} else {
+			delCmd  = fullPathName( "zip" ) + " -d ";
+			putCmd  = fullPathName( "zip" ) + " -ry ";
+		}
+		
+		if( !getPassword().isEmpty() ) {
+			getCmd += "-P '"+password+"' ";
+			copyCmd += "-P '"+password+"' ";
+			putCmd += "-P '"+password+"' ";
+		}
+	} else if (arcType == "rar") {
+		if( KStandardDirs::findExe( "rar" ).isEmpty() ) {
+			cmd     = fullPathName( "unrar" );
+			listCmd = fullPathName( "unrar" ) + " -c- -v v ";
+			getCmd  = fullPathName( "unrar" ) + " p -ierr -idp -c- -y ";
+			copyCmd = fullPathName( "unrar" ) + " e -y ";
+			delCmd  = QString::null;
+			putCmd  = QString::null;
+		} else {
+			cmd     = fullPathName( "rar" );
+			listCmd = fullPathName( "rar" ) + " -c- -v v ";
+			getCmd  = fullPathName( "rar" ) + " p -ierr -idp -c- -y ";
+			copyCmd = fullPathName( "rar" ) + " e -y ";
+			delCmd  = fullPathName( "rar" ) + " d ";
+			putCmd  = fullPathName( "rar" ) + " -r a ";
+		}
+		if( !getPassword().isEmpty() ) {
+			getCmd += "-p'"+password+"' ";
+			listCmd += "-p'"+password+"' ";
+			copyCmd += "-p'"+password+"' ";
+			if( !putCmd.isEmpty() ) {
+				putCmd += "-p'"+password+"' ";
+				delCmd += "-p'"+password+"' ";
+			}
+		}
+	} else if(arcType == "rpm") {
+		cmd     = fullPathName( "rpm" );
+		listCmd = fullPathName( "rpm" ) + " --dump -lpq ";
+		getCmd  = fullPathName( "cpio" ) + " --force-local --no-absolute-filenames -iuvdF";
+		delCmd  = QString::null;
+		putCmd  = QString::null;
+		copyCmd = QString::null;
+	} else if(arcType == "gzip") {
+		cmd     = fullPathName( "gzip" );
+		listCmd = fullPathName( "gzip" ) + " -l";
+		getCmd  = fullPathName( "gzip" ) + " -dc";
+		copyCmd = QString::null;
+		delCmd  = QString::null;
+		putCmd  = QString::null;
+	} else if(arcType == "bzip2") {
+		cmd     = fullPathName( "bzip2" );
+		listCmd = fullPathName( "bzip2" );
+		getCmd  = fullPathName( "bzip2" ) + " -dc";
+		copyCmd = QString::null;
+		delCmd  = QString::null;
+		putCmd  = QString::null;
+	} else if(arcType == "arj"){
+		cmd     = fullPathName( "arj" );
+		listCmd = fullPathName( "arj" ) + " v -y -v ";
+		getCmd  = fullPathName( "arj" ) + " -jyov -v e ";
+		copyCmd = fullPathName( "arj" ) + " -jyov -v e ";
+		delCmd  = fullPathName( "arj" ) + " d ";
+		putCmd  = fullPathName( "arj" ) + " -r a ";
+		if( !getPassword().isEmpty() ) {
+			getCmd += "-g'"+password+"' ";
+			copyCmd += "-g'"+password+"' ";
+			putCmd += "-g'"+password+"' ";
+		}
+	} else if(arcType == "lha") {
+		cmd     = fullPathName( "lha" );
+		listCmd = fullPathName( "lha" ) + " l ";
+		getCmd  = fullPathName( "lha" ) + " pq ";
+		copyCmd = fullPathName( "lha" ) + " eif ";
+		delCmd  = fullPathName( "lha" ) + " d ";
+		putCmd  = fullPathName( "lha" ) + " a ";
+	} else if(arcType == "ace") {
+		cmd     = fullPathName( "unace" );
+		listCmd = fullPathName( "unace" ) + " v";
+		getCmd  = fullPathName( "unace" ) + " e -o ";
+		copyCmd = fullPathName( "unace" ) + " e -o ";
+		delCmd  = QString::null;
+		putCmd  = QString::null;
+		if( !getPassword().isEmpty() ) {
+			getCmd += "-p'"+password+"' ";
+			copyCmd += "-p'"+password+"' ";
+		}
+	} else if ( arcType == "deb" ) {
+		cmd = fullPathName("dpkg");
+		listCmd = fullPathName("dpkg")+" -c";
+		getCmd = fullPathName("tar")+" xvf ";
+		copyCmd = QString::null;
+		delCmd = QString::null;
+		putCmd = QString::null;	
+	} else if (arcType == "7z") {
+		cmd = fullPathName( "7z" );
+		if( KStandardDirs::findExe(cmd).isEmpty() )
+			cmd = fullPathName( "7za" );
+		
+		listCmd = cmd + " l -y ";
+		getCmd  = cmd + " e -y ";
+		copyCmd = cmd + " e -y ";
+		delCmd  = cmd + " d -y ";
+		putCmd  = cmd + " a -y ";
+		if( !getPassword().isEmpty() ) {
+			getCmd += "-p'"+password+"' ";
+			listCmd += "-p'"+password+"' ";
+			copyCmd += "-p'"+password+"' ";
+			if( !putCmd.isEmpty() ) {
+				putCmd += "-p'"+password+"' ";
+				delCmd += "-p'"+password+"' ";
+			}
+		}
+	}
+	else {
+		cmd     = QString::null;
+		listCmd = QString::null;
+		getCmd  = QString::null;
+		copyCmd = QString::null;
+		delCmd  = QString::null;
+		putCmd  = QString::null;
+	}
+
+	if( KStandardDirs::findExe(cmd).isEmpty() ){
+		error( KIO::ERR_CANNOT_LAUNCH_PROCESS,
+		cmd+
+		i18n("\nMake sure that the %1 binary are installed properly on your system.").arg(cmd));
+		KRDEBUG("Failed to find cmd: " << cmd);
+		return false;
+	}
+	return true;
+}
+
+bool kio_krarcProtocol::checkStatus( int exitCode ) {
+	KRDEBUG( exitCode );
+	
+	if( arcType == "zip" || arcType == "rar" || arcType == "7z" )
+		return exitCode == 0 || exitCode == 1;
+	else if( arcType == "ace" || arcType == "bzip2" || arcType == "lha" || arcType == "rpm" || arcType == "arj" )
+		return exitCode == 0;
+	else if( arcType == "gzip" )
+		return exitCode == 0 || exitCode == 2;
+	else
+		return exitCode == 0;
+}
+
+struct AutoDetectParams {
+	QString type;
+	int location;
+	QString detectionString;
+};
+
+QString kio_krarcProtocol::detectArchive( bool &encrypted, QString fileName ) {
+	static AutoDetectParams autoDetectParams[] = {{"zip",  0, "PK\x03\x04"},
+	                                              {"rar",  0, "Rar!\x1a" },
+	                                              {"arj",  0, "\x60\xea" },
+	                                              {"rpm",  0, "\xed\xab\xee\xdb"},
+	                                              {"ace",  7, "**ACE**" },
+	                                              {"bzip2",0, "\x42\x5a\x68\x39\x31" },
+	                                              {"gzip", 0, "\x1f\x8b"},
+	                                              {"deb",  0, "!<arch>\ndebian-binary   " },
+	                                              {"7z",   0, "7z\xbc\xaf\x27\x1c" } };
+	static int autoDetectElems = sizeof( autoDetectParams ) / sizeof( AutoDetectParams );
+	
+	encrypted = false;
+	
+	QFile arcFile( fileName );
+	if ( arcFile.open( IO_ReadOnly ) ) {
+		char buffer[ 1024 ];
+		long sizeMax = arcFile.readBlock( buffer, sizeof( buffer ) );
+		arcFile.close();
+		
+		for( int i=0; i < autoDetectElems; i++ ) {
+			QString detectionString = autoDetectParams[ i ].detectionString;
+			int location = autoDetectParams[ i ].location;
+			
+			int endPtr = detectionString.length() + location;
+			if( endPtr > sizeMax )
+				continue;
+			
+			unsigned int j=0;
+			for(; j != detectionString.length(); j++ ) {
+				if( detectionString[ j ] == '?' )
+					continue;
+				if( buffer[ location + j ] != detectionString[ j ] )
+					break;
+			}
+			
+			if( j == detectionString.length() ) {
+				QString type = autoDetectParams[ i ].type;
+				if( type == "bzip2" || type == "gzip" ) {
+					KTar tapeArchive( fileName );
+					if( tapeArchive.open( IO_ReadOnly ) ) {
+						tapeArchive.close();
+						if( type == "bzip2" )
+							type = "tbz";
+						else
+							type = "tgz";
+					}
+				}
+				else if( type == "zip" )
+					encrypted = (buffer[6] & 1);
+				else if( type == "arj" ) {
+					if( sizeMax > 4 ) {
+						long headerSize = ((unsigned char *)buffer)[ 2 ] + 256*((unsigned char *)buffer)[ 3 ];
+						long fileHeader = headerSize + 10;
+						if( fileHeader + 9 < sizeMax && buffer[ fileHeader ] == (char)0x60 && buffer[ fileHeader + 1 ] == (char)0xea )
+							encrypted = (buffer[ fileHeader + 8 ] & 1 );
+					}
+				}
+				else if( type == "rar" ) {
+					if( sizeMax > 13 && buffer[ 9 ] == (char)0x73 ) {
+						if( buffer[ 10 ] & 0x80 ) { // the header is encrypted?
+							encrypted = true;
+						} else {
+							long offset = 7;
+							long mainHeaderSize = ((unsigned char *)buffer)[ offset+5 ] + 256*((unsigned char *)buffer)[ offset+6 ];
+							offset += mainHeaderSize;
+							while( offset + 10 < sizeMax ) {
+								long headerSize = ((unsigned char *)buffer)[ offset+5 ] + 256*((unsigned char *)buffer)[ offset+6 ];
+								bool isDir = (buffer[ offset+7 ] == '\0' ) && (buffer[ offset+8 ] == '\0' ) &&
+								             (buffer[ offset+9 ] == '\0' ) && (buffer[ offset+10 ] == '\0' );
+								             
+								if( buffer[ offset + 2 ] != (char)0x74 )
+									break;
+								if( !isDir ) {
+									encrypted = ( buffer[ offset + 3 ] & 4 ) != 0;
+									break;
+								}
+								offset += headerSize;
+							}
+						}
+					}
+				}
+				else if( type == "ace" ) {
+						long offset = 0;
+						long mainHeaderSize = ((unsigned char *)buffer)[ offset+2 ] + 256*((unsigned char *)buffer)[ offset+3 ] + 4;
+						offset += mainHeaderSize;
+						while( offset + 10 < sizeMax ) {
+							long headerSize = ((unsigned char *)buffer)[ offset+2 ] + 256*((unsigned char *)buffer)[ offset+3 ] + 4;
+							bool isDir = (buffer[ offset+11 ] == '\0' ) && (buffer[ offset+12 ] == '\0' ) &&
+							             (buffer[ offset+13 ] == '\0' ) && (buffer[ offset+14 ] == '\0' );
+							             
+							if( buffer[ offset + 4 ] != (char)0x01 )
+								break;
+							if( !isDir ) {
+								encrypted = ( buffer[ offset + 6 ] & 64 ) != 0;
+								break;
+							}
+							offset += headerSize;
+						}
+				}
+				else if( type == "7z" ) {
+					if( encryptedArchPath == fileName )
+						encrypted = true;
+					else {  // we try to find whether the 7z archive is encrypted
+						// this is hard as the headers are also compresseds
+						QString tester = fullPathName( "7z" );
+						if( KStandardDirs::findExe( tester ).isEmpty() ) {
+							tester = fullPathName( "7za" );
+							if( KStandardDirs::findExe( tester ).isEmpty() ) {
+								return type;
+							}
+						}
+						
+						QString testCmd = tester + " t -y ";
+						lastData = encryptedArchPath = "";
+						
+						KrShellProcess proc;
+						proc << testCmd << convertName( fileName );
+						connect( &proc, SIGNAL( receivedStdout(KProcess*,char*,int) ),
+						         this, SLOT( checkOutputForPassword( KProcess*,char*,int ) ) );
+						proc.start(KProcess::Block,KProcess::AllOutput);
+						encrypted = this->encrypted;
+						
+						if( encrypted )
+							encryptedArchPath = fileName;
+					}
+				}
+				return type;
+			}
+		}
+		
+		if( sizeMax >= 512 ) {
+			/* checking if it's a tar file */
+			unsigned checksum = 32*8;
+			char chksum[ 9 ];
+			for( int i=0; i != 512; i++ )
+				checksum += ((unsigned char *)buffer)[ i ];
+			for( int i=148; i != 156; i++ )
+				checksum -= ((unsigned char *)buffer)[ i ];
+			sprintf( chksum, "0%o", checksum );
+			if( !memcmp( buffer + 148, chksum, strlen( chksum ) ) ) {
+				int k = strlen( chksum );
+				for(; k < 8; k++ )
+					if( buffer[148+k] != 0 && buffer[148+k] != 32 )
+						break;
+				if( k==8 )
+					return "tar";
+			}
+		}
+	}
+	return QString::null;
+}
+
+void kio_krarcProtocol::checkOutputForPassword( KProcess *proc,char *buf,int len ) {
+	QByteArray d(len);
+	d.setRawData(buf,len);
+	QString data =  QString( d );
+	d.resetRawData(buf,len);
+	
+	QString checkable = lastData + data;
+	
+	QStringList lines = QStringList::split( '\n', checkable );
+	lastData = lines[ lines.count() - 1 ];
+	for( unsigned i=0; i != lines.count(); i++ ) {
+		QString line = lines[ i ].stripWhiteSpace().lower();
+		int ndx = line.find( "testing" );
+		if( ndx >=0 )
+			line.truncate( ndx );
+		if( line.isEmpty() )
+			continue;
+		
+		if( line.contains( "password" ) && line.contains( "enter" ) ) {
+			KRDEBUG( "Encrypted 7z archive found!" );
+			encrypted = true;
+			proc->kill();
+		}
+	}
+}
+
+void kio_krarcProtocol::invalidatePassword() {
+	KRDEBUG( arcFile->url().path(-1) + "/" );
+	
+	if( !encrypted )
+		return;
+	
+	KIO::AuthInfo authInfo;
+	authInfo.caption= i18n( "Krarc Password Dialog" );
+	authInfo.username= "archive";
+	authInfo.readOnly = true;
+	authInfo.keepPassword = true;
+	authInfo.verifyPath = true;
+	QString fileName = arcFile->url().path(-1);
+	authInfo.url = KURL::fromPathOrURL( "/" );
+	authInfo.url.setHost( fileName /*.replace('/','_')*/ );
+	authInfo.url.setProtocol( "krarc" );
+	
+	password = QString::null;
+	
+	cacheAuthentication( authInfo );
+}
+
+QString kio_krarcProtocol::getPassword() {
+	KRDEBUG( encrypted );
+	
+	if( !password.isNull() )
+		return password;
+	if( !encrypted )
+		return (password = "" );
+	
+	KIO::AuthInfo authInfo;
+	authInfo.caption= i18n( "Krarc Password Dialog" );
+	authInfo.username= "archive";
+	authInfo.readOnly = true;
+	authInfo.keepPassword = true;
+	authInfo.verifyPath = true;
+	QString fileName = arcFile->url().path(-1);
+	authInfo.url = KURL::fromPathOrURL( "/" );
+	authInfo.url.setHost( fileName /*.replace('/','_')*/ );
+	authInfo.url.setProtocol( "krarc" );
+	
+	if( checkCachedAuthentication( authInfo ) && !authInfo.password.isNull() ) {
+		KRDEBUG( authInfo.password );
+		return ( password = authInfo.password );
+	}
+	
+	authInfo.password = QString::null;
+	
+	if ( openPassDlg( authInfo, i18n("Accessing the file requires password.") ) && !authInfo.password.isNull() ) {
+		KRDEBUG( authInfo.password );
+		return ( password = authInfo.password );
+	}
+	
+	KRDEBUG( password );
+	return password;
+}
+
+QString kio_krarcProtocol::fullPathName( QString name ) {
+	QString supposedName = krConfig->readEntry( name, name );
+	if( supposedName.isEmpty() )
+		supposedName = name;
+	return escape( supposedName );
+}
+
+QString kio_krarcProtocol::convertFileName( QString name ) {
+	if( arcType == "zip" )
+		name = name.replace( "[", "[[]" );
+	return convertName( name );
+}
+
+QString kio_krarcProtocol::convertName( QString name ) {
+	if( !name.contains( '\'' ) )
+		return "'" + name + "'";
+	if( !name.contains( '"' ) && !name.contains( '$' ) )
+		return "\"" + name + "\"";
+	return escape( name );
+}
+
+QString kio_krarcProtocol::escape( QString name ) {    
+	const QString evilstuff = "\\\"'`()[]{}!?;$&<>| ";		// stuff that should get escaped
+	
+	for ( unsigned int i = 0; i < evilstuff.length(); ++i )
+		name.replace( evilstuff[ i ], ('\\' + evilstuff[ i ]) );
+	
+	return name;
+}
+
+#include "krarc.moc"