fix socket cmp, fix compiler warnings about unused args
[oweals/gnunet.git] / src / util / plugin.c
1 /*
2      This file is part of GNUnet
3      Copyright (C) 2002-2013 GNUnet e.V.
4
5      GNUnet is free software: you can redistribute it and/or modify it
6      under the terms of the GNU Affero General Public License as published
7      by the Free Software Foundation, either version 3 of the License,
8      or (at your option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      Affero General Public License for more details.
14
15      You should have received a copy of the GNU Affero General Public License
16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
21 /**
22  * @file util/plugin.c
23  * @brief Methods to access plugins
24  * @author Christian Grothoff
25  */
26
27 #include "platform.h"
28 #include <ltdl.h>
29 #include "gnunet_util_lib.h"
30
31 #define LOG(kind,...) GNUNET_log_from (kind, "util-plugin", __VA_ARGS__)
32
33 /**
34  * Linked list of active plugins.
35  */
36 struct PluginList
37 {
38   /**
39    * This is a linked list.
40    */
41   struct PluginList *next;
42
43   /**
44    * Name of the library.
45    */
46   char *name;
47
48   /**
49    * System handle.
50    */
51   void *handle;
52 };
53
54
55 /**
56  * Have we been initialized?
57  */
58 static int initialized;
59
60 /**
61  * Libtool search path before we started.
62  */
63 static char *old_dlsearchpath;
64
65 /**
66  * List of plugins we have loaded.
67  */
68 static struct PluginList *plugins;
69
70
71 /**
72  * Setup libtool paths.
73  */
74 static void
75 plugin_init ()
76 {
77   int err;
78   const char *opath;
79   char *path;
80   char *cpath;
81
82   err = lt_dlinit ();
83   if (err > 0)
84   {
85     FPRINTF (stderr,
86              _("Initialization of plugin mechanism failed: %s!\n"),
87              lt_dlerror ());
88     return;
89   }
90   opath = lt_dlgetsearchpath ();
91   if (NULL != opath)
92     old_dlsearchpath = GNUNET_strdup (opath);
93   path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
94   if (NULL != path)
95   {
96     if (NULL != opath)
97     {
98       GNUNET_asprintf (&cpath, "%s:%s", opath, path);
99       lt_dlsetsearchpath (cpath);
100       GNUNET_free (path);
101       GNUNET_free (cpath);
102     }
103     else
104     {
105       lt_dlsetsearchpath (path);
106       GNUNET_free (path);
107     }
108   }
109 }
110
111
112 /**
113  * Shutdown libtool.
114  */
115 static void
116 plugin_fini ()
117 {
118   lt_dlsetsearchpath (old_dlsearchpath);
119   if (NULL != old_dlsearchpath)
120   {
121     GNUNET_free (old_dlsearchpath);
122     old_dlsearchpath = NULL;
123   }
124   lt_dlexit ();
125 }
126
127
128 /**
129  * Lookup a function in the plugin.
130  *
131  * @param plug the plugin to check
132  * @param name name of the symbol to look for
133  * @return NULL if the symbol was not found
134  */
135 static GNUNET_PLUGIN_Callback
136 resolve_function (struct PluginList *plug,
137                   const char *name)
138 {
139   char *initName;
140   void *mptr;
141
142   GNUNET_asprintf (&initName,
143                    "_%s_%s",
144                    plug->name,
145                    name);
146   mptr = lt_dlsym (plug->handle, &initName[1]);
147   if (NULL == mptr)
148     mptr = lt_dlsym (plug->handle, initName);
149   if (NULL == mptr)
150     LOG (GNUNET_ERROR_TYPE_ERROR,
151          _("`%s' failed to resolve method '%s' with error: %s\n"),
152          "lt_dlsym",
153          &initName[1], lt_dlerror ());
154   GNUNET_free (initName);
155   return mptr;
156 }
157
158
159 /**
160  * Test if a plugin exists.
161  *
162  * Note that the library must export a symbol called
163  * `library_name_init` for the test to succeed.
164  *
165  * @param library_name name of the plugin to test if it is installed
166  * @return #GNUNET_YES if the plugin exists, #GNUNET_NO if not
167  */
168 int
169 GNUNET_PLUGIN_test (const char *library_name)
170 {
171   void *libhandle;
172   GNUNET_PLUGIN_Callback init;
173   struct PluginList plug;
174
175   if (! initialized)
176   {
177     initialized = GNUNET_YES;
178     plugin_init ();
179   }
180   libhandle = lt_dlopenext (library_name);
181   if (NULL == libhandle)
182     return GNUNET_NO;
183   plug.handle = libhandle;
184   plug.name = (char *) library_name;
185   init = resolve_function (&plug, "init");
186   if (NULL == init)
187   {
188     GNUNET_break (0);
189     lt_dlclose (libhandle);
190     return GNUNET_NO;
191   }
192   lt_dlclose (libhandle);
193   return GNUNET_YES;
194 }
195
196
197 /**
198  * Setup plugin (runs the `init` callback and returns whatever `init`
199  * returned).  If `init` returns NULL, the plugin is unloaded.
200  *
201  * Note that the library must export symbols called
202  * `library_name_init` and `library_name_done`.  These will be called
203  * when the library is loaded and unloaded respectively.
204  *
205  * @param library_name name of the plugin to load
206  * @param arg argument to the plugin initialization function
207  * @return whatever the initialization function returned
208  */
209 void *
210 GNUNET_PLUGIN_load (const char *library_name, void *arg)
211 {
212   void *libhandle;
213   struct PluginList *plug;
214   GNUNET_PLUGIN_Callback init;
215   void *ret;
216
217   if (!initialized)
218   {
219     initialized = GNUNET_YES;
220     plugin_init ();
221   }
222   libhandle = lt_dlopenext (library_name);
223   if (libhandle == NULL)
224   {
225     LOG (GNUNET_ERROR_TYPE_ERROR,
226          _("`%s' failed for library `%s' with error: %s\n"),
227          "lt_dlopenext",
228          library_name, lt_dlerror ());
229     return NULL;
230   }
231   plug = GNUNET_new (struct PluginList);
232   plug->handle = libhandle;
233   plug->name = GNUNET_strdup (library_name);
234   plug->next = plugins;
235   plugins = plug;
236   init = resolve_function (plug, "init");
237   if ((init == NULL) || (NULL == (ret = init (arg))))
238   {
239     lt_dlclose (libhandle);
240     GNUNET_free (plug->name);
241     plugins = plug->next;
242     GNUNET_free (plug);
243     return NULL;
244   }
245   return ret;
246 }
247
248
249 /**
250  * Unload plugin (runs the `done` callback and returns whatever `done`
251  * returned).  The plugin is then unloaded.
252  *
253  * @param library_name name of the plugin to unload
254  * @param arg argument to the plugin shutdown function
255  * @return whatever the shutdown function returned
256  */
257 void *
258 GNUNET_PLUGIN_unload (const char *library_name,
259                       void *arg)
260 {
261   struct PluginList *pos;
262   struct PluginList *prev;
263   GNUNET_PLUGIN_Callback done;
264   void *ret;
265
266   prev = NULL;
267   pos = plugins;
268   while ((NULL != pos) && (0 != strcmp (pos->name, library_name)))
269   {
270     prev = pos;
271     pos = pos->next;
272   }
273   if (NULL == pos)
274     return NULL;
275
276   done = resolve_function (pos, "done");
277   ret = NULL;
278   if (NULL != done)
279     ret = done (arg);
280   if (NULL == prev)
281     plugins = pos->next;
282   else
283     prev->next = pos->next;
284   lt_dlclose (pos->handle);
285   GNUNET_free (pos->name);
286   GNUNET_free (pos);
287   if (NULL == plugins)
288   {
289     plugin_fini ();
290     initialized = GNUNET_NO;
291   }
292   return ret;
293 }
294
295
296 /**
297  * Closure for #find_libraries().
298  */
299 struct LoadAllContext
300 {
301   /**
302    * Prefix the plugin names we find have to match.
303    */
304   const char *basename;
305
306   /**
307    * Argument to give to 'init' when loading the plugin.
308    */
309   void *arg;
310
311   /**
312    * Function to call for each plugin.
313    */
314   GNUNET_PLUGIN_LoaderCallback cb;
315
316   /**
317    * Closure for @e cb
318    */
319   void *cb_cls;
320 };
321
322
323 /**
324  * Function called on each plugin in the directory.  Loads
325  * the plugins that match the given basename.
326  *
327  * @param cls the `struct LoadAllContext` describing which
328  *            plugins to load and what to do with them
329  * @param filename name of a plugin library to check
330  * @return #GNUNET_OK (continue loading)
331  */
332 static int
333 find_libraries (void *cls, const char *filename)
334 {
335   struct LoadAllContext *lac = cls;
336   const char *slashpos;
337   const char *libname;
338   char *basename;
339   char *dot;
340   void *lib_ret;
341   size_t n;
342
343   libname = filename;
344   while (NULL != (slashpos = strstr (libname, DIR_SEPARATOR_STR)))
345     libname = slashpos + 1;
346   n = strlen (libname);
347   if (0 != strncmp (lac->basename, libname, strlen (lac->basename)))
348     return GNUNET_OK;           /* wrong name */
349   if ((n > 3) && (0 == strcmp (&libname[n - 3], ".la")))
350     return GNUNET_OK;           /* .la file */
351   basename = GNUNET_strdup (libname);
352   if (NULL != (dot = strstr (basename, ".")))
353     *dot = '\0';
354   lib_ret = GNUNET_PLUGIN_load (basename, lac->arg);
355   if (NULL != lib_ret)
356     lac->cb (lac->cb_cls, basename, lib_ret);
357   GNUNET_free (basename);
358   return GNUNET_OK;
359 }
360
361
362 /**
363  * Load all compatible plugins with the given base name.
364  *
365  * Note that the library must export symbols called
366  * `basename_ANYTHING_init` and `basename_ANYTHING__done`.  These will
367  * be called when the library is loaded and unloaded respectively.
368  *
369  * @param basename basename of the plugins to load
370  * @param arg argument to the plugin initialization function
371  * @param cb function to call for each plugin found
372  * @param cb_cls closure for @a cb
373  */
374 void
375 GNUNET_PLUGIN_load_all (const char *basename, void *arg,
376                         GNUNET_PLUGIN_LoaderCallback cb, void *cb_cls)
377 {
378   struct LoadAllContext lac;
379   char *path;
380
381   path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
382   if (NULL == path)
383   {
384     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
385                 _("Could not determine plugin installation path.\n"));
386     return;
387   }
388   lac.basename = basename;
389   lac.arg = arg;
390   lac.cb = cb;
391   lac.cb_cls = cb_cls;
392   GNUNET_DISK_directory_scan (path, &find_libraries, &lac);
393   GNUNET_free (path);
394 }
395
396
397 /* end of plugin.c */