Diffstat (limited to 'microkde/kdecore/klibloader.cpp') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | microkde/kdecore/klibloader.cpp | 626 |
1 files changed, 626 insertions, 0 deletions
diff --git a/microkde/kdecore/klibloader.cpp b/microkde/kdecore/klibloader.cpp new file mode 100644 index 0000000..1410308 --- a/dev/null +++ b/microkde/kdecore/klibloader.cpp @@ -0,0 +1,626 @@ +/* This file is part of the KDE libraries + Copyright (C) 1999 Torben Weis <weis@kde.org> + Copyright (C) 2000 Michael Matz <matz@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License version 2 as published by the Free Software Foundation. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ +//US #include <config.h> +#include <qclipboard.h> +#include <qfile.h> +#include <qtimer.h> +#include <qobjectdict.h> +#include <qwidgetlist.h> +#include <qwidget.h> + +#include "kapplication.h" +#include "klibloader.h" +#include "kstandarddirs.h" +#include "kdebug.h" +#include "klocale.h" + +//US #include "ltdl.h" + +//US do everything through qlibrary +#ifndef DESKTOP_VERSION +#include <qpe/qpeapplication.h> +#include <qtopia/qlibrary.h> +#endif + +/*US +#ifdef Q_WS_X11 +#include <X11/Xlib.h> +#include <X11/Xatom.h> +#endif +*/ +template class QAsciiDict<KLibrary>; + +#include <stdlib.h> //getenv + +/*US +#if HAVE_DLFCN_H +# include <dlfcn.h> +#endif + +#ifdef RTLD_GLOBAL +# define LT_GLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_GLOBAL DL_GLOBAL +# endif +#endif +#ifndef LT_GLOBAL +# define LT_GLOBAL 0 +#endif +*/ + +/*US +extern "C" { +extern int lt_dlopen_flag; +} +*/ + +KLibFactory::KLibFactory( QObject* parent, const char* name ) + : QObject( parent, name ) +{ +} + +KLibFactory::~KLibFactory() +{ +// kdDebug(150) << "Deleting KLibFactory " << this << endl; +} + +QObject* KLibFactory::create( QObject* parent, const char* name, const char* classname, const QStringList &args ) +{ + QObject* obj = createObject( parent, name, classname, args ); + if ( obj ) + emit objectCreated( obj ); + return obj; +} + + +QObject* KLibFactory::createObject( QObject*, const char*, const char*, const QStringList &) +{ + return 0; +} + + +// ----------------------------------------------- + +//US KLibrary::KLibrary( const QString& libname, const QString& filename, void * handle ) +KLibrary::KLibrary( const QString& libname, const QString& filename, QLibrary* handle ) +{ + /* Make sure, we have a KLibLoader */ + (void) KLibLoader::self(); + m_libname = libname; + m_filename = filename; + m_handle = handle; + m_factory = 0; + m_timer = 0; +} + +KLibrary::~KLibrary() +{ +// kdDebug(150) << "Deleting KLibrary " << this << " " << m_libname << endl; + if ( m_timer && m_timer->isActive() ) + m_timer->stop(); + + // If any object is remaining, delete + if ( m_objs.count() > 0 ) + { + QPtrListIterator<QObject> it( m_objs ); + for ( ; it.current() ; ++it ) + { + kdDebug(150) << "Factory still has object " << it.current() << " " << it.current()->name () << " Library = " << m_libname << endl; + disconnect( it.current(), SIGNAL( destroyed() ), + this, SLOT( slotObjectDestroyed() ) ); + } + m_objs.setAutoDelete(true); + m_objs.clear(); + } + + if ( m_factory ) { +// kdDebug(150) << " ... deleting the factory " << m_factory << endl; + delete m_factory; + } +} + +QString KLibrary::name() const +{ + return m_libname; +} + +QString KLibrary::fileName() const +{ + return m_filename; +} + +KLibFactory* KLibrary::factory() +{ + if ( m_factory ) + return m_factory; + + QCString symname; + symname.sprintf("init_%s", name().latin1() ); + + void* sym = symbol( symname ); + if ( !sym ) + { + kdWarning(150) << "KLibrary: The library " << name() << " does not offer an init_" << name() << " function" << endl; + return 0; + } + + typedef KLibFactory* (*t_func)(); + t_func func = (t_func)sym; + m_factory = func(); + + if( !m_factory ) + { + kdWarning(150) << "KLibrary: The library " << name() << " does not offer a KDE compatible factory" << endl; + return 0; + } + + connect( m_factory, SIGNAL( objectCreated( QObject * ) ), + this, SLOT( slotObjectCreated( QObject * ) ) ); + + return m_factory; +} + +void* KLibrary::symbol( const char* symname ) const +{ +//US void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname ); + void* sym = m_handle->resolve( symname ); + if ( !sym ) + { +//US kdWarning(150) << "KLibrary: " << lt_dlerror() << endl; + kdWarning(150) << "KLibrary: " << m_libname << ", symbol:" << symname << " not found " << endl; + return 0; + } + + return sym; +} + +bool KLibrary::hasSymbol( const char* symname ) const +{ +//US void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname ); + void* sym = m_handle->resolve( symname ); + return (sym != 0L ); +} + +void KLibrary::unload() const +{ + if (KLibLoader::s_self) + KLibLoader::s_self->unloadLibrary(QFile::encodeName(name())); +} + +void KLibrary::slotObjectCreated( QObject *obj ) +{ + if ( !obj ) + return; + + if ( m_timer && m_timer->isActive() ) + m_timer->stop(); + + if ( m_objs.containsRef( obj ) ) + return; // we know this object already + + connect( obj, SIGNAL( destroyed() ), + this, SLOT( slotObjectDestroyed() ) ); + + m_objs.append( obj ); +} + +void KLibrary::slotObjectDestroyed() +{ + m_objs.removeRef( sender() ); + + if ( m_objs.count() == 0 ) + { +// kdDebug(150) << "KLibrary: shutdown timer for " << name() << " started!" +// << endl; + + if ( !m_timer ) + { + m_timer = new QTimer( this, "klibrary_shutdown_timer" ); + connect( m_timer, SIGNAL( timeout() ), + this, SLOT( slotTimeout() ) ); + } + + // as long as it's not stable make the timeout short, for debugging + // pleasure (matz) + //m_timer->start( 1000*60, true ); + m_timer->start( 1000*10, true ); + } +} + +void KLibrary::slotTimeout() +{ + if ( m_objs.count() != 0 ) + return; + + /* Don't go through KLibLoader::unloadLibrary(), because that uses the + ref counter, but this timeout means to unconditionally close this library + The destroyed() signal will take care to remove us from all lists. + */ + delete this; +} + +// ------------------------------------------------- + +/* This helper class is needed, because KLibraries can go away without + being unloaded. So we need some info about KLibraries even after its + death. */ +class KLibWrapPrivate +{ +public: +//US KLibWrapPrivate(KLibrary *l, lt_dlhandle h); + KLibWrapPrivate(KLibrary *l, QLibrary* h); + + KLibrary *lib; + enum {UNKNOWN, UNLOAD, DONT_UNLOAD} unload_mode; + int ref_count; +//US lt_dlhandle handle; + QLibrary *handle; + QString name; + QString filename; +}; + +//US KLibWrapPrivate::KLibWrapPrivate(KLibrary *l, lt_dlhandle h) +KLibWrapPrivate::KLibWrapPrivate(KLibrary *l, QLibrary* h) + : lib(l), ref_count(1), handle(h), name(l->name()), filename(l->fileName()) +{ + unload_mode = UNKNOWN; +/*US + if (lt_dlsym(handle, "__kde_do_not_unload") != 0) { +// kdDebug(150) << "Will not unload " << name << endl; + unload_mode = DONT_UNLOAD; + } else if (lt_dlsym(handle, "__kde_do_unload") != 0) { + unload_mode = UNLOAD; + } +*/ +//US use instead: + if (h->resolve("__kde_do_not_unload") != 0) { +// kdDebug(150) << "Will not unload " << name << endl; + unload_mode = DONT_UNLOAD; + } else if (h->resolve("__kde_do_unload") != 0) { + unload_mode = UNLOAD; + } +} + +class KLibLoaderPrivate +{ +public: + QPtrList<KLibWrapPrivate> loaded_stack; + QPtrList<KLibWrapPrivate> pending_close; + enum {UNKNOWN, UNLOAD, DONT_UNLOAD} unload_mode; + + QString errorMessage; +}; + +KLibLoader* KLibLoader::s_self = 0; + +KLibLoader* KLibLoader::self() +{ + if ( !s_self ) + s_self = new KLibLoader; + return s_self; +} + +void KLibLoader::cleanUp() +{ + if ( !s_self ) + return; + + delete s_self; + s_self = 0; +} + +KLibLoader::KLibLoader( QObject* parent, const char* name ) + : QObject( parent, name ) +{ + s_self = this; + d = new KLibLoaderPrivate; +//US lt_dlinit(); + d->unload_mode = KLibLoaderPrivate::UNKNOWN; + if (getenv("KDE_NOUNLOAD") != 0) + d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD; + else if (getenv("KDE_DOUNLOAD") != 0) + d->unload_mode = KLibLoaderPrivate::UNLOAD; + d->loaded_stack.setAutoDelete( true ); +} + +KLibLoader::~KLibLoader() +{ +// kdDebug(150) << "Deleting KLibLoader " << this << " " << name() << endl; + + QAsciiDictIterator<KLibWrapPrivate> it( m_libs ); + for (; it.current(); ++it ) + { + kdDebug(150) << "The KLibLoader contains the library " << it.current()->name + << " (" << it.current()->lib << ")" << endl; + d->pending_close.append(it.current()); + } + + close_pending(0); + + delete d; +} + +//static +QString KLibLoader::findLibrary( const char * name/*US , const KInstance * instance*/ ) +{ + QCString libname( name ); + + // only append ".la" if there is no extension + // this allows to load non-libtool libraries as well + // (mhk, 20000228) + int pos = libname.findRev('/'); + if (pos < 0) + pos = 0; + if (libname.find('.', pos) < 0) + libname += ".la"; + + // only look up the file if it is not an absolute filename + // (mhk, 20000228) + QString libfile; + if (libname[0] == '/') + libfile = libname; + else + { +//US libfile = instance->dirs()->findResource( "module", libname ); + libfile = KGlobal::dirs()->findResource( "module", libname ); + if ( libfile.isEmpty() ) + { +//US libfile = instance->dirs()->findResource( "lib", libname ); + libfile = KGlobal::dirs()->findResource( "lib", libname ); +#ifndef NDEBUG + if ( !libfile.isEmpty() && libname.left(3) == "lib" ) // don't warn for kdeinit modules + kdDebug(150) << "library " << libname << " not found under 'module' but under 'lib'" << endl; +#endif + } + if ( libfile.isEmpty() ) + { +#ifndef NDEBUG + kdDebug(150) << "library=" << libname << ": No file names " << libname.data() << " found in paths." << endl; +#endif + self()->d->errorMessage = i18n("Library files for \"%1\" not found in paths").arg(libname); + } + else + self()->d->errorMessage = QString::null; + } + return libfile; +} + + +KLibrary* KLibLoader::globalLibrary( const char *name ) +{ +KLibrary *tmp; +/*US +int olt_dlopen_flag = lt_dlopen_flag; + + lt_dlopen_flag |= LT_GLOBAL; + kdDebug(150) << "Loading the next library global with flag " + << lt_dlopen_flag + << "." << endl; +*/ + tmp = library(name); +/*US + lt_dlopen_flag = olt_dlopen_flag; +*/ +return tmp; +} + + +KLibrary* KLibLoader::library( const char *name ) +{ + if (!name) + return 0; + + KLibWrapPrivate* wrap = m_libs[name]; + if (wrap) { + /* Nothing to do to load the library. */ + wrap->ref_count++; + return wrap->lib; + } + + /* Test if this library was loaded at some time, but got + unloaded meanwhile, whithout being dlclose()'ed. */ + QPtrListIterator<KLibWrapPrivate> it(d->loaded_stack); + for (; it.current(); ++it) { + if (it.current()->name == name) + wrap = it.current(); + } + + if (wrap) { + d->pending_close.removeRef(wrap); + if (!wrap->lib) { + /* This lib only was in loaded_stack, but not in m_libs. */ + wrap->lib = new KLibrary( name, wrap->filename, wrap->handle ); + } + wrap->ref_count++; + } else { + QString libfile = findLibrary( name ); + if ( libfile.isEmpty() ) + return 0; + + const QString & qpeDir = QPEApplication::qpeDir(); + libfile = qpeDir + libfile; +//US QLibrary *lib = new QLibrary( qpeDir + "/plugins/korganizer/libopiekabc.so", QLibrary::Immediately ); + QLibrary *qlib = new QLibrary( libfile.latin1(), QLibrary::Immediately ); + +//US lt_dlhandle handle = lt_dlopen( libfile.latin1() ); +//US if ( !handle ) + if ( !qlib ) + { +//US const char* errmsg = lt_dlerror(); + char* errmsg; + sprintf(errmsg, "KLibLoader::library could not load library: %s", libfile.latin1()); + qDebug(errmsg); + + if(errmsg) + d->errorMessage = QString::fromLatin1(errmsg); + else + d->errorMessage = QString::null; + kdWarning(150) << "library=" << name << ": file=" << libfile << ": " << d->errorMessage << endl; + return 0; + } + else + d->errorMessage = QString::null; + + KLibrary *lib = new KLibrary( name, libfile, qlib ); + wrap = new KLibWrapPrivate(lib, qlib); + d->loaded_stack.prepend(wrap); + } + m_libs.insert( name, wrap ); + + connect( wrap->lib, SIGNAL( destroyed() ), + this, SLOT( slotLibraryDestroyed() ) ); + + return wrap->lib; +} + +QString KLibLoader::lastErrorMessage() const +{ + return d->errorMessage; +} + +void KLibLoader::unloadLibrary( const char *libname ) +{ + KLibWrapPrivate *wrap = m_libs[ libname ]; + if (!wrap) + return; + if (--wrap->ref_count) + return; + +// kdDebug(150) << "closing library " << libname << endl; + + m_libs.remove( libname ); + + disconnect( wrap->lib, SIGNAL( destroyed() ), + this, SLOT( slotLibraryDestroyed() ) ); + close_pending( wrap ); +} + +KLibFactory* KLibLoader::factory( const char* name ) +{ + KLibrary* lib = library( name ); + if ( !lib ) + return 0; + + return lib->factory(); +} + +void KLibLoader::slotLibraryDestroyed() +{ + const KLibrary *lib = static_cast<const KLibrary *>( sender() ); + + QAsciiDictIterator<KLibWrapPrivate> it( m_libs ); + for (; it.current(); ++it ) + if ( it.current()->lib == lib ) + { + KLibWrapPrivate *wrap = it.current(); + wrap->lib = 0; /* the KLibrary object is already away */ + m_libs.remove( it.currentKey() ); + close_pending( wrap ); + return; + } +} + +void KLibLoader::close_pending(KLibWrapPrivate *wrap) +{ + if (wrap && !d->pending_close.containsRef( wrap )) + d->pending_close.append( wrap ); + + /* First delete all KLibrary objects in pending_close, but _don't_ unload + the DSO behind it. */ + QPtrListIterator<KLibWrapPrivate> it(d->pending_close); + for (; it.current(); ++it) { + wrap = it.current(); + if (wrap->lib) { + disconnect( wrap->lib, SIGNAL( destroyed() ), + this, SLOT( slotLibraryDestroyed() ) ); + delete wrap->lib; + wrap->lib = 0; + } + } + + if (d->unload_mode == KLibLoaderPrivate::DONT_UNLOAD) return; + + bool deleted_one = false; + while ((wrap = d->loaded_stack.first())) { + /* Let's first see, if we want to try to unload this lib. + If the env. var KDE_DOUNLOAD is set, we try to unload every lib. + If not, we look at the lib itself, and unload it only, if it exports + the symbol __kde_do_unload. */ + if (d->unload_mode != KLibLoaderPrivate::UNLOAD + && wrap->unload_mode != KLibWrapPrivate::UNLOAD) + break; + + /* Now ensure, that the libs are only unloaded in the reverse direction + they were loaded. */ + if (!d->pending_close.containsRef( wrap )) { + if (!deleted_one) + /* Only diagnose, if we really haven't deleted anything. */ +// kdDebug(150) << "try to dlclose " << wrap->name << ": not yet" << endl; + break; + } + +// kdDebug(150) << "try to dlclose " << wrap->name << ": yes, done." << endl; + +#ifndef Q_WS_QWS + if ( !deleted_one ) { + /* Only do the hack once in this loop. + WABA: *HACK* + We need to make sure to clear the clipboard before unloading a DSO + because the DSO could have defined an object derived from QMimeSource + and placed that on the clipboard. */ + /*kapp->clipboard()->clear();*/ + + /* Well.. let's do something more subtle... convert the clipboard context + to text. That should be safe as it only uses objects defined by Qt. */ + + QWidgetList *widgetlist = QApplication::topLevelWidgets(); + QWidget *co = widgetlist->first(); + while (co) { + if (qstrcmp(co->name(), "internal clipboard owner") == 0) { + if (XGetSelectionOwner(co->x11Display(), XA_PRIMARY) == co->winId()) + kapp->clipboard()->setText(kapp->clipboard()->text()); + + break; + } + co = widgetlist->next(); + } + delete widgetlist; + } +#else + // FIXME(E): Implement in Qt Embedded +#endif + + deleted_one = true; +//US lt_dlclose(wrap->handle); + wrap->handle->unload(); + + d->pending_close.removeRef(wrap); + /* loaded_stack is AutoDelete, so wrap is freed */ + d->loaded_stack.remove(); + } +} + +void KLibLoader::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +void KLibFactory::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +//US #include "klibloader.moc" |