src/core/na-module.c

   1 /*
   2  * Nautilus-Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <gmodule.h>
  36
  37 #include <api/na-core-utils.h>
  38
  39 #include "na-module.h"
  40
  41 /* private class data
  42  */
  43 struct _NAModuleClassPrivate {
  44         void *empty;                                            /* so that gcc -pedantic is happy */
  45 };
  46
  47 /* private instance data
  48  */
  49 struct _NAModulePrivate {
  50         gboolean  dispose_has_run;
  51         gchar    *path;                                         /* full pathname of the plugin */
  52         gchar    *name;                                         /* basename without the extension */
  53         GModule  *library;
  54         GList    *objects;
  55
  56         /* api
  57          */
  58         gboolean ( *startup )    ( GTypeModule *module );
  59         guint    ( *get_version )( void );
  60         gint     ( *list_types ) ( const GType **types );
  61         void     ( *shutdown )   ( void );
  62 };
  63
  64 static GTypeModuleClass *st_parent_class = NULL;
  65
  66 static GType     register_type( void );
  67 static void      class_init( NAModuleClass *klass );
  68 static void      instance_init( GTypeInstance *instance, gpointer klass );
  69 static void      instance_dispose( GObject *object );
  70 static void      instance_finalize( GObject *object );
  71
  72 static NAModule *module_new( const gchar *filename );
  73 static gboolean  on_module_load( GTypeModule *gmodule );
  74 static gboolean  is_a_na_plugin( NAModule *module );
  75 static gboolean  plugin_check( NAModule *module, const gchar *symbol, gpointer *pfn );
  76 static void      register_module_types( NAModule *module );
  77 static void      add_module_type( NAModule *module, GType type );
  78 static void      object_weak_notify( NAModule *module, GObject *object );
  79
  80 static void      on_module_unload( GTypeModule *gmodule );
  81
  82 GType
  83 na_module_get_type( void )
  84 {
  85         static GType object_type = 0;
  86
  87         if( !object_type ){
  88                 object_type = register_type();
  89         }
  90
  91         return( object_type );
  92 }
  93
  94 static GType
  95 register_type( void )
  96 {
  97         static const gchar *thisfn = "na_module_register_type";
  98         GType type;
  99
 100         static GTypeInfo info = {
 101                 sizeof( NAModuleClass ),
 102                 ( GBaseInitFunc ) NULL,
 103                 ( GBaseFinalizeFunc ) NULL,
 104                 ( GClassInitFunc ) class_init,
 105                 NULL,
 106                 NULL,
 107                 sizeof( NAModule ),
 108                 0,
 109                 ( GInstanceInitFunc ) instance_init
 110         };
 111
 112         g_debug( "%s", thisfn );
 113
 114         type = g_type_register_static( G_TYPE_TYPE_MODULE, "NAModule", &info, 0 );
 115
 116         return( type );
 117 }
 118
 119 static void
 120 class_init( NAModuleClass *klass )
 121 {
 122         static const gchar *thisfn = "na_module_class_init";
 123         GObjectClass *object_class;
 124         GTypeModuleClass *module_class;
 125
 126         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 127
 128         st_parent_class = g_type_class_peek_parent( klass );
 129
 130         object_class = G_OBJECT_CLASS( klass );
 131         object_class->dispose = instance_dispose;
 132         object_class->finalize = instance_finalize;
 133
 134         module_class = G_TYPE_MODULE_CLASS( klass );
 135         module_class->load = on_module_load;
 136         module_class->unload = on_module_unload;
 137
 138         klass->private = g_new0( NAModuleClassPrivate, 1 );
 139 }
 140
 141 static void
 142 instance_init( GTypeInstance *instance, gpointer klass )
 143 {
 144         static const gchar *thisfn = "na_module_instance_init";
 145         NAModule *self;
 146
 147         g_return_if_fail( NA_IS_MODULE( instance ));
 148
 149         g_debug( "%s: instance=%p (%s), klass=%p",
 150                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 151
 152         self = NA_MODULE( instance );
 153
 154         self->private = g_new0( NAModulePrivate, 1 );
 155
 156         self->private->dispose_has_run = FALSE;
 157 }
 158
 159 static void
 160 instance_dispose( GObject *object )
 161 {
 162         static const gchar *thisfn = "na_module_instance_dispose";
 163         NAModule *self;
 164
 165         g_return_if_fail( NA_IS_MODULE( object ));
 166
 167         self = NA_MODULE( object );
 168
 169         if( !self->private->dispose_has_run ){
 170
 171                 g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 172
 173                 self->private->dispose_has_run = TRUE;
 174
 175                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 176                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 177                 }
 178         }
 179 }
 180
 181 static void
 182 instance_finalize( GObject *object )
 183 {
 184         static const gchar *thisfn = "na_module_instance_finalize";
 185         NAModule *self;
 186
 187         g_return_if_fail( NA_IS_MODULE( object ));
 188
 189         g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 190
 191         self = NA_MODULE( object );
 192
 193         g_free( self->private->path );
 194         g_free( self->private->name );
 195
 196         g_free( self->private );
 197
 198         /* chain call to parent class */
 199         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 200                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 201         }
 202 }
 203
 204 /*
 205  * na_module_dump:
 206  * @module: this #NAModule instance.
 207  *
 208  * Dumps the content of the module.
 209  */
 210 void
 211 na_module_dump( const NAModule *module )
 212 {
 213         static const gchar *thisfn = "na_module_dump";
 214         GList *iobj;
 215
 216         g_debug( "%s:    path=%s", thisfn, module->private->path );
 217         g_debug( "%s:    name=%s", thisfn, module->private->name );
 218         g_debug( "%s: library=%p", thisfn, ( void * ) module->private->library );
 219         g_debug( "%s: objects=%p (count=%d)", thisfn, ( void * ) module->private->objects, g_list_length( module->private->objects ));
 220         for( iobj = module->private->objects ; iobj ; iobj = iobj->next ){
 221                 g_debug( "%s:    iobj=%p (%s)", thisfn, ( void * ) iobj->data, G_OBJECT_TYPE_NAME( iobj->data ));
 222         }
 223 }
 224
 225 /*
 226  * na_module_load_modules:
 227  *
 228  * Load availables dynamically loadable extension libraries (plugins).
 229  *
 230  * Returns: a #GList of #NAModule, each object representing a dynamically
 231  * loaded library. The list should be na_module_release_modules() by the
 232  * caller after use.
 233  */
 234 GList *
 235 na_module_load_modules( void )
 236 {
 237         static const gchar *thisfn = "na_module_load_modules";
 238         const gchar *dirname = PKGLIBDIR;
 239         const gchar *suffix = ".so";
 240         GList *modules;
 241         GDir *api_dir;
 242         GError *error;
 243         const gchar *entry;
 244         gchar *fname;
 245         NAModule *module;
 246
 247         g_debug( "%s", thisfn );
 248
 249         modules = NULL;
 250         error = NULL;
 251
 252         api_dir = g_dir_open( dirname, 0, &error );
 253         if( error ){
 254                 g_warning( "%s: g_dir_open: %s", thisfn, error->message );
 255                 g_error_free( error );
 256                 error = NULL;
 257
 258         } else {
 259                 while(( entry = g_dir_read_name( api_dir )) != NULL ){
 260                         if( g_str_has_suffix( entry, suffix )){
 261                                 fname = g_build_filename( dirname, entry, NULL );
 262                                 module = module_new( fname );
 263                                 if( module ){
 264                                         module->private->name = na_core_utils_str_remove_suffix( entry, suffix );
 265                                         modules = g_list_prepend( modules, module );
 266                                         g_debug( "%s: module %s successfully loaded", thisfn, entry );
 267                                 }
 268                                 g_free( fname );
 269                         }
 270                 }
 271                 g_dir_close( api_dir );
 272         }
 273
 274         return( modules );
 275 }
 276
 277 /*
 278  * @fname: full pathname of the being-loaded dynamic library.
 279  */
 280 static NAModule *
 281 module_new( const gchar *fname )
 282 {
 283         NAModule *module;
 284
 285         module = g_object_new( NA_MODULE_TYPE, NULL );
 286         module->private->path = g_strdup( fname );
 287
 288         if( !g_type_module_use( G_TYPE_MODULE( module )) || !is_a_na_plugin( module )){
 289                 g_object_unref( module );
 290                 return( NULL );
 291         }
 292
 293         register_module_types( module );
 294
 295         return( module );
 296 }
 297
 298 /*
 299  * triggered by GTypeModule base class when first loading the library,
 300  * which is itself triggered by module_new:g_type_module_use()
 301  *
 302  * returns: %TRUE if the module is successfully loaded
 303  */
 304 static gboolean
 305 on_module_load( GTypeModule *gmodule )
 306 {
 307         static const gchar *thisfn = "na_module_on_module_load";
 308         NAModule *module;
 309         gboolean loaded;
 310
 311         g_return_val_if_fail( G_IS_TYPE_MODULE( gmodule ), FALSE );
 312
 313         g_debug( "%s: gmodule=%p", thisfn, ( void * ) gmodule );
 314
 315         loaded = FALSE;
 316         module = NA_MODULE( gmodule );
 317
 318         module->private->library = g_module_open(
 319                         module->private->path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL );
 320
 321         if( !module->private->library ){
 322                 g_warning( "%s: g_module_open: path=%s, error=%s", thisfn, module->private->path, g_module_error());
 323
 324         } else {
 325                 loaded = TRUE;
 326         }
 327
 328         return( loaded );
 329 }
 330
 331 /*
 332  * the module has been successfully loaded
 333  * is it a Nautilus-Action plugin ?
 334  * if ok, we ask the plugin to initialize itself
 335  *
 336  * As of API v 1:
 337  * - na_extension_startup, na_extension_list_types and na_extension_shutdown
 338  *   are mandatory, and MUST be implemented by the plugin
 339  * - na_extension_get_version is optional, and defaults to 1.
 340  */
 341 static gboolean
 342 is_a_na_plugin( NAModule *module )
 343 {
 344         static const gchar *thisfn = "na_module_is_a_na_plugin";
 345         gboolean ok;
 346
 347         ok =
 348                 plugin_check( module, "na_extension_startup"    , ( gpointer * ) &module->private->startup) &&
 349                 plugin_check( module, "na_extension_list_types" , ( gpointer * ) &module->private->list_types ) &&
 350                 plugin_check( module, "na_extension_shutdown"   , ( gpointer * ) &module->private->shutdown ) &&
 351                 module->private->startup( G_TYPE_MODULE( module ));
 352
 353         if( ok ){
 354                 g_debug( "%s: %s: ok", thisfn, module->private->path );
 355         }
 356
 357         return( ok );
 358 }
 359
 360 static gboolean
 361 plugin_check( NAModule *module, const gchar *symbol, gpointer *pfn )
 362 {
 363         static const gchar *thisfn = "na_module_plugin_check";
 364         gboolean ok;
 365
 366         ok = g_module_symbol( module->private->library, symbol, pfn );
 367
 368         if( !ok || !pfn ){
 369                 g_debug("%s: %s: %s: symbol not found", thisfn, module->private->path, symbol );
 370         }
 371
 372         return( ok );
 373 }
 374
 375 /*
 376  * The 'na_extension_startup' function of the plugin has been already
 377  * called ; the GType types the plugin provides have so already been
 378  * registered in the GType system
 379  *
 380  * We ask here the plugin to give us a list of these GTypes.
 381  * For each GType, we allocate a new object of the given class
 382  * and keep this object in the module's list
 383  */
 384 static void
 385 register_module_types( NAModule *module )
 386 {
 387         const GType *types;
 388         guint count, i;
 389
 390         count = module->private->list_types( &types );
 391         module->private->objects = NULL;
 392
 393         for( i = 0 ; i < count ; i++ ){
 394                 if( types[i] ){
 395                         add_module_type( module, types[i] );
 396                 }
 397         }
 398 }
 399
 400 static void
 401 add_module_type( NAModule *module, GType type )
 402 {
 403         GObject *object;
 404
 405         object = g_object_new( type, NULL );
 406         g_debug( "na_module_add_module_type: allocating object=%p (%s)", ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 407
 408         g_object_weak_ref( object, ( GWeakNotify ) object_weak_notify, module );
 409
 410         module->private->objects = g_list_prepend( module->private->objects, object );
 411 }
 412
 413 static void
 414 object_weak_notify( NAModule *module, GObject *object )
 415 {
 416         static const gchar *thisfn = "na_module_object_weak_notify";
 417
 418         g_debug( "%s: module=%p, object=%p (%s)",
 419                         thisfn, ( void * ) module, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 420
 421         module->private->objects = g_list_remove( module->private->objects, object );
 422 }
 423
 424 /*
 425  * 'unload' is triggered by the last 'unuse' call
 426  * which is itself called in na_module::instance_dispose
 427  */
 428 static void
 429 on_module_unload( GTypeModule *gmodule )
 430 {
 431         static const gchar *thisfn = "na_module_on_module_unload";
 432         NAModule *module;
 433
 434         g_return_if_fail( G_IS_TYPE_MODULE( gmodule ));
 435
 436         g_debug( "%s: gmodule=%p", thisfn, ( void * ) gmodule );
 437
 438         module = NA_MODULE( gmodule );
 439
 440         if( module->private->shutdown ){
 441                 module->private->shutdown();
 442         }
 443
 444         if( module->private->library ){
 445                 g_module_close( module->private->library );
 446         }
 447
 448         module->private->startup = NULL;
 449         module->private->get_version = NULL;
 450         module->private->list_types = NULL;
 451         module->private->shutdown = NULL;
 452 }
 453
 454 /*
 455  * na_module_get_extensions_for_type:
 456  * @type: the serched GType.
 457  *
 458  * Returns: a list of loaded modules willing to deal with requested @type.
 459  *
 460  * The returned list should be na_module_free_extensions_list() by the caller.
 461  */
 462 GList *
 463 na_module_get_extensions_for_type( GList *modules, GType type )
 464 {
 465         GList *willing_to, *im, *io;
 466         NAModule *a_modul;
 467
 468         willing_to = NULL;
 469
 470         for( im = modules; im ; im = im->next ){
 471                 a_modul = NA_MODULE( im->data );
 472                 for( io = a_modul->private->objects ; io ; io = io->next ){
 473                         if( G_TYPE_CHECK_INSTANCE_TYPE( G_OBJECT( io->data ), type )){
 474                                 willing_to = g_list_prepend( willing_to, g_object_ref( io->data ));
 475                         }
 476                 }
 477         }
 478
 479         return( willing_to );
 480 }
 481
 482 /*
 483  * na_module_free_extensions_list:
 484  * @extensions: a #GList as returned by #na_module_get_extensions_for_type().
 485  *
 486  * Free the previously returned list.
 487  */
 488 void
 489 na_module_free_extensions_list( GList *extensions )
 490 {
 491         g_list_foreach( extensions, ( GFunc ) g_object_unref, NULL );
 492         g_list_free( extensions );
 493 }
 494
 495 /*
 496  * na_module_has_id:
 497  * @module: this #NAModule object.
 498  * @id: the searched id.
 499  *
 500  * Returns: %TRUE if one of the interfaces advertised by the module has
 501  * the given id, %FALSE else.
 502  */
 503 gboolean
 504 na_module_has_id( NAModule *module, const gchar *id )
 505 {
 506         gboolean id_ok;
 507         GList *iobj;
 508
 509         id_ok = FALSE;
 510         for( iobj = module->private->objects ; iobj && !id_ok ; iobj = iobj->next ){
 511                 g_debug( "na_module_has_id: object=%s", G_OBJECT_TYPE_NAME( iobj->data ));
 512         }
 513
 514         return( id_ok );
 515 }
 516
 517 /*
 518  * na_module_release_modules:
 519  * @modules: the list of loaded modules.
 520  *
 521  * Release resources allocated to the loaded modules on #NAPivot dispose.
 522  */
 523 void
 524 na_module_release_modules( GList *modules )
 525 {
 526         static const gchar *thisfn = "na_modules_release_modules";
 527         NAModule *module;
 528         GList *imod;
 529         GList *iobj;
 530
 531         g_debug( "%s: modules=%p (count=%d)", thisfn, ( void * ) modules, g_list_length( modules ));
 532
 533         for( imod = modules ; imod ; imod = imod->next ){
 534                 module = NA_MODULE( imod->data );
 535
 536                 for( iobj = module->private->objects ; iobj ; iobj = iobj->next ){
 537                         g_object_unref( iobj->data );
 538                 }
 539
 540                 g_type_module_unuse( G_TYPE_MODULE( module ));
 541         }
 542
 543         g_list_free( modules );
 544 }