Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
smb4k/smb4k/core/smb4kcore.cpp

956 lignes
24 KiB

/***************************************************************************
smb4kcore - The main core class of Smb4K.
-------------------
begin : Do Apr 8 2004
copyright : (C) 2004-2007 by Alexander Reinholdt
email : dustpuppy@users.berlios.de
***************************************************************************/
/***************************************************************************
* 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. *
* *
* This program is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, *
* MA 02110-1301 USA *
***************************************************************************/
// TQt includes
#include <tqdir.h>
#include <tqmap.h>
#include <tqstringlist.h>
// KDE includes
#include <tdeversion.h>
#include <tdelocale.h>
#include <tdemessagebox.h>
#include <kurl.h>
#include <krun.h>
#include <tdeapplication.h>
#include <kpassivepopup.h>
#include <kdebug.h>
#include <kstaticdeleter.h>
#include <dcopclient.h>
// system includes
#include <stdlib.h>
// application specific includes
#include "smb4kcore.h"
#include "smb4kdefs.h"
#include "smb4kerror.h"
#include "smb4tdeglobal.h"
#include "smb4knetworkitems.h"
#include "smb4kshare.h"
#include "smb4ksambaoptionshandler.h"
#include "smb4ksettings.h"
using namespace Smb4TDEGlobal;
Smb4KCore *Smb4KCore::m_self = 0;
static KStaticDeleter<Smb4KCore> staticSmb4KCoreDeleter;
Smb4KCore::Smb4KCore() : TQObject()
{
// Set default values for settings that depend on the system
// Smb4K is running on:
setDefaultSettings();
// Search for the programs that are needed by Smb4K:
searchPrograms();
m_fileIO = new Smb4KFileIO( this, "CoreFileIO" );
m_scanner = new Smb4KScanner( &m_workgroups, &m_hosts, this, "CoreScanner" );
m_mounter = new Smb4KMounter( this, "CoreMounter" );
m_bookmarkHandler = new Smb4KBookmarkHandler( &m_hosts, this, "CoreBookmarkHandler" );
m_print = new Smb4KPrint( this, "CorePrinterHandler" );
m_synchronizer = new Smb4KSynchronizer( this, "CoreSynchronizer" );
m_previewer = new Smb4KPreviewer( this, "CorePreviewer" );
m_scanner_state = SCANNER_STOP;
m_mounter_state = MOUNTER_STOP;
m_print_state = PRINT_STOP;
m_syncer_state = SYNCHRONIZER_STOP;
m_previewer_state = PREVIEWER_STOP;
// Connections:
connect( m_scanner, TQT_SIGNAL( state( int ) ),
this, TQT_SLOT( slotSetScannerState( int ) ) );
connect( m_mounter, TQT_SIGNAL( state( int ) ),
this, TQT_SLOT( slotSetMounterState( int ) ) );
connect( m_print, TQT_SIGNAL( state( int ) ),
this, TQT_SLOT( slotSetPrinterHandlerState( int ) ) );
connect( m_synchronizer, TQT_SIGNAL( state( int ) ),
this, TQT_SLOT( slotSetSynchronizerState( int ) ) );
connect( m_previewer, TQT_SIGNAL( state( int ) ),
this, TQT_SLOT( slotSetSynchronizerState( int ) ) );
connect( kapp, TQT_SIGNAL( shutDown() ),
this, TQT_SLOT( slotShutdown() ) );
}
Smb4KCore::~Smb4KCore()
{
// Do not call abort() here. This will most likely lead
// to crashes.
// Clear the list of workgroups.
for ( TQValueList<Smb4KWorkgroupItem *>::Iterator it = m_workgroups.begin(); it != m_workgroups.end(); ++it )
{
delete *it;
}
m_workgroups.clear();
// Clear the list of hosts.
for ( TQValueList<Smb4KHostItem *>::Iterator it = m_hosts.begin(); it != m_hosts.end(); ++it )
{
delete *it;
}
m_hosts.clear();
if ( m_self == this )
{
staticSmb4KCoreDeleter.setObject( m_self, 0, false );
}
}
Smb4KCore *Smb4KCore::self()
{
if ( !m_self )
{
staticSmb4KCoreDeleter.setObject( m_self, new Smb4KCore() );
}
return m_self;
}
void Smb4KCore::init()
{
// Start the core.
m_scanner->init();
m_mounter->init();
}
/****************************************************************************
Returns a bool that tells the program whether a core process is running.
****************************************************************************/
bool Smb4KCore::isRunning()
{
if ( self()->m_scanner->isRunning() || self()->m_mounter->isRunning() ||
self()->m_print->isRunning() || self()->m_synchronizer->isRunning() ||
self()->m_previewer->isRunning() )
{
return true;
}
else
{
return false;
}
}
/****************************************************************************
Sets the current state of the core.
****************************************************************************/
void Smb4KCore::setCurrentState( int state )
{
if ( state != SCANNER_STOP && state != MOUNTER_STOP &&
state != PRINT_STOP && state != SYNCHRONIZER_STOP &&
state != PREVIEWER_STOP )
{
m_current_state = state;
}
else
{
if ( !m_scanner->isRunning() && !m_mounter->isRunning() &&
!m_print->isRunning() && !m_synchronizer->isRunning() &&
!m_previewer->isRunning() )
{
m_current_state = CORE_STOP;
}
else
{
if ( m_scanner->isRunning() )
{
m_current_state = m_scanner_state;
}
else if ( m_print->isRunning() )
{
m_current_state = m_print_state;
}
else if ( m_mounter->isRunning() )
{
m_current_state = m_mounter_state;
}
else if ( m_synchronizer->isRunning() )
{
m_current_state = m_syncer_state;
}
else if ( m_previewer->isRunning() )
{
m_current_state = m_previewer_state;
}
}
}
}
/****************************************************************************
Aborts any process of the core.
****************************************************************************/
void Smb4KCore::abort()
{
self()->m_scanner->abort();
self()->m_mounter->abort();
self()->m_print->abort();
self()->m_synchronizer->abort();
self()->m_previewer->abort();
}
/****************************************************************************
Opens the given URL.
****************************************************************************/
void Smb4KCore::open( Smb4KShare *share, int openWith )
{
if ( !share || share->isBroken() )
{
return;
}
#if TDE_VERSION_MAJOR == 3 && TDE_VERSION_MINOR <= 3 && TDE_VERSION_RELEASE <= 92
if ( TQString::compare( share->filesystem(), "cifs" ) == 0 )
{
if( KMessageBox::warningContinueCancel( (TQWidget *)this, i18n( "Up to KDE 3.3.x, TDEIO and Konqueror cannot handle CIFS shares. Konqueror will hang if you try to access it.\nDo you want to continue?" ) ) == KMessageBox::Cancel )
{
return;
}
}
#endif
switch ( openWith )
{
case Konqueror:
{
KURL url;
url.setPath( share->canonicalPath() );
(void) new KRun( url, 0, true, true );
break;
}
case Konsole:
{
if ( Smb4KSettings::konsole().isEmpty() )
{
Smb4KError::error( ERROR_COMMAND_NOT_FOUND, "konsole" );
}
else
{
KRun::runCommand( "konsole --workdir "+share->canonicalPath() );
}
break;
}
default:
{
break;
}
}
}
/****************************************************************************
Searches for the programs needed by Smb4K
****************************************************************************/
void Smb4KCore::searchPrograms()
{
// Remove the group "Programs" and reread the
// configuration:
Smb4KSettings::self()->config()->deleteGroup( "Programs" );
Smb4KSettings::self()->readConfig();
// List of paths that should be searched.
TQStringList path_list = TQStringList::split( ":", TQString( "%1" ).arg( getenv( "PATH" ) ), false );
if ( path_list.find( "/sbin" ) == path_list.end() )
{
path_list << "/sbin";
}
if ( path_list.find( "/usr/sbin" ) == path_list.end() )
{
path_list << "/usr/sbin";
}
if ( path_list.find( "/usr/local/sbin" ) == path_list.end() )
{
path_list << "/usr/local/sbin";
}
// Put all programs that are needed by Smb4K
// into the map below:
TQMap<TQString /*name*/, bool /*located*/> program_list;
TQMap<TQString /*name*/, TQString /*absolute path*/> program_paths;
// Mandatory programs:
program_list.insert( "grep", false );
program_list.insert( "awk", false );
program_list.insert( "sed", false );
program_list.insert( "xargs", false );
program_list.insert( "rmdir", false );
program_list.insert( "nmblookup", false );
program_list.insert( "smbclient", false );
program_list.insert( "smbspool", false );
program_list.insert( "net", false );
#ifndef __FreeBSD__
program_list.insert( "mount.cifs", false );
program_list.insert( "umount.cifs", false );
program_list.insert( "smbmount", false );
program_list.insert( "smbumount", false );
program_list.insert( "mount", false );
#else
program_list.insert( "mount_smbfs", false );
program_list.insert( "smbutil", false );
#endif
program_list.insert( "umount", false );
program_list.insert( "smb4k_mount", false );
program_list.insert( "smb4k_umount", false );
program_list.insert( "smb4k_kill", false );
program_list.insert( "smb4k_cat", false );
program_list.insert( "smb4k_mv", false );
// Optional programs
program_list.insert( "super", false );
program_list.insert( "sudo", false );
program_list.insert( "dvips", false );
program_list.insert( "enscript", false );
program_list.insert( "rsync", false );
program_list.insert( "konsole", false );
for ( TQStringList::ConstIterator it = path_list.begin(); it != path_list.end(); ++it )
{
TQDir::setCurrent( *it );
for ( TQMap<TQString, bool>::Iterator p = program_list.begin(); p != program_list.end(); ++p )
{
if ( p.data() == false ) // not located yet
{
if ( TQFile::exists( p.key() ) )
{
program_paths.insert( p.key(), TQDir::currentDirPath()+TQDir::separator()+p.key() );
program_list[ p.key() ] = true;
}
else
{
continue;
}
}
else
{
continue;
}
}
}
// Find out if Smb4K is to be starting up at all:
TQStringList missing;
if ( !program_list["grep"] )
{
missing.append( "grep" );
}
else
{
Smb4KSettings::self()->grepItem()->setDefaultValue( program_paths["grep"] );
if ( Smb4KSettings::grep().isEmpty() )
{
Smb4KSettings::self()->grepItem()->setDefault();
}
}
if ( !program_list["awk"] )
{
missing.append( "awk" );
}
else
{
Smb4KSettings::self()->awkItem()->setDefaultValue( program_paths["awk"] );
if ( Smb4KSettings::awk().isEmpty() )
{
Smb4KSettings::self()->awkItem()->setDefault();
}
}
if ( !program_list["sed"] )
{
missing.append( "sed" );
}
else
{
Smb4KSettings::self()->sedItem()->setDefaultValue( program_paths["sed"] );
if ( Smb4KSettings::sed().isEmpty() )
{
Smb4KSettings::self()->sedItem()->setDefault();
}
}
if ( !program_list["xargs"] )
{
missing.append( "xargs" );
}
else
{
Smb4KSettings::self()->xargsItem()->setDefaultValue( program_paths["xargs"] );
if ( Smb4KSettings::xargs().isEmpty() )
{
Smb4KSettings::self()->xargsItem()->setDefault();
}
}
if ( !program_list["rmdir"] )
{
missing.append( "rmdir" );
}
else
{
Smb4KSettings::self()->rmdirItem()->setDefaultValue( program_paths["rmdir"] );
if ( Smb4KSettings::rmdir().isEmpty() )
{
Smb4KSettings::self()->rmdirItem()->setDefault();
}
}
if ( !program_list["nmblookup"] )
{
missing.append( "nmblookup" );
}
else
{
Smb4KSettings::self()->nmblookupItem()->setDefaultValue( program_paths["nmblookup"] );
if ( Smb4KSettings::nmblookup().isEmpty() )
{
Smb4KSettings::self()->nmblookupItem()->setDefault();
}
}
if ( !program_list["smbclient"] )
{
missing.append( "smbclient" );
}
else
{
Smb4KSettings::self()->smbclientItem()->setDefaultValue( program_paths["smbclient"] );
if ( Smb4KSettings::smbclient().isEmpty() )
{
Smb4KSettings::self()->smbclientItem()->setDefault();
}
}
if ( !program_list["smbspool"] )
{
missing.append( "smbspool" );
}
else
{
Smb4KSettings::self()->smbspoolItem()->setDefaultValue( program_paths["smbspool"] );
if ( Smb4KSettings::smbspool().isEmpty() )
{
Smb4KSettings::self()->smbspoolItem()->setDefault();
}
}
if ( !program_list["net"] )
{
missing.append( "net" );
}
else
{
Smb4KSettings::self()->netItem()->setDefaultValue( program_paths["net"] );
if ( Smb4KSettings::net().isEmpty() )
{
Smb4KSettings::self()->netItem()->setDefault();
}
}
#ifndef __FreeBSD__
if ( !program_list["mount.cifs"] && !program_list["smbmount"] )
{
missing.append( "mount.cifs & smbmount" );
}
else
{
// One of the two programs is at least present, so we can do
// it like this:
TQString filesystem;
if ( program_list["mount.cifs"] )
{
Smb4KSettings::self()->mount_cifsItem()->setDefaultValue( program_paths["mount.cifs"] );
if ( Smb4KSettings::mount_cifs().isEmpty() )
{
Smb4KSettings::self()->mount_cifsItem()->setDefault();
}
}
else
{
Smb4KSettings::setFilesystem( Smb4KSettings::EnumFilesystem::SMBFS );
}
if ( program_list["smbmount"] )
{
Smb4KSettings::self()->smbmountItem()->setDefaultValue( program_paths["smbmount"] );
if ( Smb4KSettings::smbmount().isEmpty() )
{
Smb4KSettings::self()->smbmountItem()->setDefault();
}
}
else
{
Smb4KSettings::setFilesystem( Smb4KSettings::EnumFilesystem::CIFS );
}
}
if ( !program_list["umount.cifs"] && !program_list["smbumount"] )
{
missing.append( "umount.cifs & smbumount" );
}
else
{
// One of the two programs is at least present, so we can do
// it like this:
TQString filesystem;
if ( program_list["umount.cifs"] )
{
Smb4KSettings::self()->umount_cifsItem()->setDefaultValue( program_paths["umount.cifs"] );
if ( Smb4KSettings::umount_cifs().isEmpty() )
{
Smb4KSettings::self()->umount_cifsItem()->setDefault();
}
}
else
{
Smb4KSettings::setFilesystem( Smb4KSettings::EnumFilesystem::SMBFS );
}
if ( program_list["smbumount"] )
{
Smb4KSettings::self()->smbumountItem()->setDefaultValue( program_paths["smbumount"] );
if ( Smb4KSettings::smbumount().isEmpty() )
{
Smb4KSettings::self()->smbumountItem()->setDefault();
}
}
else
{
Smb4KSettings::setFilesystem( Smb4KSettings::EnumFilesystem::CIFS );
}
}
if ( !program_list["mount"] )
{
missing.append( "mount" );
}
else
{
Smb4KSettings::self()->mountItem()->setDefaultValue( program_paths["mount"] );
if ( Smb4KSettings::mount().isEmpty() )
{
Smb4KSettings::self()->mountItem()->setDefault();
}
}
#else
if ( !program_list["mount_smbfs"] )
{
missing.append( "mount_smbfs" );
}
else
{
Smb4KSettings::self()->mount_smbfsItem()->setDefaultValue( program_paths["mount_smbfs"] );
if ( Smb4KSettings::mount_smbfs().isEmpty() )
{
Smb4KSettings::self()->mount_smbfsItem()->setDefault();
}
}
if ( !program_list["smbutil"] )
{
missing.append( "smbutil" );
}
else
{
Smb4KSettings::self()->smbutilItem()->setDefaultValue( program_paths["smbutil"] );
if ( Smb4KSettings::smbutil().isEmpty() )
{
Smb4KSettings::self()->smbutilItem()->setDefault();
}
}
#endif
if ( !program_list["umount"] )
{
missing.append( "umount" );
}
else
{
Smb4KSettings::self()->umountItem()->setDefaultValue( program_paths["umount"] );
if ( Smb4KSettings::umount().isEmpty() )
{
Smb4KSettings::self()->umountItem()->setDefault();
}
}
if ( !program_list["smb4k_mount"] )
{
missing.append( "smb4k_mount" );
}
else
{
Smb4KSettings::self()->smb4k_mountItem()->setDefaultValue( program_paths["smb4k_mount"] );
if ( Smb4KSettings::smb4k_mount().isEmpty() )
{
Smb4KSettings::self()->smb4k_mountItem()->setDefault();
}
}
if ( !program_list["smb4k_umount"] )
{
missing.append( "smb4k_umount" );
}
else
{
Smb4KSettings::self()->smb4k_umountItem()->setDefaultValue( program_paths["smb4k_umount"] );
if ( Smb4KSettings::smb4k_umount().isEmpty() )
{
Smb4KSettings::self()->smb4k_umountItem()->setDefault();
}
}
if ( !program_list["smb4k_kill"] )
{
missing.append( "smb4k_kill" );
}
else
{
Smb4KSettings::self()->smb4k_killItem()->setDefaultValue( program_paths["smb4k_kill"] );
if ( Smb4KSettings::smb4k_kill().isEmpty() )
{
Smb4KSettings::self()->smb4k_killItem()->setDefault();
}
}
if ( !program_list["smb4k_cat"] )
{
missing.append( "smb4k_cat" );
}
else
{
Smb4KSettings::self()->smb4k_catItem()->setDefaultValue( program_paths["smb4k_cat"] );
if ( Smb4KSettings::smb4k_cat().isEmpty() )
{
Smb4KSettings::self()->smb4k_catItem()->setDefault();
}
}
if ( !program_list["smb4k_mv"] )
{
missing.append( "smb4k_mv" );
}
else
{
Smb4KSettings::self()->smb4k_mvItem()->setDefaultValue( program_paths["smb4k_mv"] );
if ( Smb4KSettings::smb4k_mv().isEmpty() )
{
Smb4KSettings::self()->smb4k_mvItem()->setDefault();
}
}
if ( !missing.isEmpty() )
{
// Error out if one of the mandatory programs is
// missing:
Smb4KError::error( ERROR_MISSING_PROGRAMS, missing.join( ", " ) );
exit( EXIT_FAILURE );
}
else
{
// Check for the optional programs:
if ( !program_list["super"] )
{
if ( (Smb4KSettings::useForceUnmount() ||
Smb4KSettings::alwaysUseSuperUser()) &&
Smb4KSettings::superUserProgram() ==
Smb4KSettings::EnumSuperUserProgram::Super )
{
Smb4KError::information( INFO_DISABLE_SUID_FEATURE, "super" );
// Reset the super user settings:
Smb4KSettings::self()->useForceUnmountItem()->setDefault();
Smb4KSettings::self()->alwaysUseSuperUserItem()->setDefault();
}
else
{
// Do nothing
}
}
else
{
Smb4KSettings::self()->superItem()->setDefaultValue( program_paths["super"] );
if ( Smb4KSettings::super().isEmpty() )
{
Smb4KSettings::self()->superItem()->setDefault();
}
}
if ( !program_list["sudo"] )
{
if ( (Smb4KSettings::useForceUnmount() ||
Smb4KSettings::alwaysUseSuperUser()) &&
Smb4KSettings::superUserProgram() ==
Smb4KSettings::EnumSuperUserProgram::Super )
{
Smb4KError::information( INFO_DISABLE_SUID_FEATURE, "sudo" );
// Reset the super user settings:
Smb4KSettings::self()->useForceUnmountItem()->setDefault();
Smb4KSettings::self()->alwaysUseSuperUserItem()->setDefault();
}
else
{
// Do nothing
}
}
else
{
Smb4KSettings::self()->sudoItem()->setDefaultValue( program_paths["sudo"] );
if ( Smb4KSettings::sudo().isEmpty() )
{
Smb4KSettings::self()->sudoItem()->setDefault();
}
}
if ( program_list["dvips"] )
{
Smb4KSettings::self()->dvipsItem()->setDefaultValue( program_paths["dvips"] );
if ( Smb4KSettings::dvips().isEmpty() )
{
Smb4KSettings::self()->dvipsItem()->setDefault();
}
}
if ( program_list["enscript"] )
{
Smb4KSettings::self()->enscriptItem()->setDefaultValue( program_paths["enscript"] );
if ( Smb4KSettings::enscript().isEmpty() )
{
Smb4KSettings::self()->enscriptItem()->setDefault();
}
}
if ( program_list["rsync"] )
{
Smb4KSettings::self()->rsyncItem()->setDefaultValue( program_paths["rsync"] );
if ( Smb4KSettings::rsync().isEmpty() )
{
Smb4KSettings::self()->rsyncItem()->setDefault();
}
}
if ( program_list["konsole"] )
{
Smb4KSettings::self()->konsoleItem()->setDefaultValue( program_paths["konsole"] );
if ( Smb4KSettings::konsole().isEmpty() )
{
Smb4KSettings::self()->konsoleItem()->setDefault();
}
}
// Write the configuration to disk:
Smb4KSettings::writeConfig();
}
}
void Smb4KCore::setDefaultSettings()
{
// Samba options that have to be dynamically imported from smb.conf:
TQMap<TQString, TQString> opts = optionsHandler()->globalSambaOptions();
if ( !opts["netbios name"].isEmpty() )
{
Smb4KSettings::self()->netBIOSNameItem()->setDefaultValue( opts["netbios name"] );
if ( Smb4KSettings::netBIOSName().isEmpty() )
{
Smb4KSettings::self()->netBIOSNameItem()->setDefault();
}
}
if ( !opts["workgroup"].isEmpty() )
{
Smb4KSettings::self()->domainNameItem()->setDefaultValue( opts["workgroup"] );
if ( Smb4KSettings::domainName().isEmpty() )
{
Smb4KSettings::self()->domainNameItem()->setDefault();
}
}
if ( !opts["socket options"].isEmpty() )
{
Smb4KSettings::self()->socketOptionsItem()->setDefaultValue( opts["socket options"] );
if ( Smb4KSettings::socketOptions().isEmpty() )
{
Smb4KSettings::self()->socketOptionsItem()->setDefault();
}
}
if ( !opts["netbios scope"].isEmpty() )
{
Smb4KSettings::self()->netBIOSScopeItem()->setDefaultValue( opts["netbios scope"] );
if ( Smb4KSettings::netBIOSScope().isEmpty() )
{
Smb4KSettings::self()->netBIOSScopeItem()->setDefault();
}
}
if ( !opts["name resolve order"].isEmpty() )
{
Smb4KSettings::self()->nameResolveOrderItem()->setDefaultValue( opts["name resolve order"] );
if ( Smb4KSettings::nameResolveOrder().isEmpty() )
{
Smb4KSettings::self()->nameResolveOrderItem()->setDefault();
}
}
if ( !opts["interfaces"].isEmpty() )
{
Smb4KSettings::self()->broadcastAddressItem()->setDefaultValue( opts["interfaces"] );
if ( Smb4KSettings::broadcastAddress().isEmpty() )
{
Smb4KSettings::self()->broadcastAddressItem()->setDefault();
}
}
}
/////////////////////////////////////////////////////////////////////////////
// TQT_SLOT IMPLEMENTATIONS
/////////////////////////////////////////////////////////////////////////////
void Smb4KCore::slotSetScannerState( int state )
{
m_scanner_state = state;
setCurrentState( state );
emit runStateChanged();
}
void Smb4KCore::slotSetMounterState( int state )
{
m_mounter_state = state;
setCurrentState( state );
emit runStateChanged();
}
void Smb4KCore::slotSetPrinterHandlerState( int state )
{
m_print_state = state;
setCurrentState( state );
emit runStateChanged();
}
void Smb4KCore::slotSetSynchronizerState( int state )
{
m_syncer_state = state;
setCurrentState( state );
emit runStateChanged();
}
void Smb4KCore::slotSetPreviewerState( int state )
{
m_previewer_state = state;
setCurrentState( state );
emit runStateChanged();
}
void Smb4KCore::slotShutdown()
{
Smb4KSettings::writeConfig();
}
#include "smb4kcore.moc"