libpurple/plugins.c

   1 /*
   2  * purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22 #include "internal.h"
  23
  24 #include "core.h"
  25 #include "debug.h"
  26 #include "dbus-maybe.h"
  27 #include "enums.h"
  28 #include "plugins.h"
  29
  30 #define PURPLE_PLUGIN_INFO_GET_PRIVATE(obj) \
  31         (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_PLUGIN_INFO, PurplePluginInfoPrivate))
  32
  33 typedef struct _PurplePluginInfoPrivate  PurplePluginInfoPrivate;
  34
  35 /**************************************************************************
  36  * Plugin info private data
  37  **************************************************************************/
  38 struct _PurplePluginInfoPrivate {
  39         char *ui_requirement;  /* ID of UI that is required to load the plugin */
  40         char *error;           /* Why a plugin is not loadable                 */
  41
  42         PurplePluginInfoFlags flags; /* Flags for the plugin */
  43
  44         /* Callback that returns a list of actions the plugin can perform */
  45         PurplePluginActionsCb actions_cb;
  46
  47         /* Callback that returns extra information about a plugin */
  48         PurplePluginExtraCb extra_cb;
  49
  50         /* Callback that returns a preferences frame for a plugin */
  51         PurplePluginPrefFrameCb pref_frame_cb;
  52
  53         /* Callback that returns a preferences request handle for a plugin */
  54         PurplePluginPrefRequestCb pref_request_cb;
  55
  56         /* TRUE if a plugin has been unloaded at least once. Auto-load
  57          * plugins that have been unloaded once will not be auto-loaded again. */
  58         gboolean unloaded;
  59 };
  60
  61 enum
  62 {
  63         PROP_0,
  64         PROP_UI_REQUIREMENT,
  65         PROP_ACTIONS_CB,
  66         PROP_EXTRA_CB,
  67         PROP_PREF_FRAME_CB,
  68         PROP_PREF_REQUEST_CB,
  69         PROP_FLAGS,
  70         PROP_LAST
  71 };
  72
  73 static GObjectClass *parent_class;
  74
  75 /**************************************************************************
  76  * Globals
  77  **************************************************************************/
  78 #ifdef PURPLE_PLUGINS
  79 static GList *loaded_plugins     = NULL;
  80 static GList *plugins_to_disable = NULL;
  81 #endif
  82
  83 /**************************************************************************
  84  * Plugin API
  85  **************************************************************************/
  86 #ifdef PURPLE_PLUGINS
  87 static gboolean
  88 plugin_loading_cb(GObject *manager, PurplePlugin *plugin, GError **error,
  89                   gpointer data)
  90 {
  91         PurplePluginInfo *info;
  92         PurplePluginInfoPrivate *priv;
  93
  94         g_return_val_if_fail(PURPLE_IS_PLUGIN(plugin), FALSE);
  95
  96         info = purple_plugin_get_info(plugin);
  97         if (!info)
  98                 return TRUE; /* a GPlugin internal plugin */
  99
 100         priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 101
 102         if (priv->error) {
 103                 purple_debug_error("plugins", "Failed to load plugin %s: %s",
 104                                            purple_plugin_get_filename(plugin), priv->error);
 105
 106                 g_set_error(error, PURPLE_PLUGINS_DOMAIN, 0,
 107                                     "Plugin is not loadable: %s", priv->error);
 108
 109                 return FALSE;
 110         }
 111
 112         return TRUE;
 113 }
 114
 115 static void
 116 plugin_loaded_cb(GObject *manager, PurplePlugin *plugin)
 117 {
 118         PurplePluginInfo *info;
 119
 120         g_return_if_fail(PURPLE_IS_PLUGIN(plugin));
 121
 122         info = purple_plugin_get_info(plugin);
 123         if (!info)
 124                 return; /* a GPlugin internal plugin */
 125
 126         loaded_plugins = g_list_prepend(loaded_plugins, plugin);
 127
 128         purple_debug_info("plugins", "Loaded plugin %s\n",
 129                           purple_plugin_get_filename(plugin));
 130
 131         purple_signal_emit(purple_plugins_get_handle(), "plugin-load", plugin);
 132 }
 133
 134 static gboolean
 135 plugin_unloading_cb(GObject *manager, PurplePlugin *plugin, GError **error,
 136                     gpointer data)
 137 {
 138         PurplePluginInfo *info;
 139
 140         g_return_val_if_fail(PURPLE_IS_PLUGIN(plugin), FALSE);
 141
 142         info = purple_plugin_get_info(plugin);
 143         if (info) {
 144                 purple_debug_info("plugins", "Unloading plugin %s\n",
 145                                   purple_plugin_get_filename(plugin));
 146         }
 147
 148         return TRUE;
 149 }
 150
 151 static void
 152 plugin_unloaded_cb(GObject *manager, PurplePlugin *plugin)
 153 {
 154         PurplePluginInfo *info;
 155         PurplePluginInfoPrivate *priv;
 156
 157         g_return_if_fail(PURPLE_IS_PLUGIN(plugin));
 158
 159         info = purple_plugin_get_info(plugin);
 160         if (!info)
 161                 return; /* a GPlugin internal plugin */
 162
 163         priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 164
 165         /* cancel any pending dialogs the plugin has */
 166         purple_request_close_with_handle(plugin);
 167         purple_notify_close_with_handle(plugin);
 168
 169         purple_signals_disconnect_by_handle(plugin);
 170         purple_signals_unregister_by_instance(plugin);
 171
 172         priv->unloaded = TRUE;
 173
 174         loaded_plugins     = g_list_remove(loaded_plugins, plugin);
 175         plugins_to_disable = g_list_remove(plugins_to_disable, plugin);
 176
 177         purple_signal_emit(purple_plugins_get_handle(), "plugin-unload", plugin);
 178
 179         purple_prefs_disconnect_by_handle(plugin);
 180 }
 181 #endif /* PURPLE_PLUGINS */
 182
 183 gboolean
 184 purple_plugin_load(PurplePlugin *plugin, GError **error)
 185 {
 186 #ifdef PURPLE_PLUGINS
 187         GError *err = NULL;
 188
 189         g_return_val_if_fail(plugin != NULL, FALSE);
 190
 191         if (purple_plugin_is_loaded(plugin))
 192                 return TRUE;
 193
 194         if (!gplugin_manager_load_plugin(plugin, &err)) {
 195                 purple_debug_error("plugins", "Failed to load plugin %s: %s",
 196                                 purple_plugin_get_filename(plugin),
 197                                 (err ? err->message : "Unknown reason"));
 198
 199                 if (error)
 200                         *error = g_error_copy(err);
 201                 g_error_free(err);
 202
 203                 return FALSE;
 204         }
 205
 206         return TRUE;
 207
 208 #else
 209         g_set_error(error, PURPLE_PLUGINS_DOMAIN, 0, "Plugin support is disabled.");
 210         return FALSE;
 211 #endif /* PURPLE_PLUGINS */
 212 }
 213
 214 gboolean
 215 purple_plugin_unload(PurplePlugin *plugin, GError **error)
 216 {
 217 #ifdef PURPLE_PLUGINS
 218         GError *err = NULL;
 219
 220         g_return_val_if_fail(plugin != NULL, FALSE);
 221
 222         if (!purple_plugin_is_loaded(plugin))
 223                 return TRUE;
 224
 225         if (!gplugin_manager_unload_plugin(plugin, &err)) {
 226                 purple_debug_error("plugins", "Failed to unload plugin %s: %s",
 227                                 purple_plugin_get_filename(plugin),
 228                                 (err ? err->message : "Unknown reason"));
 229
 230                 if (error)
 231                         *error = g_error_copy(err);
 232                 g_error_free(err);
 233
 234                 return FALSE;
 235         }
 236
 237         return TRUE;
 238
 239 #else
 240         g_set_error(error, PURPLE_PLUGINS_DOMAIN, 0, "Plugin support is disabled.");
 241         return FALSE;
 242 #endif /* PURPLE_PLUGINS */
 243 }
 244
 245 gboolean
 246 purple_plugin_is_loaded(const PurplePlugin *plugin)
 247 {
 248 #ifdef PURPLE_PLUGINS
 249         g_return_val_if_fail(plugin != NULL, FALSE);
 250
 251         return (gplugin_plugin_get_state(plugin) == GPLUGIN_PLUGIN_STATE_LOADED);
 252
 253 #else
 254         return FALSE;
 255 #endif
 256 }
 257
 258 const gchar *
 259 purple_plugin_get_filename(const PurplePlugin *plugin)
 260 {
 261 #ifdef PURPLE_PLUGINS
 262         g_return_val_if_fail(plugin != NULL, NULL);
 263
 264         return gplugin_plugin_get_filename(plugin);
 265
 266 #else
 267         return NULL;
 268 #endif
 269 }
 270
 271 PurplePluginInfo *
 272 purple_plugin_get_info(const PurplePlugin *plugin)
 273 {
 274 #ifdef PURPLE_PLUGINS
 275         GPluginPluginInfo *info;
 276
 277         g_return_val_if_fail(plugin != NULL, NULL);
 278
 279         info = gplugin_plugin_get_info(plugin);
 280
 281         /* GPlugin refs the plugin info object before returning it. This workaround
 282          * is to avoid managing the reference counts everywhere in our codebase
 283          * where we use the plugin info. The plugin info instance is guaranteed to
 284          * exist as long as the plugin exists. */
 285         g_object_unref(info);
 286
 287         if (PURPLE_IS_PLUGIN_INFO(info))
 288                 return PURPLE_PLUGIN_INFO(info);
 289         else
 290                 return NULL;
 291 #else
 292         return NULL;
 293 #endif
 294 }
 295
 296 void
 297 purple_plugin_disable(PurplePlugin *plugin)
 298 {
 299 #ifdef PURPLE_PLUGINS
 300         g_return_if_fail(plugin != NULL);
 301
 302         if (!g_list_find(plugins_to_disable, plugin))
 303                 plugins_to_disable = g_list_prepend(plugins_to_disable, plugin);
 304 #endif
 305 }
 306
 307 GType
 308 purple_plugin_register_type(PurplePlugin *plugin, GType parent,
 309                             const gchar *name, const GTypeInfo *info,
 310                             GTypeFlags flags)
 311 {
 312 #ifdef PURPLE_PLUGINS
 313         g_return_val_if_fail(GPLUGIN_IS_NATIVE_PLUGIN(plugin), G_TYPE_INVALID);
 314
 315         return gplugin_native_plugin_register_type(GPLUGIN_NATIVE_PLUGIN(plugin),
 316                                                    parent, name, info, flags);
 317
 318 #else
 319         return G_TYPE_INVALID;
 320 #endif
 321 }
 322
 323 void
 324 purple_plugin_add_interface(PurplePlugin *plugin, GType instance_type,
 325                             GType interface_type,
 326                             const GInterfaceInfo *interface_info)
 327 {
 328 #ifdef PURPLE_PLUGINS
 329         g_return_if_fail(GPLUGIN_IS_NATIVE_PLUGIN(plugin));
 330
 331         gplugin_native_plugin_add_interface(GPLUGIN_NATIVE_PLUGIN(plugin),
 332                                             instance_type, interface_type,
 333                                             interface_info);
 334 #endif
 335 }
 336
 337 gboolean
 338 purple_plugin_is_internal(const PurplePlugin *plugin)
 339 {
 340         PurplePluginInfo *info;
 341
 342         g_return_val_if_fail(plugin != NULL, FALSE);
 343
 344         info = purple_plugin_get_info(plugin);
 345         if (!info)
 346                 return TRUE;
 347
 348         return (purple_plugin_info_get_flags(info) &
 349                 PURPLE_PLUGIN_INFO_FLAGS_INTERNAL);
 350 }
 351
 352 GSList *
 353 purple_plugin_get_dependent_plugins(const PurplePlugin *plugin)
 354 {
 355 #warning TODO: Implement this when GPlugin can return dependent plugins.
 356
 357 #ifdef PURPLE_PLUGINS
 358         return NULL;
 359 #else
 360         return NULL;
 361 #endif
 362 }
 363
 364 /**************************************************************************
 365  * GObject code for PurplePluginInfo
 366  **************************************************************************/
 367 /* GObject initialization function */
 368 static void
 369 purple_plugin_info_init(GTypeInstance *instance, gpointer klass)
 370 {
 371         PURPLE_DBUS_REGISTER_POINTER(PURPLE_PLUGIN_INFO(instance), PurplePluginInfo);
 372 }
 373
 374 /* Set method for GObject properties */
 375 static void
 376 purple_plugin_info_set_property(GObject *obj, guint param_id, const GValue *value,
 377                 GParamSpec *pspec)
 378 {
 379         PurplePluginInfo *info = PURPLE_PLUGIN_INFO(obj);
 380         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 381
 382         switch (param_id) {
 383                 case PROP_UI_REQUIREMENT:
 384                         priv->ui_requirement = g_strdup(g_value_get_string(value));
 385                         break;
 386                 case PROP_ACTIONS_CB:
 387                         priv->actions_cb = g_value_get_pointer(value);
 388                         break;
 389                 case PROP_EXTRA_CB:
 390                         priv->extra_cb = g_value_get_pointer(value);
 391                         break;
 392                 case PROP_PREF_FRAME_CB:
 393                         priv->pref_frame_cb = g_value_get_pointer(value);
 394                         break;
 395                 case PROP_PREF_REQUEST_CB:
 396                         priv->pref_request_cb = g_value_get_pointer(value);
 397                         break;
 398                 case PROP_FLAGS:
 399                         priv->flags = g_value_get_flags(value);
 400                         break;
 401                 default:
 402                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 403                         break;
 404         }
 405 }
 406
 407 /* Get method for GObject properties */
 408 static void
 409 purple_plugin_info_get_property(GObject *obj, guint param_id, GValue *value,
 410                 GParamSpec *pspec)
 411 {
 412         PurplePluginInfo *info = PURPLE_PLUGIN_INFO(obj);
 413
 414         switch (param_id) {
 415                 case PROP_ACTIONS_CB:
 416                         g_value_set_pointer(value,
 417                                         purple_plugin_info_get_actions_cb(info));
 418                         break;
 419                 case PROP_EXTRA_CB:
 420                         g_value_set_pointer(value,
 421                                         purple_plugin_info_get_extra_cb(info));
 422                         break;
 423                 case PROP_PREF_FRAME_CB:
 424                         g_value_set_pointer(value,
 425                                         purple_plugin_info_get_pref_frame_cb(info));
 426                         break;
 427                 case PROP_PREF_REQUEST_CB:
 428                         g_value_set_pointer(value,
 429                                         purple_plugin_info_get_pref_request_cb(info));
 430                         break;
 431                 case PROP_FLAGS:
 432                         g_value_set_flags(value, purple_plugin_info_get_flags(info));
 433                         break;
 434                 default:
 435                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 436                         break;
 437         }
 438 }
 439
 440 /* Called when done constructing */
 441 static void
 442 purple_plugin_info_constructed(GObject *object)
 443 {
 444         PurplePluginInfo *info = PURPLE_PLUGIN_INFO(object);
 445         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 446         const char *id = purple_plugin_info_get_id(info);
 447         guint32 version;
 448
 449         parent_class->constructed(object);
 450
 451         if (id == NULL || *id == '\0')
 452                 priv->error = g_strdup(_("This plugin has not defined an ID."));
 453
 454         if (priv->ui_requirement && !purple_strequal(priv->ui_requirement, purple_core_get_ui()))
 455         {
 456                 priv->error = g_strdup_printf(_("You are using %s, but this plugin requires %s."),
 457                                 purple_core_get_ui(), priv->ui_requirement);
 458                 purple_debug_error("plugins", "%s is not loadable: The UI requirement is not met. (%s)\n",
 459                                 id, priv->error);
 460         }
 461
 462         version = purple_plugin_info_get_abi_version(info);
 463         if (PURPLE_PLUGIN_ABI_MAJOR_VERSION(version) != PURPLE_MAJOR_VERSION ||
 464                 PURPLE_PLUGIN_ABI_MINOR_VERSION(version) > PURPLE_MINOR_VERSION)
 465         {
 466                 priv->error = g_strdup_printf(_("Your libpurple version is %d.%d.x (need %d.%d.x)"),
 467                                 PURPLE_MAJOR_VERSION, PURPLE_MINOR_VERSION,
 468                                 PURPLE_PLUGIN_ABI_MAJOR_VERSION(version),
 469                                 PURPLE_PLUGIN_ABI_MINOR_VERSION(version));
 470                 purple_debug_error("plugins", "%s is not loadable: libpurple version is %d.%d.x (need %d.%d.x)\n",
 471                                 id, PURPLE_MAJOR_VERSION, PURPLE_MINOR_VERSION,
 472                                 PURPLE_PLUGIN_ABI_MAJOR_VERSION(version),
 473                                 PURPLE_PLUGIN_ABI_MINOR_VERSION(version));
 474         }
 475 }
 476
 477 /* GObject finalize function */
 478 static void
 479 purple_plugin_info_finalize(GObject *object)
 480 {
 481         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(object);
 482
 483         g_free(priv->ui_requirement);
 484         g_free(priv->error);
 485
 486         PURPLE_DBUS_UNREGISTER_POINTER(object);
 487
 488         parent_class->finalize(object);
 489 }
 490
 491 /* Class initializer function */
 492 static void purple_plugin_info_class_init(PurplePluginInfoClass *klass)
 493 {
 494         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 495
 496         parent_class = g_type_class_peek_parent(klass);
 497
 498         g_type_class_add_private(klass, sizeof(PurplePluginInfoPrivate));
 499
 500         obj_class->constructed = purple_plugin_info_constructed;
 501         obj_class->finalize    = purple_plugin_info_finalize;
 502
 503         /* Setup properties */
 504         obj_class->get_property = purple_plugin_info_get_property;
 505         obj_class->set_property = purple_plugin_info_set_property;
 506
 507         g_object_class_install_property(obj_class, PROP_UI_REQUIREMENT,
 508                 g_param_spec_string("ui-requirement",
 509                                   "UI Requirement",
 510                                   "ID of UI that is required by this plugin", NULL,
 511                                   G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
 512
 513         g_object_class_install_property(obj_class, PROP_ACTIONS_CB,
 514                 g_param_spec_pointer("actions-cb",
 515                                   "Plugin actions",
 516                                   "Callback that returns list of plugin's actions",
 517                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 518                                   G_PARAM_STATIC_STRINGS));
 519
 520         g_object_class_install_property(obj_class, PROP_EXTRA_CB,
 521                 g_param_spec_pointer("extra-cb",
 522                                   "Extra info callback",
 523                                   "Callback that returns extra info about the plugin",
 524                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 525                                   G_PARAM_STATIC_STRINGS));
 526
 527         g_object_class_install_property(obj_class, PROP_PREF_FRAME_CB,
 528                 g_param_spec_pointer("pref-frame-cb",
 529                                   "Preferences frame callback",
 530                                   "The callback that returns the preferences frame",
 531                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 532                                   G_PARAM_STATIC_STRINGS));
 533
 534         g_object_class_install_property(obj_class, PROP_PREF_REQUEST_CB,
 535                 g_param_spec_pointer("pref-request-cb",
 536                                   "Preferences request callback",
 537                                   "Callback that returns preferences request handle",
 538                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 539                                   G_PARAM_STATIC_STRINGS));
 540
 541         g_object_class_install_property(obj_class, PROP_FLAGS,
 542                 g_param_spec_flags("flags",
 543                                   "Plugin flags",
 544                                   "The flags for the plugin",
 545                                   PURPLE_TYPE_PLUGIN_INFO_FLAGS, 0,
 546                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 547                                   G_PARAM_STATIC_STRINGS));
 548 }
 549
 550 /**************************************************************************
 551  * PluginInfo API
 552  **************************************************************************/
 553 GType
 554 purple_plugin_info_get_type(void)
 555 {
 556         static GType type = 0;
 557
 558         if (G_UNLIKELY(type == 0)) {
 559                 static const GTypeInfo info = {
 560                         .class_size = sizeof(PurplePluginInfoClass),
 561                         .class_init = (GClassInitFunc)purple_plugin_info_class_init,
 562                         .instance_size = sizeof(PurplePluginInfo),
 563                         .instance_init = (GInstanceInitFunc)purple_plugin_info_init,
 564                 };
 565
 566                 type = g_type_register_static(
 567 #ifdef PURPLE_PLUGINS
 568                                               GPLUGIN_TYPE_PLUGIN_INFO,
 569 #else
 570                                               G_TYPE_OBJECT,
 571 #endif
 572                                               "PurplePluginInfo", &info, 0);
 573         }
 574
 575         return type;
 576 }
 577
 578 PurplePluginInfo *
 579 purple_plugin_info_new(const char *first_property, ...)
 580 {
 581         GObject *info;
 582         va_list var_args;
 583
 584         /* at least ID is required */
 585         if (!first_property)
 586                 return NULL;
 587
 588         va_start(var_args, first_property);
 589         info = g_object_new_valist(PURPLE_TYPE_PLUGIN_INFO, first_property,
 590                                    var_args);
 591         va_end(var_args);
 592
 593         return PURPLE_PLUGIN_INFO(info);
 594 }
 595
 596 const gchar *
 597 purple_plugin_info_get_id(const PurplePluginInfo *info)
 598 {
 599 #ifdef PURPLE_PLUGINS
 600         g_return_val_if_fail(info != NULL, NULL);
 601
 602         return gplugin_plugin_info_get_id(GPLUGIN_PLUGIN_INFO(info));
 603
 604 #else
 605         return NULL;
 606 #endif
 607 }
 608
 609 const gchar *
 610 purple_plugin_info_get_name(const PurplePluginInfo *info)
 611 {
 612 #ifdef PURPLE_PLUGINS
 613         g_return_val_if_fail(info != NULL, NULL);
 614
 615         return gplugin_plugin_info_get_name(GPLUGIN_PLUGIN_INFO(info));
 616
 617 #else
 618         return NULL;
 619 #endif
 620 }
 621
 622 const gchar *
 623 purple_plugin_info_get_version(const PurplePluginInfo *info)
 624 {
 625 #ifdef PURPLE_PLUGINS
 626         g_return_val_if_fail(info != NULL, NULL);
 627
 628         return gplugin_plugin_info_get_version(GPLUGIN_PLUGIN_INFO(info));
 629
 630 #else
 631         return NULL;
 632 #endif
 633 }
 634
 635 const gchar *
 636 purple_plugin_info_get_category(const PurplePluginInfo *info)
 637 {
 638 #ifdef PURPLE_PLUGINS
 639         g_return_val_if_fail(info != NULL, NULL);
 640
 641         return gplugin_plugin_info_get_category(GPLUGIN_PLUGIN_INFO(info));
 642
 643 #else
 644         return NULL;
 645 #endif
 646 }
 647
 648 const gchar *
 649 purple_plugin_info_get_summary(const PurplePluginInfo *info)
 650 {
 651 #ifdef PURPLE_PLUGINS
 652         g_return_val_if_fail(info != NULL, NULL);
 653
 654         return gplugin_plugin_info_get_summary(GPLUGIN_PLUGIN_INFO(info));
 655
 656 #else
 657         return NULL;
 658 #endif
 659 }
 660
 661 const gchar *
 662 purple_plugin_info_get_description(const PurplePluginInfo *info)
 663 {
 664 #ifdef PURPLE_PLUGINS
 665         g_return_val_if_fail(info != NULL, NULL);
 666
 667         return gplugin_plugin_info_get_description(GPLUGIN_PLUGIN_INFO(info));
 668
 669 #else
 670         return NULL;
 671 #endif
 672 }
 673
 674 const gchar * const *
 675 purple_plugin_info_get_authors(const PurplePluginInfo *info)
 676 {
 677 #ifdef PURPLE_PLUGINS
 678         g_return_val_if_fail(info != NULL, NULL);
 679
 680         return gplugin_plugin_info_get_authors(GPLUGIN_PLUGIN_INFO(info));
 681
 682 #else
 683         return NULL;
 684 #endif
 685 }
 686
 687 const gchar *
 688 purple_plugin_info_get_website(const PurplePluginInfo *info)
 689 {
 690 #ifdef PURPLE_PLUGINS
 691         g_return_val_if_fail(info != NULL, NULL);
 692
 693         return gplugin_plugin_info_get_website(GPLUGIN_PLUGIN_INFO(info));
 694
 695 #else
 696         return NULL;
 697 #endif
 698 }
 699
 700 const gchar *
 701 purple_plugin_info_get_icon(const PurplePluginInfo *info)
 702 {
 703 #ifdef PURPLE_PLUGINS
 704         g_return_val_if_fail(info != NULL, NULL);
 705
 706         return gplugin_plugin_info_get_icon(GPLUGIN_PLUGIN_INFO(info));
 707
 708 #else
 709         return NULL;
 710 #endif
 711 }
 712
 713 const gchar *
 714 purple_plugin_info_get_license_id(const PurplePluginInfo *info)
 715 {
 716 #ifdef PURPLE_PLUGINS
 717         g_return_val_if_fail(info != NULL, NULL);
 718
 719         return gplugin_plugin_info_get_license_id(GPLUGIN_PLUGIN_INFO(info));
 720
 721 #else
 722         return NULL;
 723 #endif
 724 }
 725
 726 const gchar *
 727 purple_plugin_info_get_license_text(const PurplePluginInfo *info)
 728 {
 729 #ifdef PURPLE_PLUGINS
 730         g_return_val_if_fail(info != NULL, NULL);
 731
 732         return gplugin_plugin_info_get_license_text(GPLUGIN_PLUGIN_INFO(info));
 733
 734 #else
 735         return NULL;
 736 #endif
 737 }
 738
 739 const gchar *
 740 purple_plugin_info_get_license_url(const PurplePluginInfo *info)
 741 {
 742 #ifdef PURPLE_PLUGINS
 743         g_return_val_if_fail(info != NULL, NULL);
 744
 745         return gplugin_plugin_info_get_license_url(GPLUGIN_PLUGIN_INFO(info));
 746
 747 #else
 748         return NULL;
 749 #endif
 750 }
 751
 752 const gchar * const *
 753 purple_plugin_info_get_dependencies(const PurplePluginInfo *info)
 754 {
 755 #ifdef PURPLE_PLUGINS
 756         g_return_val_if_fail(info != NULL, NULL);
 757
 758         return gplugin_plugin_info_get_dependencies(GPLUGIN_PLUGIN_INFO(info));
 759
 760 #else
 761         return NULL;
 762 #endif
 763 }
 764
 765 guint32
 766 purple_plugin_info_get_abi_version(const PurplePluginInfo *info)
 767 {
 768 #ifdef PURPLE_PLUGINS
 769         g_return_val_if_fail(info != NULL, 0);
 770
 771         return gplugin_plugin_info_get_abi_version(GPLUGIN_PLUGIN_INFO(info));
 772
 773 #else
 774         return 0;
 775 #endif
 776 }
 777
 778 PurplePluginActionsCb
 779 purple_plugin_info_get_actions_cb(const PurplePluginInfo *info)
 780 {
 781         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 782
 783         g_return_val_if_fail(priv != NULL, NULL);
 784
 785         return priv->actions_cb;
 786 }
 787
 788 PurplePluginExtraCb
 789 purple_plugin_info_get_extra_cb(const PurplePluginInfo *info)
 790 {
 791         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 792
 793         g_return_val_if_fail(priv != NULL, NULL);
 794
 795         return priv->extra_cb;
 796 }
 797
 798 PurplePluginPrefFrameCb
 799 purple_plugin_info_get_pref_frame_cb(const PurplePluginInfo *info)
 800 {
 801         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 802
 803         g_return_val_if_fail(priv != NULL, NULL);
 804
 805         return priv->pref_frame_cb;
 806 }
 807
 808 PurplePluginPrefRequestCb
 809 purple_plugin_info_get_pref_request_cb(const PurplePluginInfo *info)
 810 {
 811         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 812
 813         g_return_val_if_fail(priv != NULL, NULL);
 814
 815         return priv->pref_request_cb;
 816 }
 817
 818 PurplePluginInfoFlags
 819 purple_plugin_info_get_flags(const PurplePluginInfo *info)
 820 {
 821         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 822
 823         g_return_val_if_fail(priv != NULL, 0);
 824
 825         return priv->flags;
 826 }
 827
 828 const gchar *
 829 purple_plugin_info_get_error(const PurplePluginInfo *info)
 830 {
 831         PurplePluginInfoPrivate *priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 832
 833         g_return_val_if_fail(priv != NULL, NULL);
 834
 835         return priv->error;
 836 }
 837
 838 void
 839 purple_plugin_info_set_ui_data(PurplePluginInfo *info, gpointer ui_data)
 840 {
 841         g_return_if_fail(PURPLE_IS_PLUGIN_INFO(info));
 842
 843         info->ui_data = ui_data;
 844 }
 845
 846 gpointer
 847 purple_plugin_info_get_ui_data(const PurplePluginInfo *info)
 848 {
 849         g_return_val_if_fail(PURPLE_IS_PLUGIN_INFO(info), NULL);
 850
 851         return info->ui_data;
 852 }
 853
 854 /**************************************************************************
 855  * PluginAction API
 856  **************************************************************************/
 857 PurplePluginAction *
 858 purple_plugin_action_new(const char* label, PurplePluginActionCb callback)
 859 {
 860         PurplePluginAction *action;
 861
 862         g_return_val_if_fail(label != NULL && callback != NULL, NULL);
 863
 864         action = g_new0(PurplePluginAction, 1);
 865
 866         action->label    = g_strdup(label);
 867         action->callback = callback;
 868
 869         return action;
 870 }
 871
 872 void
 873 purple_plugin_action_free(PurplePluginAction *action)
 874 {
 875         g_return_if_fail(action != NULL);
 876
 877         g_free(action->label);
 878         g_free(action);
 879 }
 880
 881 static PurplePluginAction *
 882 purple_plugin_action_copy(PurplePluginAction *action)
 883 {
 884         g_return_val_if_fail(action != NULL, NULL);
 885
 886         return purple_plugin_action_new(action->label, action->callback);
 887 }
 888
 889 GType
 890 purple_plugin_action_get_type(void)
 891 {
 892         static GType type = 0;
 893
 894         if (G_UNLIKELY(type == 0)) {
 895                 type = g_boxed_type_register_static("PurplePluginAction",
 896                                 (GBoxedCopyFunc)purple_plugin_action_copy,
 897                                 (GBoxedFreeFunc)purple_plugin_action_free);
 898         }
 899
 900         return type;
 901 }
 902
 903 /**************************************************************************
 904  * Plugins API
 905  **************************************************************************/
 906 GList *
 907 purple_plugins_find_all(void)
 908 {
 909 #ifdef PURPLE_PLUGINS
 910         GList *ret = NULL, *ids, *l;
 911         GSList *plugins, *ll;
 912
 913         ids = gplugin_manager_list_plugins();
 914
 915         for (l = ids; l; l = l->next) {
 916                 plugins = gplugin_manager_find_plugins(l->data);
 917
 918                 for (ll = plugins; ll; ll = ll->next) {
 919                         PurplePlugin *plugin = PURPLE_PLUGIN(ll->data);
 920                         if (purple_plugin_get_info(plugin))
 921                                 ret = g_list_append(ret, plugin);
 922                 }
 923
 924                 gplugin_manager_free_plugin_list(plugins);
 925         }
 926         g_list_free(ids);
 927
 928         return ret;
 929
 930 #else
 931         return NULL;
 932 #endif
 933 }
 934
 935 GList *
 936 purple_plugins_get_loaded(void)
 937 {
 938 #ifdef PURPLE_PLUGINS
 939         return loaded_plugins;
 940 #else
 941         return NULL;
 942 #endif
 943 }
 944
 945 void
 946 purple_plugins_add_search_path(const gchar *path)
 947 {
 948 #ifdef PURPLE_PLUGINS
 949         gplugin_manager_append_path(path);
 950 #endif
 951 }
 952
 953 void
 954 purple_plugins_refresh(void)
 955 {
 956 #ifdef PURPLE_PLUGINS
 957         GList *plugins, *l;
 958
 959         gplugin_manager_refresh();
 960
 961         plugins = purple_plugins_find_all();
 962         for (l = plugins; l != NULL; l = l->next) {
 963                 PurplePlugin *plugin = PURPLE_PLUGIN(l->data);
 964                 PurplePluginInfo *info;
 965                 PurplePluginInfoPrivate *priv;
 966
 967                 if (purple_plugin_is_loaded(plugin))
 968                         continue;
 969
 970                 info = purple_plugin_get_info(plugin);
 971                 priv = PURPLE_PLUGIN_INFO_GET_PRIVATE(info);
 972
 973                 if (!priv->unloaded && purple_plugin_info_get_flags(info) &
 974                                 PURPLE_PLUGIN_INFO_FLAGS_AUTO_LOAD) {
 975                         purple_debug_info("plugins", "Auto-loading plugin %s\n",
 976                                           purple_plugin_get_filename(plugin));
 977                         purple_plugin_load(plugin, NULL);
 978                 }
 979         }
 980
 981         g_list_free(plugins);
 982 #endif
 983 }
 984
 985 PurplePlugin *
 986 purple_plugins_find_plugin(const gchar *id)
 987 {
 988 #ifdef PURPLE_PLUGINS
 989         PurplePlugin *plugin;
 990
 991         g_return_val_if_fail(id != NULL && *id != '\0', NULL);
 992
 993         plugin = gplugin_manager_find_plugin(id);
 994
 995         if (!plugin)
 996                 return NULL;
 997
 998         /* GPlugin refs the plugin object before returning it. This workaround is
 999          * to avoid managing the reference counts everywhere in our codebase where
1000          * we use plugin instances. A plugin object will exist till the plugins
1001          * subsystem is uninitialized. */
1002         g_object_unref(plugin);
1003
1004         return plugin;
1005
1006 #else
1007         return NULL;
1008 #endif
1009 }
1010
1011 PurplePlugin *
1012 purple_plugins_find_by_filename(const char *filename)
1013 {
1014         GList *plugins, *l;
1015
1016         g_return_val_if_fail(filename != NULL && *filename != '\0', NULL);
1017
1018         plugins = purple_plugins_find_all();
1019
1020         for (l = plugins; l != NULL; l = l->next) {
1021                 PurplePlugin *plugin = PURPLE_PLUGIN(l->data);
1022
1023                 if (purple_strequal(purple_plugin_get_filename(plugin), filename)) {
1024                         g_list_free(plugins);
1025                         return plugin;
1026                 }
1027         }
1028         g_list_free(plugins);
1029
1030         return NULL;
1031 }
1032
1033 void
1034 purple_plugins_save_loaded(const char *key)
1035 {
1036 #ifdef PURPLE_PLUGINS
1037         GList *pl;
1038         GList *files = NULL;
1039
1040         g_return_if_fail(key != NULL && *key != '\0');
1041
1042         for (pl = purple_plugins_get_loaded(); pl != NULL; pl = pl->next) {
1043                 PurplePlugin *plugin = PURPLE_PLUGIN(pl->data);
1044                 PurplePluginInfo *info = purple_plugin_get_info(plugin);
1045                 if (!info)
1046                         continue;
1047
1048                 if (purple_plugin_info_get_flags(info) &
1049                                 PURPLE_PLUGIN_INFO_FLAGS_AUTO_LOAD)
1050                         continue;
1051
1052                 if (!g_list_find(plugins_to_disable, plugin))
1053                         files = g_list_append(files, (gchar *)purple_plugin_get_filename(plugin));
1054         }
1055
1056         purple_prefs_set_path_list(key, files);
1057         g_list_free(files);
1058 #endif
1059 }
1060
1061 void
1062 purple_plugins_load_saved(const char *key)
1063 {
1064 #ifdef PURPLE_PLUGINS
1065         GList *l, *files;
1066
1067         g_return_if_fail(key != NULL && *key != '\0');
1068
1069         files = purple_prefs_get_path_list(key);
1070
1071         for (l = files; l; l = l->next)
1072         {
1073                 char *file;
1074                 PurplePlugin *plugin;
1075
1076                 if (l->data == NULL)
1077                         continue;
1078
1079                 file = l->data;
1080                 plugin = purple_plugins_find_by_filename(file);
1081
1082                 if (plugin) {
1083                         purple_debug_info("plugins", "Loading saved plugin %s\n", file);
1084                         purple_plugin_load(plugin, NULL);
1085                 } else {
1086                         purple_debug_error("plugins", "Unable to find saved plugin %s\n", file);
1087                 }
1088
1089                 g_free(l->data);
1090         }
1091
1092         g_list_free(files);
1093 #endif /* PURPLE_PLUGINS */
1094 }
1095
1096 /**************************************************************************
1097  * Plugins Subsystem API
1098  **************************************************************************/
1099 void *
1100 purple_plugins_get_handle(void)
1101 {
1102         static int handle;
1103
1104         return &handle;
1105 }
1106
1107 void
1108 purple_plugins_init(void)
1109 {
1110         void *handle = purple_plugins_get_handle();
1111 #ifdef PURPLE_PLUGINS
1112         const gchar *search_path;
1113 #endif
1114
1115         purple_signal_register(handle, "plugin-load",
1116                                purple_marshal_VOID__POINTER,
1117                                G_TYPE_NONE, 1, PURPLE_TYPE_PLUGIN);
1118         purple_signal_register(handle, "plugin-unload",
1119                                purple_marshal_VOID__POINTER,
1120                                G_TYPE_NONE, 1, PURPLE_TYPE_PLUGIN);
1121
1122 #ifdef PURPLE_PLUGINS
1123         gplugin_init();
1124
1125         search_path = g_getenv("PURPLE_PLUGIN_PATH");
1126         if (search_path) {
1127                 gchar **paths;
1128                 int i;
1129
1130                 paths = g_strsplit(search_path, G_SEARCHPATH_SEPARATOR_S, 0);
1131                 for (i = 0; paths[i]; ++i) {
1132                         purple_plugins_add_search_path(paths[i]);
1133                 }
1134
1135                 g_strfreev(paths);
1136         }
1137
1138         gplugin_manager_add_default_paths();
1139
1140         purple_plugins_add_search_path(PURPLE_LIBDIR);
1141
1142         g_signal_connect(gplugin_manager_get_instance(), "loading-plugin",
1143                          G_CALLBACK(plugin_loading_cb), NULL);
1144         g_signal_connect(gplugin_manager_get_instance(), "loaded-plugin",
1145                          G_CALLBACK(plugin_loaded_cb), NULL);
1146         g_signal_connect(gplugin_manager_get_instance(), "unloading-plugin",
1147                          G_CALLBACK(plugin_unloading_cb), NULL);
1148         g_signal_connect(gplugin_manager_get_instance(), "unloaded-plugin",
1149                          G_CALLBACK(plugin_unloaded_cb), NULL);
1150
1151         purple_plugins_refresh();
1152 #endif
1153 }
1154
1155 void
1156 purple_plugins_uninit(void)
1157 {
1158         void *handle = purple_plugins_get_handle();
1159
1160 #ifdef PURPLE_PLUGINS
1161         purple_debug_info("plugins", "Unloading all plugins\n");
1162         while (loaded_plugins != NULL)
1163                 purple_plugin_unload(loaded_plugins->data, NULL);
1164 #endif
1165
1166         purple_signals_disconnect_by_handle(handle);
1167         purple_signals_unregister_by_instance(handle);
1168
1169 #ifdef PURPLE_PLUGINS
1170         gplugin_uninit();
1171 #endif
1172 }