lib/ephy-shlib-loader.c

   1 /*
   2  *  Copyright © 2003 Marco Pesenti Gritti
   3  *  Copyright © 2003, 2004 Christian Persch
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  *  $Id: ephy-shlib-loader.c 6952 2007-03-11 19:42:02Z chpe $
  20  */
  21
  22 #include "config.h"
  23
  24 #include "ephy-shlib-loader.h"
  25 #include "ephy-loader.h"
  26 #include "ephy-module.h"
  27 #include "ephy-debug.h"
  28
  29 #include <string.h>
  30
  31 #define DATA_KEY "EphyShlibLoader::LoaderData"
  32
  33 typedef struct
  34 {
  35         EphyModule *module;
  36         GObject *object;
  37 } LoaderData;
  38
  39 #define EPHY_SHLIB_LOADER_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_SHLIB_LOADER, EphyShlibLoaderPrivate))
  40
  41 struct _EphyShlibLoaderPrivate
  42 {
  43         GSList *data;
  44 };
  45
  46 static void ephy_shlib_loader_class_init (EphyShlibLoaderClass *klass);
  47 static void ephy_shlib_loader_iface_init (EphyLoaderIface *iface);
  48 static void ephy_shlib_loader_init        (EphyShlibLoader *loader);
  49
  50 static GObjectClass *parent_class = NULL;
  51
  52 GType
  53 ephy_shlib_loader_get_type (void)
  54 {
  55         static GType type = 0;
  56
  57         if (G_UNLIKELY (type == 0))
  58         {
  59                 const GTypeInfo our_info =
  60                 {
  61                         sizeof (EphyShlibLoaderClass),
  62                         NULL, /* base_init */
  63                         NULL, /* base_finalize */
  64                         (GClassInitFunc) ephy_shlib_loader_class_init,
  65                         NULL,
  66                         NULL, /* class_data */
  67                         sizeof (EphyShlibLoader),
  68                         0, /* n_preallocs */
  69                         (GInstanceInitFunc) ephy_shlib_loader_init
  70                 };
  71
  72                 const GInterfaceInfo loader_info =
  73                 {
  74                         (GInterfaceInitFunc) ephy_shlib_loader_iface_init,
  75                         NULL,
  76                         NULL
  77                 };
  78
  79                 type = g_type_register_static (G_TYPE_OBJECT,
  80                                                "EphyShlibLoader",
  81                                                &our_info, 0);
  82
  83                 g_type_add_interface_static (type,
  84                                              EPHY_TYPE_LOADER,
  85                                              &loader_info);
  86         }
  87
  88         return type;
  89 }
  90
  91 static void
  92 free_loader_data (LoaderData *data)
  93 {
  94         g_return_if_fail (data != NULL);
  95
  96         /* data->module must NOT be unreffed! */
  97
  98         if (data->object != NULL)
  99         {
 100                 g_object_unref (data->object);
 101         }
 102
 103         g_free (data);
 104 }
 105
 106 static void
 107 ephy_shlib_loader_init (EphyShlibLoader *loader)
 108 {
 109         loader->priv = EPHY_SHLIB_LOADER_GET_PRIVATE (loader);
 110
 111         LOG ("EphyShlibLoader initialising");
 112 }
 113
 114 static void
 115 ephy_shlib_loader_finalize (GObject *object)
 116 {
 117         EphyShlibLoader *loader = EPHY_SHLIB_LOADER (object);
 118
 119         LOG ("EphyShlibLoader finalising");
 120
 121         g_slist_foreach (loader->priv->data, (GFunc) free_loader_data, NULL);
 122         g_slist_free (loader->priv->data);
 123
 124         parent_class->finalize (object);
 125 }
 126
 127 static int
 128 find_library (const LoaderData *data,
 129               const char *library)
 130 {
 131         return strcmp (ephy_module_get_path (data->module), library);
 132 }
 133
 134 static int
 135 find_object (const LoaderData *data,
 136              const GObject *object)
 137 {
 138         return data->object != object;
 139 }
 140
 141 static GObject *
 142 impl_get_object (EphyLoader *eloader,
 143                  GKeyFile *keyfile)
 144 {
 145         EphyShlibLoader *loader = EPHY_SHLIB_LOADER (eloader);
 146         GSList *l;
 147         LoaderData *data = NULL;
 148         char *library;
 149         gboolean resident;
 150
 151         g_return_val_if_fail (keyfile != NULL, NULL);
 152
 153         library = g_key_file_get_string (keyfile, "Loader", "Library", NULL);
 154         if (library == NULL)
 155         {
 156                 g_warning ("NULL library name!\n");
 157                 return NULL;
 158         }
 159
 160         resident = g_key_file_get_boolean (keyfile, "Loader", "Resident", NULL);
 161
 162         l = g_slist_find_custom (loader->priv->data, library,
 163                                 (GCompareFunc) find_library);
 164
 165         if (l != NULL)
 166         {
 167                 data = l->data;
 168                 g_return_val_if_fail (data != NULL, NULL);
 169
 170                 if (data->object != NULL)
 171                 {
 172                         g_free (library);
 173                         return g_object_ref (data->object);
 174                 }
 175         }
 176         else
 177         {
 178                 data = g_new0 (LoaderData, 1);
 179                 loader->priv->data = g_slist_prepend (loader->priv->data, data);
 180         }
 181
 182         if (data->module == NULL)
 183         {
 184                 data->module = ephy_module_new (library, resident);
 185         }
 186
 187         g_return_val_if_fail (data->object == NULL, data->object);
 188
 189         if (g_type_module_use (G_TYPE_MODULE (data->module)) == FALSE)
 190         {
 191                 g_free (library);
 192                 g_warning ("Could not load extension file at %s\n",
 193                            ephy_module_get_path (data->module));
 194                 return NULL;
 195         }
 196
 197         data->object = ephy_module_new_object (data->module);
 198
 199         g_type_module_unuse (G_TYPE_MODULE (data->module));
 200
 201         if (data->object != NULL)
 202         {
 203                 g_object_set_data (G_OBJECT (data->object), DATA_KEY, data);
 204         }
 205
 206         g_free (library);
 207
 208         return data->object;
 209 }
 210
 211 static void
 212 impl_release_object (EphyLoader *eloader,
 213                      GObject *object)
 214 {
 215         EphyShlibLoader *loader = EPHY_SHLIB_LOADER (eloader);
 216         GSList *l;
 217         LoaderData *data;
 218
 219         l = g_slist_find_custom (loader->priv->data, object,
 220                                 (GCompareFunc) find_object);
 221         g_return_if_fail (l != NULL);
 222         data = l->data;
 223
 224         g_object_unref (data->object);
 225         data->object = NULL;
 226 }
 227
 228 static void
 229 ephy_shlib_loader_iface_init (EphyLoaderIface *iface)
 230 {
 231         iface->type = "shlib";
 232         iface->get_object = impl_get_object;
 233         iface->release_object = impl_release_object;
 234 }
 235
 236 static void
 237 ephy_shlib_loader_class_init (EphyShlibLoaderClass *klass)
 238 {
 239         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 240
 241         parent_class = g_type_class_peek_parent (klass);
 242
 243         object_class->finalize = ephy_shlib_loader_finalize;
 244
 245         g_type_class_add_private (object_class, sizeof (EphyShlibLoaderPrivate));
 246 }