klibloader.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 1999 Torben Weis <weis@kde.org>
00003    Copyright (C) 2000 Michael Matz <matz@kde.org>
00004 
00005    This library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Library General Public
00007    License version 2 as published by the Free Software Foundation.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017    Boston, MA 02110-1301, USA.
00018 */
00019 #include "config.h"
00020 
00021 #include <config.h>
00022 #include <qclipboard.h>
00023 #include <qfile.h>
00024 #include <qdir.h>
00025 #include <qtimer.h>
00026 #include <qobjectdict.h>
00027 
00028 #include "kapplication.h"
00029 #include "klibloader.h"
00030 #include "kstandarddirs.h"
00031 #include "kdebug.h"
00032 #include "klocale.h"
00033 
00034 #include "ltdl.h"
00035 
00036 template class QAsciiDict<KLibrary>;
00037 
00038 #include <stdlib.h> //getenv
00039 
00040 
00041 #if HAVE_DLFCN_H
00042 #  include <dlfcn.h>
00043 #endif
00044 
00045 #ifdef RTLD_GLOBAL
00046 #  define LT_GLOBAL             RTLD_GLOBAL
00047 #else
00048 #  ifdef DL_GLOBAL
00049 #    define LT_GLOBAL           DL_GLOBAL
00050 #  endif
00051 #endif /* !RTLD_GLOBAL */
00052 #ifndef LT_GLOBAL
00053 #  define LT_GLOBAL             0
00054 #endif /* !LT_GLOBAL */
00055 
00056 
00057 class KLibLoaderPrivate
00058 {
00059 public:
00060     QPtrList<KLibWrapPrivate> loaded_stack;
00061     QPtrList<KLibWrapPrivate> pending_close;
00062     enum {UNKNOWN, UNLOAD, DONT_UNLOAD} unload_mode;
00063 
00064     QString errorMessage;
00065 };
00066 
00067 KLibLoader* KLibLoader::s_self = 0;
00068 
00069 // -------------------------------------------------------------------------
00070 
00071 KLibFactory::KLibFactory( QObject* parent, const char* name )
00072     : QObject( parent, name )
00073 {
00074 }
00075 
00076 KLibFactory::~KLibFactory()
00077 {
00078 //    kdDebug(150) << "Deleting KLibFactory " << this << endl;
00079 }
00080 
00081 QObject* KLibFactory::create( QObject* parent, const char* name, const char* classname, const QStringList &args )
00082 {
00083     QObject* obj = createObject( parent, name, classname, args );
00084     if ( obj )
00085     emit objectCreated( obj );
00086     return obj;
00087 }
00088 
00089 
00090 QObject* KLibFactory::createObject( QObject*, const char*, const char*, const QStringList &)
00091 {
00092     return 0;
00093 }
00094 
00095 
00096 // -----------------------------------------------
00097 
00098 KLibrary::KLibrary( const QString& libname, const QString& filename, void * handle )
00099 {
00100     /* Make sure, we have a KLibLoader */
00101     (void) KLibLoader::self();
00102     m_libname = libname;
00103     m_filename = filename;
00104     m_handle = handle;
00105     m_factory = 0;
00106     m_timer = 0;
00107 }
00108 
00109 KLibrary::~KLibrary()
00110 {
00111 //    kdDebug(150) << "Deleting KLibrary " << this << "  " << m_libname << endl;
00112     if ( m_timer && m_timer->isActive() )
00113     m_timer->stop();
00114 
00115     // If any object is remaining, delete
00116     if ( m_objs.count() > 0 )
00117     {
00118         QPtrListIterator<QObject> it( m_objs );
00119         for ( ; it.current() ; ++it )
00120         {
00121             kdDebug(150) << "Factory still has object " << it.current() << " " << it.current()->name () << " Library = " << m_libname << endl;
00122             disconnect( it.current(), SIGNAL( destroyed() ),
00123                 this, SLOT( slotObjectDestroyed() ) );
00124         }
00125         m_objs.setAutoDelete(true);
00126         m_objs.clear();
00127     }
00128 
00129     if ( m_factory ) {
00130 //  kdDebug(150) << " ... deleting the factory " << m_factory << endl;
00131     delete m_factory;
00132         m_factory = 0L;
00133     }
00134 }
00135 
00136 QString KLibrary::name() const
00137 {
00138     return m_libname;
00139 }
00140 
00141 QString KLibrary::fileName() const
00142 {
00143     return m_filename;
00144 }
00145 
00146 KLibFactory* KLibrary::factory()
00147 {
00148     if ( m_factory )
00149         return m_factory;
00150 
00151     QCString symname;
00152     symname.sprintf("init_%s", name().latin1() );
00153 
00154     void* sym = symbol( symname );
00155     if ( !sym )
00156     {
00157         KLibLoader::self()->d->errorMessage = i18n( "The library %1 does not offer an %2 function." ).arg( name(), "init_" + name() );
00158         kdWarning(150) << KLibLoader::self()->d->errorMessage << endl;
00159         return 0;
00160     }
00161 
00162     typedef KLibFactory* (*t_func)();
00163     t_func func = (t_func)sym;
00164     m_factory = func();
00165 
00166     if( !m_factory )
00167     {
00168         KLibLoader::self()->d->errorMessage = i18n( "The library %1 does not offer a KDE compatible factory." ).arg( name() );
00169         kdWarning(150) << KLibLoader::self()->d->errorMessage << endl;
00170         return 0;
00171     }
00172 
00173     connect( m_factory, SIGNAL( objectCreated( QObject * ) ),
00174              this, SLOT( slotObjectCreated( QObject * ) ) );
00175 
00176     return m_factory;
00177 }
00178 
00179 void* KLibrary::symbol( const char* symname ) const
00180 {
00181     void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname );
00182     if ( !sym )
00183     {
00184         KLibLoader::self()->d->errorMessage = "KLibrary: " + QString::fromLocal8Bit( lt_dlerror() );
00185         kdWarning(150) << KLibLoader::self()->d->errorMessage << endl;
00186         return 0;
00187     }
00188 
00189     return sym;
00190 }
00191 
00192 bool KLibrary::hasSymbol( const char* symname ) const
00193 {
00194     void* sym = lt_dlsym( (lt_dlhandle) m_handle, symname );
00195     return (sym != 0L );
00196 }
00197 
00198 void KLibrary::unload() const
00199 {
00200    if (KLibLoader::s_self)
00201       KLibLoader::s_self->unloadLibrary(QFile::encodeName(name()));
00202 }
00203 
00204 void KLibrary::slotObjectCreated( QObject *obj )
00205 {
00206   if ( !obj )
00207     return;
00208 
00209   if ( m_timer && m_timer->isActive() )
00210     m_timer->stop();
00211 
00212   if ( m_objs.containsRef( obj ) )
00213       return; // we know this object already
00214 
00215   connect( obj, SIGNAL( destroyed() ),
00216            this, SLOT( slotObjectDestroyed() ) );
00217 
00218   m_objs.append( obj );
00219 }
00220 
00221 void KLibrary::slotObjectDestroyed()
00222 {
00223   m_objs.removeRef( sender() );
00224 
00225   if ( m_objs.count() == 0 )
00226   {
00227 //    kdDebug(150) << "KLibrary: shutdown timer for " << name() << " started!"
00228 //                 << endl;
00229 
00230     if ( !m_timer )
00231     {
00232       m_timer = new QTimer( this, "klibrary_shutdown_timer" );
00233       connect( m_timer, SIGNAL( timeout() ),
00234                this, SLOT( slotTimeout() ) );
00235     }
00236 
00237     // as long as it's not stable make the timeout short, for debugging
00238     // pleasure (matz)
00239     //m_timer->start( 1000*60, true );
00240     m_timer->start( 1000*10, true );
00241   }
00242 }
00243 
00244 void KLibrary::slotTimeout()
00245 {
00246   if ( m_objs.count() != 0 )
00247     return;
00248 
00249   /* Don't go through KLibLoader::unloadLibrary(), because that uses the
00250      ref counter, but this timeout means to unconditionally close this library
00251      The destroyed() signal will take care to remove us from all lists.
00252   */
00253   delete this;
00254 }
00255 
00256 // -------------------------------------------------
00257 
00258 /* This helper class is needed, because KLibraries can go away without
00259    being unloaded. So we need some info about KLibraries even after its
00260    death. */
00261 class KLibWrapPrivate
00262 {
00263 public:
00264     KLibWrapPrivate(KLibrary *l, lt_dlhandle h);
00265 
00266     KLibrary *lib;
00267     enum {UNKNOWN, UNLOAD, DONT_UNLOAD} unload_mode;
00268     int ref_count;
00269     lt_dlhandle handle;
00270     QString name;
00271     QString filename;
00272 };
00273 
00274 KLibWrapPrivate::KLibWrapPrivate(KLibrary *l, lt_dlhandle h)
00275  : lib(l), ref_count(1), handle(h), name(l->name()), filename(l->fileName())
00276 {
00277     unload_mode = UNKNOWN;
00278     if (lt_dlsym(handle, "__kde_do_not_unload") != 0) {
00279 //        kdDebug(150) << "Will not unload " << name << endl;
00280         unload_mode = DONT_UNLOAD;
00281     } else if (lt_dlsym(handle, "__kde_do_unload") != 0) {
00282         unload_mode = UNLOAD;
00283     }
00284 }
00285 
00286 KLibLoader* KLibLoader::self()
00287 {
00288     if ( !s_self )
00289         s_self = new KLibLoader;
00290     return s_self;
00291 }
00292 
00293 void KLibLoader::cleanUp()
00294 {
00295   if ( !s_self )
00296     return;
00297 
00298   delete s_self;
00299   s_self = 0L;
00300 }
00301 
00302 KLibLoader::KLibLoader( QObject* parent, const char* name )
00303     : QObject( parent, name )
00304 {
00305     s_self = this;
00306     d = new KLibLoaderPrivate;
00307     lt_dlinit();
00308     d->unload_mode = KLibLoaderPrivate::UNKNOWN;
00309     if (getenv("KDE_NOUNLOAD") != 0)
00310         d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
00311     else if (getenv("KDE_DOUNLOAD") != 0)
00312         d->unload_mode = KLibLoaderPrivate::UNLOAD;
00313     d->loaded_stack.setAutoDelete( true );
00314 }
00315 
00316 KLibLoader::~KLibLoader()
00317 {
00318 //    kdDebug(150) << "Deleting KLibLoader " << this << "  " << name() << endl;
00319 
00320     QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
00321     for (; it.current(); ++it )
00322     {
00323       kdDebug(150) << "The KLibLoader contains the library " << it.current()->name
00324         << " (" << it.current()->lib << ")" << endl;
00325       d->pending_close.append(it.current());
00326     }
00327 
00328     close_pending(0);
00329 
00330     delete d;
00331     d = 0L;
00332 }
00333 
00334 #include <boost/filesystem/exception.hpp>
00335 #include <boost/filesystem/operations.hpp>
00336 #include <boost/filesystem/path.hpp>
00337 #include <boost/regex.hpp>
00338 
00339 QCString makeSharedLibraryName( char const* name, QString const& dir )
00340 {
00341     try
00342     {
00343         boost::filesystem::path d( dir.ascii() );
00344         std::string p = d.string() + "/" + name + ".so";
00345         if ( boost::filesystem::exists( p ) )
00346             return p.c_str();
00347         boost::regex re( p + "\\..+", boost::regex::extended );
00348         for ( boost::filesystem::directory_iterator i( d );
00349             i != boost::filesystem::directory_iterator(); ++i )
00350         {
00351             boost::smatch m;
00352             if ( boost::regex_match( i->string(), m, re ) )
00353                 return m.str().c_str();
00354         }
00355     }
00356     catch ( boost::filesystem::filesystem_error const& )
00357     {
00358     }
00359     return QCString();
00360 }
00361 
00362 QString KLibLoader::findLibrary( const char * name, const KInstance * instance )
00363 {
00364     try
00365     {
00366         if ( boost::filesystem::exists( name ) )
00367             return name;
00368     }
00369     catch ( boost::filesystem::filesystem_error const& )
00370     {
00371     }
00372     QStringList dirs = instance->dirs()->resourceDirs( "module" );
00373     for ( QStringList::ConstIterator i = dirs.begin(); i != dirs.end(); ++i )
00374     {
00375         QCString p = makeSharedLibraryName( name, *i );
00376         if ( !p.isNull() )
00377             return p;
00378     }
00379     dirs = instance->dirs()->resourceDirs( "lib" );
00380     for ( QStringList::ConstIterator i = dirs.begin(); i != dirs.end(); ++i )
00381     {
00382         QCString p = makeSharedLibraryName( name, *i );
00383         if ( !p.isNull() )
00384             return p;
00385     }
00386     return QString::null;
00387 }
00388 
00389 
00390 KLibrary* KLibLoader::globalLibrary( const char *name )
00391 {
00392 KLibrary *tmp;
00393 int olt_dlopen_flag = lt_dlopen_flag;
00394 
00395    lt_dlopen_flag |= LT_GLOBAL;
00396    kdDebug(150) << "Loading the next library global with flag "
00397                 << lt_dlopen_flag
00398                 << "." << endl;
00399    tmp = library(name);
00400    lt_dlopen_flag = olt_dlopen_flag;
00401 
00402 return tmp;
00403 }
00404 
00405 
00406 KLibrary* KLibLoader::library( const char *name )
00407 {
00408     if (!name)
00409         return 0;
00410 
00411     KLibWrapPrivate* wrap = m_libs[name];
00412     if (wrap) {
00413       /* Nothing to do to load the library.  */
00414       wrap->ref_count++;
00415       return wrap->lib;
00416     }
00417 
00418     /* Test if this library was loaded at some time, but got
00419        unloaded meanwhile, whithout being dlclose()'ed.  */
00420     QPtrListIterator<KLibWrapPrivate> it(d->loaded_stack);
00421     for (; it.current(); ++it) {
00422       if (it.current()->name == name)
00423         wrap = it.current();
00424     }
00425 
00426     if (wrap) {
00427       d->pending_close.removeRef(wrap);
00428       if (!wrap->lib) {
00429         /* This lib only was in loaded_stack, but not in m_libs.  */
00430         wrap->lib = new KLibrary( name, wrap->filename, wrap->handle );
00431       }
00432       wrap->ref_count++;
00433     } else {
00434       QString libfile = findLibrary( name );
00435       if ( libfile.isEmpty() )
00436       {
00437         d->errorMessage = i18n("Library files for \"%1\" not found in paths.").arg(name);
00438         return 0;
00439       }
00440 
00441       lt_dlhandle handle = lt_dlopen( QFile::encodeName(libfile) );
00442       if ( !handle )
00443       {
00444         const char* errmsg = lt_dlerror();
00445         if(errmsg)
00446             d->errorMessage = QString::fromLocal8Bit(errmsg);
00447         else
00448             d->errorMessage = QString::null;
00449         return 0;
00450       }
00451       else
00452         d->errorMessage = QString::null;
00453 
00454       KLibrary *lib = new KLibrary( name, libfile, handle );
00455       wrap = new KLibWrapPrivate(lib, handle);
00456       d->loaded_stack.prepend(wrap);
00457     }
00458     m_libs.insert( name, wrap );
00459 
00460     connect( wrap->lib, SIGNAL( destroyed() ),
00461              this, SLOT( slotLibraryDestroyed() ) );
00462 
00463     return wrap->lib;
00464 }
00465 
00466 QString KLibLoader::lastErrorMessage() const
00467 {
00468     return d->errorMessage;
00469 }
00470 
00471 void KLibLoader::unloadLibrary( const char *libname )
00472 {
00473   KLibWrapPrivate *wrap = m_libs[ libname ];
00474   if (!wrap)
00475     return;
00476   if (--wrap->ref_count)
00477     return;
00478 
00479 //  kdDebug(150) << "closing library " << libname << endl;
00480 
00481   m_libs.remove( libname );
00482 
00483   disconnect( wrap->lib, SIGNAL( destroyed() ),
00484               this, SLOT( slotLibraryDestroyed() ) );
00485   close_pending( wrap );
00486 }
00487 
00488 KLibFactory* KLibLoader::factory( const char* name )
00489 {
00490     KLibrary* lib = library( name );
00491     if ( !lib )
00492         return 0;
00493 
00494     return lib->factory();
00495 }
00496 
00497 void KLibLoader::slotLibraryDestroyed()
00498 {
00499   const KLibrary *lib = static_cast<const KLibrary *>( sender() );
00500 
00501   QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
00502   for (; it.current(); ++it )
00503     if ( it.current()->lib == lib )
00504     {
00505       KLibWrapPrivate *wrap = it.current();
00506       wrap->lib = 0;  /* the KLibrary object is already away */
00507       m_libs.remove( it.currentKey() );
00508       close_pending( wrap );
00509       return;
00510     }
00511 }
00512 
00513 void KLibLoader::close_pending(KLibWrapPrivate *wrap)
00514 {
00515   if (wrap && !d->pending_close.containsRef( wrap ))
00516     d->pending_close.append( wrap );
00517 
00518   /* First delete all KLibrary objects in pending_close, but _don't_ unload
00519      the DSO behind it.  */
00520   QPtrListIterator<KLibWrapPrivate> it(d->pending_close);
00521   for (; it.current(); ++it) {
00522     wrap = it.current();
00523     if (wrap->lib) {
00524       disconnect( wrap->lib, SIGNAL( destroyed() ),
00525                   this, SLOT( slotLibraryDestroyed() ) );
00526       KLibrary* to_delete = wrap->lib;
00527       wrap->lib = 0L; // unset first, because KLibrary dtor can cause
00528       delete to_delete; // recursive call to close_pending()
00529     }
00530   }
00531 
00532   if (d->unload_mode == KLibLoaderPrivate::DONT_UNLOAD) {
00533     d->pending_close.clear();
00534     return;
00535   }
00536 
00537   bool deleted_one = false;
00538   while ((wrap = d->loaded_stack.first())) {
00539     /* Let's first see, if we want to try to unload this lib.
00540        If the env. var KDE_DOUNLOAD is set, we try to unload every lib.
00541        If not, we look at the lib itself, and unload it only, if it exports
00542        the symbol __kde_do_unload. */
00543     if (d->unload_mode != KLibLoaderPrivate::UNLOAD
00544         && wrap->unload_mode != KLibWrapPrivate::UNLOAD)
00545       break;
00546 
00547     /* Now ensure, that the libs are only unloaded in the reverse direction
00548        they were loaded.  */
00549     if (!d->pending_close.containsRef( wrap )) {
00550       if (!deleted_one)
00551         /* Only diagnose, if we really haven't deleted anything. */
00552 //        kdDebug(150) << "try to dlclose " << wrap->name << ": not yet" << endl;
00553       break;
00554     }
00555 
00556 //    kdDebug(150) << "try to dlclose " << wrap->name << ": yes, done." << endl;
00557 
00558     if ( !deleted_one ) {
00559       /* Only do the hack once in this loop.
00560          WABA: *HACK*
00561          We need to make sure to clear the clipboard before unloading a DSO
00562          because the DSO could have defined an object derived from QMimeSource
00563          and placed that on the clipboard. */
00564       /*kapp->clipboard()->clear();*/
00565 
00566       /* Well.. let's do something more subtle... convert the clipboard context
00567          to text. That should be safe as it only uses objects defined by Qt. */
00568       if( kapp->clipboard()->ownsSelection()) {
00569     kapp->clipboard()->setText(
00570             kapp->clipboard()->text( QClipboard::Selection ), QClipboard::Selection );
00571       }
00572       if( kapp->clipboard()->ownsClipboard()) {
00573     kapp->clipboard()->setText(
00574             kapp->clipboard()->text( QClipboard::Clipboard ), QClipboard::Clipboard );
00575       }
00576     }
00577 
00578     deleted_one = true;
00579     lt_dlclose(wrap->handle);
00580     d->pending_close.removeRef(wrap);
00581     /* loaded_stack is AutoDelete, so wrap is freed */
00582     d->loaded_stack.remove();
00583   }
00584 }
00585 
00586 void KLibLoader::virtual_hook( int, void* )
00587 { /*BASE::virtual_hook( id, data );*/ }
00588 
00589 void KLibFactory::virtual_hook( int, void* )
00590 { /*BASE::virtual_hook( id, data );*/ }
00591 
00592 #include "klibloader.moc"
KDE Home | KDE Accessibility Home | Description of Access Keys