src/ephy-extensions-manager.c

   1 /*
   2  *  Copyright © 2003 Marco Pesenti Gritti
   3  *  Copyright © 2003, 2004 Christian Persch
   4  *  Copyright © 2004 Adam Hooper
   5  *  Copyright © 2005 Crispin Flowerday
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2, or (at your option)
  10  *  any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  *  $Id: ephy-extensions-manager.c 6952 2007-03-11 19:42:02Z chpe $
  22  */
  23
  24 #include "config.h"
  25
  26 #include "ephy-extensions-manager.h"
  27
  28 #include "ephy-loader.h"
  29 #include "ephy-shlib-loader.h"
  30
  31 #include "ephy-node-db.h"
  32 #include "ephy-shell.h"
  33 #include "eel-gconf-extensions.h"
  34 #include "ephy-file-helpers.h"
  35 #include "ephy-object-helpers.h"
  36 #include "ephy-debug.h"
  37
  38 #include "ephy-glib-compat.h"
  39
  40 #include <libxml/tree.h>
  41 #include <libxml/xmlreader.h>
  42 #include <libxml/globals.h>
  43 #include <libxml/tree.h>
  44 #include <libxml/xmlwriter.h>
  45 #include <libxslt/xslt.h>
  46 #include <libxslt/transform.h>
  47 #include <libxslt/xsltutils.h>
  48
  49 #include <libgnomevfs/gnome-vfs-ops.h>
  50 #include <libgnomevfs/gnome-vfs-utils.h>
  51
  52 #include <gconf/gconf-client.h>
  53
  54 #include <gmodule.h>
  55 #include <dirent.h>
  56 #include <string.h>
  57
  58 #ifdef ENABLE_PYTHON
  59 #include "ephy-python-extension.h"
  60 #include "ephy-python-loader.h"
  61 #endif
  62
  63 #define CONF_LOADED_EXTENSIONS  "/apps/epiphany/general/active_extensions"
  64 #define EE_GROUP                "Epiphany Extension"
  65 #define DOT_INI                 ".ephy-extension"
  66 #define RELOAD_DELAY            333 /* ms */
  67 #define RELOAD_SYNC_DELAY       1 /* seconds */
  68
  69 #define ENABLE_LEGACY_FORMAT
  70
  71 #define EPHY_EXTENSIONS_MANAGER_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_EXTENSIONS_MANAGER, EphyExtensionsManagerPrivate))
  72
  73 struct _EphyExtensionsManagerPrivate
  74 {
  75         gboolean initialised;
  76
  77         GList *data;
  78         GList *factories;
  79         GList *extensions;
  80         GList *dir_monitors;
  81         GList *windows;
  82         guint active_extensions_notifier_id;
  83         guint sync_timeout_id;
  84         GHashTable *reload_hash;
  85
  86 #ifdef ENABLE_LEGACY_FORMAT
  87         xsltStylesheetPtr xml2ini_xsl;
  88 #endif
  89 };
  90
  91 typedef struct
  92 {
  93         EphyExtensionInfo info;
  94         gboolean load_failed;
  95
  96         char *loader_type;
  97
  98         EphyLoader *loader; /* NULL if never loaded */
  99         GObject *extension; /* NULL if unloaded */
 100
 101 #ifdef ENABLE_LEGACY_FORMAT
 102         guint is_legacy_format : 1;
 103 #endif
 104 } ExtensionInfo;
 105
 106 typedef struct
 107 {
 108         char *type;
 109         EphyLoader *loader;
 110 } LoaderInfo;
 111
 112 typedef enum
 113 {
 114         FORMAT_UNKNOWN,
 115         FORMAT_INI
 116 #ifdef ENABLE_LEGACY_FORMAT
 117         , FORMAT_XML
 118 #endif
 119 } ExtensionFormat;
 120
 121 enum
 122 {
 123         CHANGED,
 124         ADDED,
 125         REMOVED,
 126         LAST_SIGNAL
 127 };
 128
 129 static guint signals[LAST_SIGNAL] = { 0 };
 130
 131 static GObjectClass *parent_class = NULL;
 132
 133 static void ephy_extensions_manager_class_init  (EphyExtensionsManagerClass *klass);
 134 static void ephy_extensions_manager_iface_init  (EphyExtensionIface *iface);
 135 static void ephy_extensions_manager_init        (EphyExtensionsManager *manager);
 136
 137 GType
 138 ephy_extensions_manager_get_type (void)
 139 {
 140         static GType type = 0;
 141
 142         if (G_UNLIKELY (type == 0))
 143         {
 144                 const GTypeInfo our_info =
 145                 {
 146                         sizeof (EphyExtensionsManagerClass),
 147                         NULL, /* base_init */
 148                         NULL, /* base_finalize */
 149                         (GClassInitFunc) ephy_extensions_manager_class_init,
 150                         NULL,
 151                         NULL, /* class_data */
 152                         sizeof (EphyExtensionsManager),
 153                         0, /* n_preallocs */
 154                         (GInstanceInitFunc) ephy_extensions_manager_init
 155                 };
 156
 157                 const GInterfaceInfo extension_info =
 158                 {
 159                         (GInterfaceInitFunc) ephy_extensions_manager_iface_init,
 160                         NULL,
 161                         NULL
 162                 };
 163
 164                 type = g_type_register_static (G_TYPE_OBJECT,
 165                                                "EphyExtensionsManager",
 166                                                &our_info, 0);
 167
 168                 g_type_add_interface_static (type,
 169                                              EPHY_TYPE_EXTENSION,
 170                                              &extension_info);
 171         }
 172
 173         return type;
 174 }
 175
 176 /**
 177  * ephy_extensions_manager_load:
 178  * @manager: an #EphyExtensionsManager
 179  * @name: identifier of the extension to load
 180  *
 181  * Loads the @name extension.
 182  **/
 183 void
 184 ephy_extensions_manager_load (EphyExtensionsManager *manager,
 185                               const char *identifier)
 186 {
 187         GSList *gconf_exts;
 188
 189         g_return_if_fail (EPHY_IS_EXTENSIONS_MANAGER (manager));
 190         g_return_if_fail (identifier != NULL);
 191
 192         LOG ("Adding '%s' to extensions", identifier);
 193
 194         gconf_exts = eel_gconf_get_string_list (CONF_LOADED_EXTENSIONS);
 195
 196         if (!g_slist_find_custom (gconf_exts, identifier, (GCompareFunc) strcmp))
 197         {
 198                 gconf_exts = g_slist_prepend (gconf_exts, g_strdup (identifier));
 199
 200                 eel_gconf_set_string_list (CONF_LOADED_EXTENSIONS, gconf_exts);
 201         }
 202
 203         g_slist_foreach (gconf_exts, (GFunc) g_free, NULL);
 204         g_slist_free (gconf_exts);
 205 }
 206
 207 /**
 208  * ephy_extensions_manager_unload:
 209  * @manager: an #EphyExtensionsManager
 210  * @name: filename of extension to unload, minus "lib" and "extension.so"
 211  *
 212  * Unloads the extension specified by @name.
 213  *
 214  * The extension with the same filename can afterwards be reloaded. However,
 215  * if any GTypes within the extension have changed parent types, Epiphany must
 216  * be restarted.
 217  **/
 218 void
 219 ephy_extensions_manager_unload (EphyExtensionsManager *manager,
 220                                 const char *identifier)
 221 {
 222         GSList *gconf_exts;
 223         GSList *l;
 224
 225         g_return_if_fail (EPHY_IS_EXTENSIONS_MANAGER (manager));
 226         g_return_if_fail (identifier != NULL);
 227
 228         LOG ("Removing '%s' from extensions", identifier);
 229
 230         gconf_exts = eel_gconf_get_string_list (CONF_LOADED_EXTENSIONS);
 231
 232         l = g_slist_find_custom (gconf_exts, identifier, (GCompareFunc) strcmp);
 233
 234         if (l != NULL)
 235         {
 236                 gconf_exts = g_slist_remove_link (gconf_exts, l);
 237                 g_free (l->data);
 238                 g_slist_free_1 (l);
 239
 240                 eel_gconf_set_string_list (CONF_LOADED_EXTENSIONS, gconf_exts);
 241         }
 242
 243         g_slist_foreach (gconf_exts, (GFunc) g_free, NULL);
 244         g_slist_free (gconf_exts);
 245 }
 246
 247 /**
 248  * ephy_extensions_manager_register:
 249  * @manager: an #EphyExtensionsManager
 250  * @object: an Extension
 251  *
 252  * Registers @object with the extensions manager. @object must implement the
 253  * #EphyExtension interface.
 254  **/
 255 void
 256 ephy_extensions_manager_register (EphyExtensionsManager *manager,
 257                                   GObject *object)
 258 {
 259         g_return_if_fail (EPHY_IS_EXTENSIONS_MANAGER (manager));
 260         g_return_if_fail (EPHY_IS_EXTENSION (object));
 261
 262         manager->priv->extensions = g_list_prepend (manager->priv->extensions,
 263                                                     g_object_ref (object));
 264 }
 265
 266
 267 /**
 268  * ephy_extensions_manager_get_extensions:
 269  * @manager: an #EphyExtensionsManager
 270  *
 271  * Returns the list of known extensions.
 272  *
 273  * Returns: a list of #EphyExtensionInfo
 274  **/
 275 GList *
 276 ephy_extensions_manager_get_extensions (EphyExtensionsManager *manager)
 277 {
 278         return g_list_copy (manager->priv->data);
 279 }
 280
 281 static void
 282 free_extension_info (ExtensionInfo *info)
 283 {
 284         EphyExtensionInfo *einfo = (EphyExtensionInfo *) info;
 285
 286         g_free (einfo->identifier);
 287         g_key_file_free (einfo->keyfile);
 288         g_free (info->loader_type);
 289
 290         if (info->extension != NULL)
 291         {
 292                 g_return_if_fail (info->loader != NULL);
 293
 294                 ephy_loader_release_object (info->loader, info->extension);
 295         }
 296         if (info->loader != NULL)
 297         {
 298                 g_object_unref (info->loader);
 299         }
 300
 301         g_free (info);
 302 }
 303
 304 static void
 305 free_loader_info (LoaderInfo *info)
 306 {
 307         g_free (info->type);
 308         g_object_unref (info->loader);
 309         g_free (info);
 310 }
 311
 312 static int
 313 find_extension_info (const ExtensionInfo *info,
 314                      const char *identifier)
 315 {
 316         return strcmp (info->info.identifier, identifier);
 317 }
 318
 319 static ExtensionInfo *
 320 ephy_extensions_manager_parse_keyfile (EphyExtensionsManager *manager,
 321                                        GKeyFile *key_file,
 322                                        const char *identifier)
 323 {
 324         ExtensionInfo *info;
 325         EphyExtensionInfo *einfo;
 326         char *start_group;
 327
 328         LOG ("Parsing INI description file for '%s'", identifier);
 329
 330         start_group = g_key_file_get_start_group (key_file);
 331         if (start_group == NULL ||
 332             strcmp (start_group, EE_GROUP) != 0 ||
 333             !g_key_file_has_group (key_file, "Loader"))
 334         {
 335                 g_warning ("Invalid extension description file for '%s'; "
 336                            "missing 'Epiphany Extension' or 'Loader' group",
 337                            identifier);
 338
 339                 g_key_file_free (key_file);
 340                 g_free (start_group);
 341                 return NULL;
 342         }
 343         g_free (start_group);
 344
 345         if (!g_key_file_has_key (key_file, EE_GROUP, "Name", NULL) ||
 346             !g_key_file_has_key (key_file, EE_GROUP, "Description", NULL))
 347         {
 348                 g_warning ("Invalid extension description file for '%s'; "
 349                            "missing 'Name' or 'Description' keys.",
 350                            identifier);
 351
 352                 g_key_file_free (key_file);
 353                 return NULL;
 354         }
 355
 356         info = g_new0 (ExtensionInfo, 1);
 357         einfo = (EphyExtensionInfo *) info;
 358         einfo->identifier = g_strdup (identifier);
 359         einfo->keyfile = key_file;
 360
 361         info->loader_type = g_key_file_get_string (key_file, "Loader", "Type", NULL);
 362
 363         /* sanity check */
 364         if (info->loader_type == NULL || info->loader_type[0] == '\0')
 365         {
 366                 free_extension_info (info);
 367                 return NULL;
 368         }
 369
 370         manager->priv->data = g_list_prepend (manager->priv->data, info);
 371
 372         g_signal_emit (manager, signals[ADDED], 0, info);
 373
 374         return info;
 375 }
 376
 377 static void
 378 ephy_extensions_manager_load_ini_file (EphyExtensionsManager *manager,
 379                                        const char *identifier,
 380                                        const char *path)
 381 {
 382         GKeyFile *keyfile;
 383         GError *err = NULL;
 384
 385         keyfile = g_key_file_new ();
 386         if (!g_key_file_load_from_file (keyfile, path, G_KEY_FILE_NONE, &err))
 387         {
 388                 g_warning ("Could load key file for '%s': '%s'",
 389                            identifier, err->message);
 390                 g_error_free (err);
 391                 g_key_file_free (keyfile);
 392                 return;
 393         }
 394
 395         ephy_extensions_manager_parse_keyfile (manager, keyfile, identifier);
 396 }
 397
 398 #ifdef ENABLE_LEGACY_FORMAT
 399
 400 static void
 401 ephy_extensions_manager_load_xml_file (EphyExtensionsManager *manager,
 402                                        const char *identifier,
 403                                        const char *path)
 404 {
 405         EphyExtensionsManagerPrivate *priv = manager->priv;
 406         ExtensionInfo *info;
 407         xmlDocPtr doc, res;
 408         const xmlChar *xsl_file;
 409         xmlChar *output = NULL;
 410         int outlen = -1, ret = -1;
 411
 412         START_PROFILER ("Transforming .xml -> " DOT_INI)
 413
 414         doc = xmlParseFile (path);
 415         if (!doc) goto out;
 416
 417         if (priv->xml2ini_xsl == NULL)
 418         {
 419                 xsl_file = (const xmlChar *) ephy_file ("ephy-xml2ini.xsl");
 420                 if (!xsl_file) return;
 421
 422                 priv->xml2ini_xsl = xsltParseStylesheetFile (xsl_file);
 423                 if (priv->xml2ini_xsl == NULL)
 424                 {
 425                         g_warning ("Couldn't parse the XSL to transform .xml extension descriptions!\n");
 426                         goto out;
 427                 }
 428         }
 429
 430         res = xsltApplyStylesheet (priv->xml2ini_xsl, doc, NULL);
 431         if (!res) goto out;
 432
 433         ret = xsltSaveResultToString (&output, &outlen, res, priv->xml2ini_xsl);
 434
 435         if (ret >= 0 && output != NULL && outlen > -1)
 436         {
 437                 GKeyFile *keyfile;
 438                 GError *err = NULL;
 439
 440                 keyfile = g_key_file_new ();
 441                 if (!g_key_file_load_from_data (keyfile, (char *) output, outlen,
 442                                                 G_KEY_FILE_NONE, &err))
 443                 {
 444                         g_warning ("Could load converted key file for '%s': '%s'",
 445                                    identifier, err->message);
 446                         g_error_free (err);
 447                         g_key_file_free (keyfile);
 448                         goto out;
 449                 }
 450
 451                 info = ephy_extensions_manager_parse_keyfile (manager, keyfile, identifier);
 452                 if (info != NULL)
 453                 {
 454                         info->is_legacy_format = TRUE;
 455                 }
 456         }
 457
 458         xmlFreeDoc (res);
 459         xmlFreeDoc (doc);
 460
 461 out:
 462         xmlFree (output);
 463
 464         STOP_PROFILER ("Transforming .xml -> " DOT_INI)
 465 }
 466
 467 #endif /* ENABLE_LEGACY_FORMAT */
 468
 469 static char *
 470 path_to_identifier (const char *path)
 471 {
 472         char *identifier, *dot;
 473
 474         identifier = g_path_get_basename (path);
 475         dot = strstr (identifier, DOT_INI);
 476
 477 #ifdef ENABLE_LEGACY_FORMAT
 478         if (!dot)
 479         {
 480                 dot = strstr (identifier, ".xml");
 481         }
 482 #endif
 483
 484         g_return_val_if_fail (dot != NULL, NULL);
 485
 486         *dot = '\0';
 487
 488         return identifier;
 489 }
 490
 491 static ExtensionFormat
 492 format_from_path (const char *path)
 493 {
 494         ExtensionFormat format = FORMAT_UNKNOWN;
 495
 496         if (g_str_has_suffix (path, DOT_INI))
 497         {
 498                 format = FORMAT_INI;
 499         }
 500 #ifdef ENABLE_LEGACY_FORMAT
 501         else if (g_str_has_suffix (path, ".xml"))
 502         {
 503                 format = FORMAT_XML;
 504         }
 505 #endif
 506
 507         return format;
 508 }
 509
 510 static void
 511 ephy_extensions_manager_load_file (EphyExtensionsManager *manager,
 512                                    const char *path)
 513 {
 514         GList *element;
 515         char *identifier;
 516         ExtensionFormat format;
 517
 518         identifier = path_to_identifier (path);
 519         g_return_if_fail (identifier != NULL);
 520         if (identifier == NULL) return;
 521
 522         format = format_from_path (path);
 523         g_return_if_fail (format != FORMAT_UNKNOWN);
 524
 525         element = g_list_find_custom (manager->priv->data, identifier,
 526                                       (GCompareFunc) find_extension_info);
 527         if (element != NULL)
 528         {
 529 #ifdef ENABLE_LEGACY_FORMAT
 530                 ExtensionInfo *info = (ExtensionInfo *) element->data;
 531
 532                 /* If this is the legacy format and we already have the info
 533                  * read for this type from a non-legacy format file, don't
 534                  * warn.
 535                  */
 536                 if (format == FORMAT_XML && !info->is_legacy_format)
 537 #endif
 538                 {
 539                         g_warning ("Extension description for '%s' already read!",
 540                                    identifier);
 541                 }
 542
 543                 g_free (identifier);
 544                 return;
 545         }
 546
 547         if (format == FORMAT_INI)
 548         {
 549                 ephy_extensions_manager_load_ini_file (manager, identifier,
 550                                                        path);
 551         }
 552 #ifdef ENABLE_LEGACY_FORMAT
 553         else if (format == FORMAT_XML)
 554         {
 555                 ephy_extensions_manager_load_xml_file (manager, identifier,
 556                                                        path);
 557         }
 558 #endif
 559
 560         g_free (identifier);
 561 }
 562
 563
 564 static int
 565 find_loader (const LoaderInfo *info,
 566               const char *type)
 567 {
 568         return strcmp (info->type, type);
 569 }
 570
 571 static char *
 572 sanitise_type (const char *string)
 573 {
 574         char *str, *p;
 575
 576         str = g_strdup (string);
 577         for (p = str; *p != '\0'; p++)
 578         {
 579                 if (!g_ascii_isalpha (*p)) *p = '-';
 580         }
 581
 582         return str;
 583 }
 584
 585 static EphyLoader *
 586 get_loader_for_type (EphyExtensionsManager *manager,
 587                      const char *type)
 588 {
 589         LoaderInfo *info;
 590         GList *l;
 591         char *path, *name, *stype, *data;
 592         GKeyFile *keyfile;
 593         EphyLoader *shlib_loader;
 594         GObject *loader;
 595
 596         LOG ("Looking for loader for type '%s'", type);
 597
 598         l = g_list_find_custom (manager->priv->factories, type,
 599                                 (GCompareFunc) find_loader);
 600         if (l != NULL)
 601         {
 602                 info = (LoaderInfo *) l->data;
 603                 return g_object_ref (info->loader);
 604         }
 605
 606         if (strcmp (type, "shlib") == 0)
 607         {
 608                 info = g_new (LoaderInfo, 1);
 609                 info->type = g_strdup (type);
 610                 info->loader = g_object_new (EPHY_TYPE_SHLIB_LOADER, NULL);
 611
 612                 manager->priv->factories =
 613                         g_list_append (manager->priv->factories, info);
 614
 615                 return g_object_ref (info->loader);
 616         }
 617         if (strcmp (type, "python") == 0)
 618         {
 619 #ifdef ENABLE_PYTHON
 620                 info = g_new (LoaderInfo, 1);
 621                 info->type = g_strdup (type);
 622                 info->loader = g_object_new (EPHY_TYPE_PYTHON_LOADER, NULL);
 623
 624                 manager->priv->factories =
 625                                 g_list_append (manager->priv->factories, info);
 626
 627                 return g_object_ref (info->loader);
 628 #else
 629                 return NULL;
 630 #endif
 631         }
 632
 633         shlib_loader = get_loader_for_type (manager, "shlib");
 634         g_return_val_if_fail (shlib_loader != NULL, NULL);
 635
 636         stype = sanitise_type (type);
 637         name = g_strconcat ("lib", stype, "loader.", G_MODULE_SUFFIX, NULL);
 638         path = g_build_filename (LOADER_DIR, name, NULL);
 639         data = g_strconcat ("[Loader]\nType=shlib\nLibrary=", path, "\n", NULL);
 640         g_free (stype);
 641         g_free (name);
 642         g_free (path);
 643
 644         keyfile = g_key_file_new ();
 645         if (!g_key_file_load_from_data (keyfile, data, strlen (data), 0, NULL))
 646         {
 647                 g_free (data);
 648                 return NULL;
 649         }
 650
 651         loader = ephy_loader_get_object (shlib_loader, keyfile);
 652         g_key_file_free (keyfile);
 653
 654         if (EPHY_IS_LOADER (loader))
 655         {
 656                 info = g_new (LoaderInfo, 1);
 657                 info->type = g_strdup (type);
 658                 info->loader = EPHY_LOADER (loader);
 659
 660                 manager->priv->factories =
 661                         g_list_append (manager->priv->factories, info);
 662
 663                 return g_object_ref (info->loader);
 664         }
 665
 666         g_return_val_if_reached (NULL);
 667
 668         return NULL;
 669 }
 670
 671 static void
 672 attach_window (EphyWindow *window,
 673                EphyExtension *extension)
 674 {
 675         GList *tabs, *l;
 676
 677         ephy_extension_attach_window (extension, window);
 678
 679         tabs = ephy_window_get_tabs (window);
 680         for (l = tabs; l; l = l->next)
 681         {
 682                 ephy_extension_attach_tab (extension, window,
 683                                            EPHY_TAB (l->data));
 684         }
 685         g_list_free (tabs);
 686 }
 687
 688 static void
 689 load_extension (EphyExtensionsManager *manager,
 690                 ExtensionInfo *info)
 691 {
 692         EphyLoader *loader;
 693
 694         g_return_if_fail (info->extension == NULL);
 695
 696         LOG ("Loading extension '%s'", info->info.identifier);
 697
 698         /* don't try again */
 699         if (info->load_failed) return;
 700
 701         /* get a loader */
 702         loader = get_loader_for_type (manager, info->loader_type);
 703         if (loader == NULL)
 704         {
 705                 g_message ("No loader found for extension '%s' of type '%s'\n",
 706                            info->info.identifier, info->loader_type);
 707                 return;
 708         }
 709
 710         info->loader = loader;
 711
 712         info->extension = ephy_loader_get_object (loader, info->info.keyfile);
 713
 714         /* attach if the extension implements EphyExtensionIface */
 715         if (EPHY_IS_EXTENSION (info->extension))
 716         {
 717                 manager->priv->extensions =
 718                         g_list_prepend (manager->priv->extensions,
 719                                         g_object_ref (info->extension));
 720
 721                 g_list_foreach (manager->priv->windows, (GFunc) attach_window,
 722                                 info->extension);
 723         }
 724
 725         if (info->extension != NULL)
 726         {
 727                 info->info.active = TRUE;
 728         }
 729         else
 730         {
 731                 info->info.active = FALSE;
 732                 info->load_failed = TRUE;
 733         }
 734 }
 735
 736 static void
 737 detach_window (EphyWindow *window,
 738                EphyExtension *extension)
 739 {
 740         GList *tabs, *l;
 741
 742         tabs = ephy_window_get_tabs (window);
 743         for (l = tabs; l; l = l->next)
 744         {
 745                 ephy_extension_detach_tab (extension, window,
 746                                            EPHY_TAB (l->data));
 747         }
 748         g_list_free (tabs);
 749
 750         ephy_extension_detach_window (extension, window);
 751 }
 752
 753 static void
 754 unload_extension (EphyExtensionsManager *manager,
 755                   ExtensionInfo *info)
 756 {
 757         g_return_if_fail (info->loader != NULL);
 758         g_return_if_fail (info->extension != NULL || info->load_failed);
 759
 760         LOG ("Unloading extension '%s'", info->info.identifier);
 761
 762         if (info->load_failed) return;
 763
 764         /* detach if the extension implements EphyExtensionIface */
 765         if (EPHY_IS_EXTENSION (info->extension))
 766         {
 767                 g_list_foreach (manager->priv->windows, (GFunc) detach_window,
 768                                 info->extension);
 769
 770                 manager->priv->extensions =
 771                         g_list_remove (manager->priv->extensions, info->extension);
 772
 773                 /* we own two refs to the extension, the one we added when
 774                  * we added it to the priv->extensions list, and the one returned
 775                  * from get_object. Release object, and queue a unref, since if the
 776                  * extension has its own functions queued in the idle loop, the
 777                  * functions must exist in memory before being called.
 778                  */
 779                 ephy_object_idle_unref (info->extension);
 780         }
 781
 782         ephy_loader_release_object (info->loader, G_OBJECT (info->extension));
 783
 784         info->info.active = FALSE;
 785         info->extension = NULL;
 786 }
 787
 788 static void
 789 sync_loaded_extensions (EphyExtensionsManager *manager)
 790 {
 791         GConfClient *client;
 792         GConfValue *value;
 793         GSList *active_extensions = NULL;
 794         GList *l;
 795         gboolean active;
 796         ExtensionInfo *info;
 797
 798         LOG ("Synching changed list of active extensions");
 799
 800         client = gconf_client_get_default ();
 801         g_return_if_fail (client != NULL);
 802
 803         value = gconf_client_get (client, CONF_LOADED_EXTENSIONS, NULL);
 804
 805         /* make sure the extensions-manager-ui is loaded */
 806         if (value == NULL ||
 807             value->type != GCONF_VALUE_LIST ||
 808             gconf_value_get_list_type (value) != GCONF_VALUE_STRING)
 809         {
 810                 active_extensions = g_slist_prepend (active_extensions,
 811                                                      g_strdup ("extensions-manager-ui"));
 812                 eel_gconf_set_string_list (CONF_LOADED_EXTENSIONS, active_extensions);
 813         }
 814         else
 815         {
 816                 active_extensions = eel_gconf_get_string_list (CONF_LOADED_EXTENSIONS);
 817         }
 818
 819         for (l = manager->priv->data; l != NULL; l = l->next)
 820         {
 821                 gboolean changed;
 822
 823                 info = (ExtensionInfo *) l->data;
 824
 825                 active = (g_slist_find_custom (active_extensions,
 826                                                info->info.identifier,
 827                                                (GCompareFunc) strcmp) != NULL);
 828
 829                 LOG ("Extension '%s' is %sactive and %sloaded",
 830                      info->info.identifier,
 831                      active ? "" : "not ",
 832                      info->info.active ? "" : "not ");
 833
 834                 changed = ( info->info.enabled != active );
 835
 836                 info->info.enabled = active;
 837
 838                 if (active != info->info.active)
 839                 {
 840                         if (active)
 841                         {
 842                                 load_extension (manager, info);
 843                         }
 844                         else
 845                         {
 846                                 unload_extension (manager, info);
 847                         }
 848
 849                         if (active == info->info.active)
 850                         {
 851                                 changed = TRUE;
 852                         }
 853                 }
 854
 855                 if (changed)
 856                 {
 857                         g_signal_emit (manager, signals[CHANGED], 0, info);
 858                 }
 859         }
 860
 861         g_slist_foreach (active_extensions, (GFunc) g_free, NULL);
 862         g_slist_free (active_extensions);
 863
 864         if (value != NULL)
 865         {
 866                 gconf_value_free (value);
 867         }
 868         g_object_unref (client);
 869 }
 870
 871 static void
 872 ephy_extensions_manager_unload_file (EphyExtensionsManager *manager,
 873                                      const char *path)
 874 {
 875         GList *l;
 876         ExtensionInfo *info;
 877         char *identifier;
 878
 879         identifier = path_to_identifier (path);
 880
 881         l = g_list_find_custom (manager->priv->data, identifier,
 882                                 (GCompareFunc) find_extension_info);
 883
 884         if (l != NULL)
 885         {
 886                 info = (ExtensionInfo *) l->data;
 887
 888                 manager->priv->data = g_list_remove (manager->priv->data, info);
 889
 890                 if (info->info.active == TRUE)
 891                 {
 892                         unload_extension (manager, info);
 893                 }
 894
 895                 g_signal_emit (manager, signals[REMOVED], 0, info);
 896
 897                 free_extension_info (info);
 898         }
 899
 900         g_free (identifier);
 901 }
 902
 903 static gboolean
 904 reload_sync_cb (EphyExtensionsManager *manager)
 905 {
 906         EphyExtensionsManagerPrivate *priv = manager->priv;
 907
 908         if (priv->sync_timeout_id != 0)
 909         {
 910                 g_source_remove (priv->sync_timeout_id);
 911                 priv->sync_timeout_id = 0;
 912         }
 913
 914         sync_loaded_extensions (manager);
 915
 916         return FALSE;
 917 }
 918
 919 static gboolean
 920 reload_cb (gpointer *data)
 921 {
 922         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (data[0]);
 923         EphyExtensionsManagerPrivate *priv = manager->priv;
 924         char *path = data[1];
 925
 926         LOG ("Reloading %s", path);
 927
 928         /* We still need path and don't want to remove the timeout
 929          * which will be removed automatically when we return, so
 930          * just use _steal instead of _remove.
 931          */
 932         g_hash_table_steal (priv->reload_hash, path);
 933
 934         ephy_extensions_manager_load_file (manager, path);
 935         g_free (path);
 936
 937         /* Schedule a sync of active extensions */
 938         /* FIXME: just look if we need to activate *this* extension? */
 939
 940         if (priv->sync_timeout_id != 0)
 941         {
 942                 g_source_remove (priv->sync_timeout_id);
 943         }
 944
 945         priv->sync_timeout_id = g_timeout_add_seconds (RELOAD_SYNC_DELAY,
 946                                                (GSourceFunc) reload_sync_cb,
 947                                                manager);
 948         return FALSE;
 949 }
 950
 951 static void
 952 schedule_load_from_monitor (EphyExtensionsManager *manager,
 953                             const char *path)
 954 {
 955         EphyExtensionsManagerPrivate *priv = manager->priv;
 956         char *identifier, *copy;
 957         gpointer *data;
 958         guint timeout_id;
 959
 960         /* When a file is installed, it sometimes gets CREATED empty and then
 961          * gets its contents filled later (for a CHANGED signal). Theoretically
 962          * I suppose we could get a CHANGED signal when the file is half-full,
 963          * but I doubt that'll happen much (the files are <1000 bytes). We
 964          * don't want warnings all over the place, so we just wait a bit before
 965          * actually reloading the file. (We're assuming that if a file is
 966          * empty it'll be filled soon and this function will be called again.)
 967          *
 968          * Oh, and we return if the extension is already loaded, too.
 969          */
 970
 971         identifier = path_to_identifier (path);
 972         g_return_if_fail (identifier != NULL);
 973         if (identifier == NULL) return;
 974
 975         if (g_list_find_custom (manager->priv->data, identifier,
 976                                 (GCompareFunc) find_extension_info) != NULL)
 977         {
 978                 g_free (identifier);
 979                 return;
 980         }
 981         g_free (identifier);
 982
 983         g_return_if_fail (priv->reload_hash != NULL);
 984
 985         data = g_new (gpointer, 2);
 986         data[0] = (gpointer) manager;
 987         data[1] = copy = g_strdup (path);
 988         timeout_id = g_timeout_add_full (G_PRIORITY_LOW, RELOAD_DELAY,
 989                                          (GSourceFunc) reload_cb,
 990                                          data, (GDestroyNotify) g_free);
 991         g_hash_table_replace (priv->reload_hash, copy /* owns it */,
 992                               GUINT_TO_POINTER (timeout_id));
 993 }
 994
 995 static void
 996 dir_changed_cb (GnomeVFSMonitorHandle *handle,
 997                 const char *monitor_uri,
 998                 const char *info_uri,
 999                 GnomeVFSMonitorEventType event_type,
1000                 EphyExtensionsManager *manager)
1001 {
1002         char *path;
1003
1004         /*
1005          * We only deal with XML and INI files:
1006          * Add them to the manager when created, remove them when deleted.
1007          */
1008         if (format_from_path (info_uri) == FORMAT_UNKNOWN) return;
1009
1010         path = gnome_vfs_get_local_path_from_uri (info_uri);
1011
1012         switch (event_type)
1013         {
1014                 case GNOME_VFS_MONITOR_EVENT_CREATED:
1015                 case GNOME_VFS_MONITOR_EVENT_CHANGED:
1016                         schedule_load_from_monitor (manager, path);
1017                         break;
1018                 case GNOME_VFS_MONITOR_EVENT_DELETED:
1019                         ephy_extensions_manager_unload_file (manager, path);
1020                         break;
1021                 default:
1022                         break;
1023         }
1024
1025         g_free (path);
1026 }
1027
1028 static void
1029 ephy_extensions_manager_load_dir (EphyExtensionsManager *manager,
1030                                   const char *path)
1031 {
1032         DIR *d;
1033         struct dirent *e;
1034         char *file_path;
1035         char *file_uri;
1036         GnomeVFSMonitorHandle *monitor;
1037         GnomeVFSResult res;
1038
1039         LOG ("Scanning directory '%s'", path);
1040
1041         START_PROFILER ("Scanning directory")
1042
1043         d = opendir (path);
1044         if (d == NULL)
1045         {
1046                 return;
1047         }
1048         while ((e = readdir (d)) != NULL)
1049         {
1050                 if (format_from_path (e->d_name) != FORMAT_UNKNOWN)
1051                 {
1052                         file_path = g_build_filename (path, e->d_name, NULL);
1053                         ephy_extensions_manager_load_file (manager, file_path);
1054                         g_free (file_path);
1055                 }
1056         }
1057         closedir (d);
1058
1059         file_uri = gnome_vfs_get_uri_from_local_path (path);
1060         res = gnome_vfs_monitor_add (&monitor,
1061                                      path,
1062                                      GNOME_VFS_MONITOR_DIRECTORY,
1063                                      (GnomeVFSMonitorCallback) dir_changed_cb,
1064                                      manager);
1065         g_free (file_uri);
1066
1067         if (res == GNOME_VFS_OK)
1068         {
1069                 manager->priv->dir_monitors = g_list_prepend
1070                         (manager->priv->dir_monitors, monitor);
1071         }
1072
1073         STOP_PROFILER ("Scanning directory")
1074 }
1075
1076 static void
1077 active_extensions_notifier (GConfClient *client,
1078                             guint cnxn_id,
1079                             GConfEntry *entry,
1080                             EphyExtensionsManager *manager)
1081 {
1082         sync_loaded_extensions (manager);
1083 }
1084
1085 static void
1086 cancel_timeout (gpointer data)
1087 {
1088         guint id = GPOINTER_TO_UINT (data);
1089
1090         g_source_remove (id);
1091 }
1092
1093 static void
1094 ephy_extensions_manager_init (EphyExtensionsManager *manager)
1095 {
1096         EphyExtensionsManagerPrivate *priv;
1097
1098         priv = manager->priv = EPHY_EXTENSIONS_MANAGER_GET_PRIVATE (manager);
1099
1100         priv->reload_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
1101                                                    (GDestroyNotify) g_free,
1102                                                    (GDestroyNotify) cancel_timeout);
1103 }
1104
1105 void
1106 ephy_extensions_manager_startup (EphyExtensionsManager *manager)
1107 {
1108         char *path;
1109
1110         g_return_if_fail (EPHY_IS_EXTENSIONS_MANAGER (manager));
1111
1112         LOG ("EphyExtensionsManager startup");
1113
1114         /* load the extensions descriptions */
1115         path = g_build_filename (ephy_dot_dir (), "extensions", NULL);
1116         ephy_extensions_manager_load_dir (manager, path);
1117         g_free (path);
1118
1119         ephy_extensions_manager_load_dir (manager, EXTENSIONS_DIR);
1120
1121         active_extensions_notifier (NULL, 0, NULL, manager);
1122         manager->priv->active_extensions_notifier_id =
1123                 eel_gconf_notification_add
1124                         (CONF_LOADED_EXTENSIONS,
1125                          (GConfClientNotifyFunc) active_extensions_notifier,
1126                          manager);
1127 }
1128
1129 static void
1130 ephy_extensions_manager_dispose (GObject *object)
1131 {
1132         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (object);
1133         EphyExtensionsManagerPrivate *priv = manager->priv;
1134
1135 #ifdef ENABLE_LEGACY_FORMAT
1136         if (priv->xml2ini_xsl != NULL)
1137         {
1138                 xsltFreeStylesheet (priv->xml2ini_xsl);
1139                 priv->xml2ini_xsl = NULL;
1140         }
1141 #endif
1142
1143         if (priv->active_extensions_notifier_id != 0)
1144         {
1145                 eel_gconf_notification_remove (priv->active_extensions_notifier_id);
1146                 priv->active_extensions_notifier_id = 0;
1147         }
1148
1149         if (priv->reload_hash != NULL)
1150         {
1151                 g_hash_table_destroy (priv->reload_hash);
1152                 priv->reload_hash = NULL;
1153         }
1154
1155         if (priv->sync_timeout_id != 0)
1156         {
1157                 g_source_remove (priv->sync_timeout_id);
1158                 priv->sync_timeout_id = 0;
1159         }
1160
1161         if (priv->dir_monitors != NULL)
1162         {
1163                 g_list_foreach (priv->dir_monitors, (GFunc) gnome_vfs_monitor_cancel, NULL);
1164                 g_list_free (priv->dir_monitors);
1165                 priv->dir_monitors = NULL;
1166         }
1167
1168         if (priv->extensions != NULL)
1169         {
1170                 g_list_foreach (priv->extensions, (GFunc) g_object_unref, NULL);
1171                 g_list_free (priv->extensions);
1172                 priv->extensions = NULL;
1173         }
1174
1175         if (priv->factories != NULL)
1176         {
1177                 /* FIXME release loaded loaders */
1178                 g_list_foreach (priv->factories, (GFunc) free_loader_info, NULL);
1179                 g_list_free (priv->factories);
1180                 priv->factories = NULL;
1181         }
1182
1183         if (priv->data != NULL)
1184         {
1185                 g_list_foreach (priv->data, (GFunc) free_extension_info, NULL);
1186                 g_list_free (priv->data);
1187                 priv->data = NULL;
1188         }
1189
1190         if (priv->windows != NULL)
1191         {
1192                 g_list_free (priv->windows);
1193                 priv->windows = NULL;
1194         }
1195
1196         parent_class->dispose (object);
1197 }
1198
1199 static void
1200 attach_extension_to_window (EphyExtension *extension,
1201                             EphyWindow *window)
1202 {
1203         attach_window (window, extension);
1204 }
1205
1206 static void
1207 impl_attach_window (EphyExtension *extension,
1208                     EphyWindow *window)
1209 {
1210         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (extension);
1211
1212         LOG ("Attach window %p", window);
1213
1214         g_list_foreach (manager->priv->extensions,
1215                         (GFunc) attach_extension_to_window, window);
1216
1217         manager->priv->windows = g_list_prepend (manager->priv->windows, window);
1218 }
1219
1220 static void
1221 impl_detach_window (EphyExtension *extension,
1222                     EphyWindow *window)
1223 {
1224         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (extension);
1225         GList *tabs, *l;
1226
1227         LOG ("Detach window %p", window);
1228
1229         manager->priv->windows = g_list_remove (manager->priv->windows, window);
1230
1231         g_object_ref (window);
1232
1233         /* Detach tabs (uses impl_detach_tab) */
1234         tabs = ephy_window_get_tabs (window);
1235         for (l = tabs; l; l = l->next)
1236         {
1237                 ephy_extension_detach_tab (extension, window,
1238                                            EPHY_TAB (l->data));
1239         }
1240         g_list_free (tabs);
1241
1242         /* Then detach the window */
1243         g_list_foreach (manager->priv->extensions,
1244                         (GFunc) ephy_extension_detach_window, window);
1245
1246         g_object_unref (window);
1247 }
1248
1249 static void
1250 impl_attach_tab (EphyExtension *extension,
1251                  EphyWindow *window,
1252                  EphyTab *tab)
1253 {
1254         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (extension);
1255         GList *l;
1256
1257         LOG ("Attach window %p tab %p", window, tab);
1258
1259         for (l = manager->priv->extensions; l; l = l->next)
1260         {
1261                 ephy_extension_attach_tab (EPHY_EXTENSION (l->data),
1262                                            window, tab);
1263         }
1264 }
1265
1266 static void
1267 impl_detach_tab (EphyExtension *extension,
1268                  EphyWindow *window,
1269                  EphyTab *tab)
1270 {
1271         EphyExtensionsManager *manager = EPHY_EXTENSIONS_MANAGER (extension);
1272         GList *l;
1273
1274         LOG ("Detach window %p tab %p", window, tab);
1275
1276         g_object_ref (window);
1277         g_object_ref (tab);
1278
1279         for (l = manager->priv->extensions; l; l = l->next)
1280         {
1281                 ephy_extension_detach_tab (EPHY_EXTENSION (l->data),
1282                                            window, tab);
1283         }
1284
1285         g_object_unref (tab);
1286         g_object_unref (window);
1287 }
1288
1289 static void
1290 ephy_extensions_manager_iface_init (EphyExtensionIface *iface)
1291 {
1292         iface->attach_window = impl_attach_window;
1293         iface->detach_window = impl_detach_window;
1294         iface->attach_tab    = impl_attach_tab;
1295         iface->detach_tab    = impl_detach_tab;
1296 }
1297
1298 static void
1299 ephy_extensions_manager_class_init (EphyExtensionsManagerClass *class)
1300 {
1301         GObjectClass *object_class = G_OBJECT_CLASS (class);
1302
1303         parent_class = (GObjectClass *) g_type_class_peek_parent (class);
1304
1305         object_class->dispose = ephy_extensions_manager_dispose;
1306
1307         signals[CHANGED] =
1308                 g_signal_new ("changed",
1309                               G_OBJECT_CLASS_TYPE (object_class),
1310                               G_SIGNAL_RUN_FIRST,
1311                               G_STRUCT_OFFSET (EphyExtensionsManagerClass, changed),
1312                               NULL, NULL,
1313                               g_cclosure_marshal_VOID__POINTER,
1314                               G_TYPE_NONE,
1315                               1,
1316                               G_TYPE_POINTER);
1317         signals[ADDED] =
1318                 g_signal_new ("added",
1319                               G_OBJECT_CLASS_TYPE (object_class),
1320                               G_SIGNAL_RUN_FIRST,
1321                               G_STRUCT_OFFSET (EphyExtensionsManagerClass, added),
1322                               NULL, NULL,
1323                               g_cclosure_marshal_VOID__POINTER,
1324                               G_TYPE_NONE,
1325                               1,
1326                               G_TYPE_POINTER);
1327         signals[REMOVED] =
1328                 g_signal_new ("removed",
1329                               G_OBJECT_CLASS_TYPE (object_class),
1330                               G_SIGNAL_RUN_FIRST,
1331                               G_STRUCT_OFFSET (EphyExtensionsManagerClass, removed),
1332                               NULL, NULL,
1333                               g_cclosure_marshal_VOID__POINTER,
1334                               G_TYPE_NONE,
1335                               1,
1336                               G_TYPE_POINTER);
1337
1338         g_type_class_add_private (object_class, sizeof (EphyExtensionsManagerPrivate));
1339 }