X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fplugin_transport_template.c;h=8c15f877848c8c8121296c4ab33bc8aadb4a3739;hb=1947bc8ef4eb37738ffc1c566d9c6f96071b29f7;hp=bac9bcd82a6fe2c2a469a4e5d959d788c57dc03c;hpb=a8a8461c3e3f9f60a99cb7f1f15abb3fb3ebfdf2;p=oweals%2Fgnunet.git diff --git a/src/transport/plugin_transport_template.c b/src/transport/plugin_transport_template.c index bac9bcd82..8c15f8778 100644 --- a/src/transport/plugin_transport_template.c +++ b/src/transport/plugin_transport_template.c @@ -4,7 +4,7 @@ GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 2, or (at your + by the Free Software Foundation; either version 3, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but @@ -31,9 +31,9 @@ #include "gnunet_service_lib.h" #include "gnunet_statistics_service.h" #include "gnunet_transport_service.h" -#include "plugin_transport.h" +#include "gnunet_transport_plugin.h" -#define DEBUG_TEMPLATE GNUNET_NO +#define DEBUG_TEMPLATE GNUNET_EXTRA_LOGGING /** * After how long do we expire an address that we @@ -54,6 +54,11 @@ struct Plugin; */ struct Session { + /** + * To whom are we talking to (set to our identity + * if we are still waiting for the welcome message) + */ + struct GNUNET_PeerIdentity sender; /** * Stored in a linked list. @@ -82,12 +87,6 @@ struct Session */ void *transmit_cont_cls; - /** - * To whom are we talking to (set to our identity - * if we are still waiting for the welcome message) - */ - struct GNUNET_PeerIdentity sender; - /** * At what time did we reset last_received last? */ @@ -122,43 +121,50 @@ struct Plugin */ struct Session *sessions; - /** - * Handle for the statistics service. - */ - struct GNUNET_STATISTICS_Handle *statistics; - }; + /** * Function that can be used by the transport service to transmit - * a message using the plugin. + * a message using the plugin. Note that in the case of a + * peer disconnecting, the continuation MUST be called + * prior to the disconnect notification itself. This function + * will be called with this peer's HELLO message to initiate + * a fresh connection to another peer. * * @param cls closure - * @param target who should receive this message - * @param priority how important is the message - * @param msg the message to transmit - * @param timeout when should we time out + * @param session which session must be used + * @param msgbuf the message to transmit + * @param msgbuf_size number of bytes in 'msgbuf' + * @param priority how important is the message (most plugins will + * ignore message priority and just FIFO) + * @param to how long to wait at most for the transmission (does not + * require plugins to discard the message after the timeout, + * just advisory for the desired delay; most plugins will ignore + * this as well) * @param cont continuation to call once the message has * been transmitted (or if the transport is ready * for the next transmission call; or if the - * peer disconnected...) + * peer disconnected...); can be NULL * @param cont_cls closure for cont + * @return number of bytes used (on the physical network, with overheads); + * -1 on hard errors (i.e. address invalid); 0 is a legal value + * and does NOT mean that the message was not transmitted (DV) */ static ssize_t template_plugin_send (void *cls, - const struct GNUNET_PeerIdentity * - target, - const char *msgbuf, - size_t msgbuf_size, - unsigned int priority, - struct GNUNET_TIME_Relative timeout, - const void *addr, - size_t addrlen, - int force_address, - GNUNET_TRANSPORT_TransmitContinuation - cont, void *cont_cls) + struct Session *session, + const char *msgbuf, size_t msgbuf_size, + unsigned int priority, + struct GNUNET_TIME_Relative to, + GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) { + struct Plugin *plugin = cls; int bytes_sent = 0; + + GNUNET_assert (plugin != NULL); + GNUNET_assert (session != NULL); + /* struct Plugin *plugin = cls; */ return bytes_sent; } @@ -174,8 +180,7 @@ template_plugin_send (void *cls, * @param target peer from which to disconnect */ static void -template_plugin_disconnect (void *cls, - const struct GNUNET_PeerIdentity *target) +template_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) { // struct Plugin *plugin = cls; // FIXME @@ -197,10 +202,8 @@ template_plugin_disconnect (void *cls, * @param asc_cls closure for asc */ static void -template_plugin_address_pretty_printer (void *cls, - const char *type, - const void *addr, - size_t addrlen, +template_plugin_address_pretty_printer (void *cls, const char *type, + const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback @@ -209,23 +212,6 @@ template_plugin_address_pretty_printer (void *cls, asc (asc_cls, NULL); } -/** - * Set a quota for receiving data from the given peer; this is a - * per-transport limit. The transport should limit its read/select - * calls to stay below the quota (in terms of incoming data). - * - * @param cls closure - * @param target the peer for whom the quota is given - * @param quota_in quota for receiving/sending data in bytes per ms - */ -static void -template_plugin_set_receive_quota (void *cls, - const struct GNUNET_PeerIdentity *target, - uint32_t quota_in) -{ - // struct Plugin *plugin = cls; - // FIXME! -} /** @@ -241,17 +227,73 @@ template_plugin_set_receive_quota (void *cls, * and transport */ static int -template_plugin_address_suggested (void *cls, - void *addr, size_t addrlen) +template_plugin_address_suggested (void *cls, const void *addr, size_t addrlen) { /* struct Plugin *plugin = cls; */ /* check if the address is plausible; if so, - add it to our list! */ + * add it to our list! */ return GNUNET_OK; } +/** + * Function called for a quick conversion of the binary address to + * a numeric address. Note that the caller must not free the + * address and that the next call to this function is allowed + * to override the address again. + * + * @param cls closure + * @param addr binary address + * @param addrlen length of the address + * @return string representing the same address + */ +static const char * +template_plugin_address_to_string (void *cls, const void *addr, size_t addrlen) +{ + GNUNET_break (0); + return NULL; +} + + +/** + * Function called to convert a string address to + * a binary address. + * + * @param cls closure ('struct Plugin*') + * @param addr string address + * @param addrlen length of the address + * @param buf location to store the buffer + * @param added location to store the number of bytes in the buffer. + * If the function returns GNUNET_SYSERR, its contents are undefined. + * @return GNUNET_OK on success, GNUNET_SYSERR on failure + */ +static int +template_plugin_string_to_address (void *cls, const char *addr, uint16_t addrlen, + void **buf, size_t *added) +{ + GNUNET_break (0); + return GNUNET_SYSERR; +} + + +/** + * Create a new session to transmit data to the target + * This session will used to send data to this peer and the plugin will + * notify us by calling the env->session_end function + * + * @param cls closure + * @param address pointer to the GNUNET_HELLO_Address + * @return the session if the address is valid, NULL otherwise + */ +static struct Session * +template_plugin_get_session (void *cls, + const struct GNUNET_HELLO_Address *address) +{ + GNUNET_break (0); + return NULL; +} + /** * Entry point for the plugin. */ @@ -262,16 +304,30 @@ gnunet_plugin_transport_template_init (void *cls) struct GNUNET_TRANSPORT_PluginFunctions *api; struct Plugin *plugin; + if (NULL == env->receive) + { + /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully + initialze the plugin or the API */ + api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); + api->cls = NULL; + api->address_to_string = &template_plugin_address_to_string; + api->string_to_address = &template_plugin_string_to_address; + api->address_pretty_printer = &template_plugin_address_pretty_printer; + return api; + } + plugin = GNUNET_malloc (sizeof (struct Plugin)); plugin->env = env; - plugin->statistics = NULL; api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); api->cls = plugin; api->send = &template_plugin_send; api->disconnect = &template_plugin_disconnect; api->address_pretty_printer = &template_plugin_address_pretty_printer; - api->set_receive_quota = &template_plugin_set_receive_quota; api->check_address = &template_plugin_address_suggested; + api->address_to_string = &template_plugin_address_to_string; + api->string_to_address = &template_plugin_string_to_address; + api->get_session = &template_plugin_get_session; + return api; }