-bring set/gns into the fold of non-experimental subsystems
[oweals/gnunet.git] / src / transport / gnunet-service-transport_plugins.c
1 /*
2      This file is part of GNUnet.
3      (C) 2010,2011 Christian Grothoff (and other contributing authors)
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      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      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18      Boston, MA 02111-1307, USA.
19 */
20
21 /**
22  * @file transport/gnunet-service-transport_plugins.c
23  * @brief plugin management
24  * @author Christian Grothoff
25  */
26 #include "platform.h"
27 #include "gnunet-service-transport.h"
28 #include "gnunet-service-transport_hello.h"
29 #include "gnunet-service-transport_plugins.h"
30
31 /**
32  * Entry in doubly-linked list of all of our plugins.
33  */
34 struct TransportPlugin
35 {
36   /**
37    * This is a doubly-linked list.
38    */
39   struct TransportPlugin *next;
40
41   /**
42    * This is a doubly-linked list.
43    */
44   struct TransportPlugin *prev;
45
46   /**
47    * API of the transport as returned by the plugin's
48    * initialization function.
49    */
50   struct GNUNET_TRANSPORT_PluginFunctions *api;
51
52   /**
53    * Short name for the plugin (i.e. "tcp").
54    */
55   char *short_name;
56
57   /**
58    * Name of the library (i.e. "gnunet_plugin_transport_tcp").
59    */
60   char *lib_name;
61
62   /**
63    * Environment this transport service is using
64    * for this plugin.
65    */
66   struct GNUNET_TRANSPORT_PluginEnvironment env;
67
68 };
69
70 /**
71  * Head of DLL of all loaded plugins.
72  */
73 static struct TransportPlugin *plugins_head;
74
75 /**
76  * Head of DLL of all loaded plugins.
77  */
78 static struct TransportPlugin *plugins_tail;
79
80
81
82 /**
83  * Load and initialize all plugins.  The respective functions will be
84  * invoked by the plugins when the respective events happen.  The
85  * closure will be set to a 'const char*' containing the name of the
86  * plugin that caused the call.
87  *
88  * @param recv_cb function to call when data is received
89  * @param address_cb function to call when our public addresses changed
90  * @param session_start_cb function to call when a session was created
91  * @param session_end_cb function to call when a session was terminated
92  * @param address_type_cb function to call when a address type is requested
93  * @param metric_update_cb function to call when address metrics change
94  */
95 void
96 GST_plugins_load (GNUNET_TRANSPORT_PluginReceiveCallback recv_cb,
97                   GNUNET_TRANSPORT_AddressNotification address_cb,
98                   GNUNET_TRANSPORT_SessionStart session_start_cb,
99                   GNUNET_TRANSPORT_SessionEnd session_end_cb,
100                   GNUNET_TRANSPORT_AddressToType address_type_cb,
101                   GNUNET_TRANSPORT_UpdateAddressMetrics metric_update_cb)
102 {
103   struct TransportPlugin *plug;
104   struct TransportPlugin *next;
105   unsigned long long tneigh;
106   char *libname;
107   char *plugs;
108   char *pos;
109   int fail;
110
111   if (GNUNET_OK !=
112       GNUNET_CONFIGURATION_get_value_number (GST_cfg, "TRANSPORT",
113                                              "NEIGHBOUR_LIMIT", &tneigh))
114   {
115     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
116                 _("Transport service is lacking NEIGHBOUR_LIMIT option.\n"));
117     return;
118   }
119   if (GNUNET_OK !=
120       GNUNET_CONFIGURATION_get_value_string (GST_cfg, "TRANSPORT", "PLUGINS",
121                                              &plugs))
122     return;
123   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Starting transport plugins `%s'\n"),
124               plugs);
125   for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
126   {
127     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Loading `%s' transport plugin\n"),
128                 pos);
129     GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", pos);
130     plug = GNUNET_malloc (sizeof (struct TransportPlugin));
131     plug->short_name = GNUNET_strdup (pos);
132     plug->lib_name = libname;
133     plug->env.cfg = GST_cfg;
134     plug->env.my_identity = &GST_my_identity;
135     plug->env.get_our_hello = &GST_hello_get;
136     plug->env.cls = plug->short_name;
137     plug->env.receive = recv_cb;
138     plug->env.notify_address = address_cb;
139     plug->env.session_start = session_start_cb;
140     plug->env.session_end = session_end_cb;
141     plug->env.get_address_type = address_type_cb;
142     plug->env.update_address_metrics = metric_update_cb;
143     plug->env.max_connections = tneigh;
144     plug->env.stats = GST_stats;
145     GNUNET_CONTAINER_DLL_insert (plugins_head, plugins_tail, plug);
146   }
147   GNUNET_free (plugs);
148   next = plugins_head;
149   while (next != NULL)
150   {
151     plug = next;
152     next = plug->next;
153     plug->api = GNUNET_PLUGIN_load (plug->lib_name, &plug->env);
154     if (plug->api == NULL)
155     {
156       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
157                   _("Failed to load transport plugin for `%s'\n"),
158                   plug->lib_name);
159       GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
160       GNUNET_free (plug->short_name);
161       GNUNET_free (plug->lib_name);
162       GNUNET_free (plug);
163     }
164     fail = GNUNET_NO;
165     if (NULL == plug->api->address_pretty_printer)
166     {
167         fail = GNUNET_YES;
168       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
169                   _("Missing function `%s' in transport plugin for `%s'\n"),
170                   "address_pretty_printer",
171                   plug->lib_name);
172     }
173     if (NULL == plug->api->address_to_string)
174     {
175         fail = GNUNET_YES;
176       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
177                   _("Missing function `%s' in transport plugin for `%s'\n"),
178                   "address_to_string",
179                   plug->lib_name);
180     }
181     if (NULL == plug->api->string_to_address)
182     {
183         fail = GNUNET_YES;
184       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
185                   _("Missing function `%s' in transport plugin for `%s'\n"),
186                   "string_to_address",
187                   plug->lib_name);
188     }
189     if (NULL == plug->api->check_address)
190     {
191         fail = GNUNET_YES;
192       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
193                   _("Missing function `%s' in transport plugin for `%s'\n"),
194                   "check_address",
195                   plug->lib_name);
196     }
197     if (NULL == plug->api->get_session)
198     {
199         fail = GNUNET_YES;
200       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
201                   _("Missing function `%s' in transport plugin for `%s'\n"),
202                   "get_session",
203                   plug->lib_name);
204     }
205     if (NULL == plug->api->get_network)
206     {
207         fail = GNUNET_YES;
208       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
209                   _("Missing function `%s' in transport plugin for `%s'\n"),
210                   "get_network",
211                   plug->lib_name);
212     }
213     if (NULL == plug->api->send)
214     {
215         fail = GNUNET_YES;
216       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
217                   _("Missing function `%s' in transport plugin for `%s'\n"),
218                   "send",
219                   plug->lib_name);
220     }
221     if (NULL == plug->api->disconnect)
222     {
223         fail = GNUNET_YES;
224       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
225                   _("Missing function `%s' in transport plugin for `%s'\n"),
226                   "disconnect",
227                   plug->lib_name);
228     }
229     if (GNUNET_YES == fail)
230     {
231       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
232                   _("Did not load plugin `%s' due to missing functions\n"),
233                   plug->lib_name);
234       GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
235       GNUNET_free (plug->short_name);
236       GNUNET_free (plug->lib_name);
237       GNUNET_free (plug);
238     }
239   }
240 }
241
242
243 /**
244  * Unload all plugins
245  */
246 void
247 GST_plugins_unload ()
248 {
249   struct TransportPlugin *plug;
250
251   while (NULL != (plug = plugins_head))
252   {
253     GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
254     GNUNET_free (plug->lib_name);
255     GNUNET_free (plug->short_name);
256     GNUNET_CONTAINER_DLL_remove (plugins_head, plugins_tail, plug);
257     GNUNET_free (plug);
258   }
259 }
260
261
262 /**
263  * Obtain the plugin API based on a plugin name.
264  *
265  * @param name name of the plugin
266  * @return the plugin's API, NULL if the plugin is not loaded
267  */
268 struct GNUNET_TRANSPORT_PluginFunctions *
269 GST_plugins_find (const char *name)
270 {
271   struct TransportPlugin *head = plugins_head;
272
273   while ((head != NULL) && (0 != strcmp (name, head->short_name)))
274     head = head->next;
275   if (NULL == head)
276     return NULL;
277   return head->api;
278 }
279
280
281 /**
282  * Obtain the plugin API based on a the stripped plugin name after the underscore.
283  *
284  * Example: GST_plugins_printer_find (http_client) will return all plugins
285  * starting with the prefix "http":
286  * http_client or server if loaded
287  *
288  * @param name name of the plugin
289  * @return the plugin's API, NULL if the plugin is not loaded
290  */
291 struct GNUNET_TRANSPORT_PluginFunctions *
292 GST_plugins_printer_find (const char *name)
293 {
294   struct TransportPlugin *head = plugins_head;
295
296   char *stripped = GNUNET_strdup (name);
297   char *sep = strchr (stripped, '_');
298   if (NULL != sep)
299     sep[0] = '\0';
300
301   while (head != NULL)
302   {
303     if (head->short_name == strstr (head->short_name, stripped))
304         break;
305     head = head->next;
306   }
307   GNUNET_free (stripped);
308   if (NULL == head)
309     return NULL;
310   return head->api;
311 }
312
313
314 /**
315  * Convert a given address to a human-readable format.  Note that the
316  * return value will be overwritten on the next call to this function.
317  *
318  * @param address the address to convert
319  * @return statically allocated (!) human-readable address
320  */
321 const char *
322 GST_plugins_a2s (const struct GNUNET_HELLO_Address *address)
323 {
324   struct GNUNET_TRANSPORT_PluginFunctions *api;
325   static char unable_to_show[1024];
326
327   if (address == NULL)
328   {
329         GNUNET_break (0); /* a HELLO address cannot be NULL */
330     return "<invalid>";
331   }
332   if (0 == address->address_length)
333     return TRANSPORT_SESSION_INBOUND_STRING; /* Addresse with length 0 are inbound, address->address itself may be NULL */
334   api = GST_plugins_printer_find (address->transport_name);
335   if (NULL == api)
336     return "<plugin unknown>";
337   if (0 == address->address_length)
338   {
339     GNUNET_snprintf (unable_to_show, sizeof (unable_to_show),
340                      "<unable to stringify %u-byte long address of %s transport>",
341                      (unsigned int) address->address_length,
342                      address->transport_name);
343     return unable_to_show;
344   }
345   return api->address_to_string (NULL, address->address,
346                                  address->address_length);
347 }
348
349
350 /* end of file gnunet-service-transport_plugins.c */