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
#include "platform.h"
#include "gnunet_protocols.h"
-#include "gnunet_network_lib.h"
+#include "gnunet_connection_lib.h"
#include "gnunet_server_lib.h"
#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 LOG(kind,...) GNUNET_log_from (kind, "transport-template",__VA_ARGS__)
/**
* After how long do we expire an address that we
*/
#define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6)
+#define PLUGIN_NAME "template"
/**
* Encapsulation of all of the state of the 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.
*/
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?
*/
};
+#define GNUNET_NETWORK_STRUCT_BEGIN
+
+struct TemplateAddress
+{
+ /**
+ * Address options in NBO
+ */
+ uint32_t options GNUNET_PACKED;
+
+ /* Add address here */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
/**
* Encapsulation of all of the state of the plugin.
*/
struct Session *sessions;
/**
- * Handle for the statistics service.
+ * Options in HBO to be used with addresses
*/
- struct GNUNET_STATISTICS_Handle *statistics;
};
-
-/**
- * Function that can be used by the transport service to transmit
- * a message using the plugin using a fresh connection (even if
- * we already have a connection to this peer, this function is
- * required to establish a new one).
- *
- * @param cls closure
- * @param target who should receive this message
- * @param msg1 first message to transmit
- * @param msg2 second message to transmit (can be NULL)
- * @param timeout how long until we give up?
- * @param addr the address
- * @param addrlen length of the address
- * @return non-null session if the transmission has been scheduled
- * NULL if the address format is invalid
- */
-static void *
-template_plugin_send_to (void *cls,
- const struct GNUNET_PeerIdentity *target,
- const struct GNUNET_MessageHeader *msg1,
- const struct GNUNET_MessageHeader *msg2,
- struct GNUNET_TIME_Relative timeout,
- const void *addr, size_t addrlen)
-{
- // FIXME
- return NULL;
-}
-
-
/**
* 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 plugin_context value we were asked to pass to this plugin
- * to respond to the given peer (use is optional,
- * but may speed up processing), can be NULL
- * @param service_context value passed to the transport-service
- * to identify the neighbour
- * @param target who should receive this message
- * @param msg the message to transmit
+ * @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 plugin_context that should be used next time for
- * sending messages to the specified peer
+ * @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 void *
+static ssize_t
template_plugin_send (void *cls,
- void *plugin_context,
- struct ReadyList *service_context,
- const struct GNUNET_PeerIdentity *target,
- const struct GNUNET_MessageHeader *msg,
- struct GNUNET_TIME_Relative timeout,
- 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;
- return NULL;
+ struct Plugin *plugin = cls;
+ int bytes_sent = 0;
+
+ GNUNET_assert (plugin != NULL);
+ GNUNET_assert (session != NULL);
+
+ /* struct Plugin *plugin = cls; */
+ return bytes_sent;
}
/**
+ * Function that can be used to force the plugin to disconnect
+ * from the given peer and cancel all previous transmissions
+ * (and their continuationc).
*
* @param cls closure
- * @param plugin_context value we were asked to pass to this plugin
- * to respond to the given peer (use is optional,
- * but may speed up processing), can be NULL (if
- * NULL was returned from the transmit function)
- * @param service_context must correspond to the service context
- * of the corresponding Transmit call; the plugin should
- * not cancel a send call made with a different service
- * context pointer! Never NULL.
- * @param target peer for which the last transmission is
- * to be cancelled
+ * @param target peer from which to disconnect
*/
static void
-template_plugin_cancel (void *cls,
- void *plugin_context,
- struct ReadyList *service_context,
- const struct GNUNET_PeerIdentity *target)
+template_plugin_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
{
// struct Plugin *plugin = cls;
// FIXME
}
+/**
+ * Function obtain the network type for a session
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param session the session
+ * @return the network type in HBO or GNUNET_SYSERR
+ */
+static enum GNUNET_ATS_Network_Type
+template_plugin_get_network (void *cls,
+ struct Session *session)
+{
+ GNUNET_assert (NULL != session);
+ return GNUNET_ATS_NET_UNSPECIFIED; /* Change to correct network type */
+}
+
+
/**
* Convert the transports address to a nice, human-readable
* format.
*
* @param cls closure
- * @param name name of the transport that generated the address
+ * @param type name of the transport that generated the address
* @param addr one of the addresses of the host, NULL for the last address
* the specific address format depends on the transport
* @param addrlen length of the address
* @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
asc, void *asc_cls)
{
+ if (0 == addrlen)
+ {
+ asc (asc_cls, TRANSPORT_SESSION_INBOUND_STRING);
+ }
+
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 peer 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!
-}
/**
* and transport
*/
static int
-template_plugin_address_suggested (void *cls,
- const void *addr, size_t addrlen)
+template_plugin_address_suggested (void *cls, const void *addr, size_t addrlen)
{
- // struct Plugin *plugin = cls;
+ /* struct Plugin *plugin = cls; */
- /* check if the address is plausible; if so,
- add it to our list! */
- // FIXME!
+ /* check if the address is belonging to the plugin*/
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)
+{
+ /*
+ * Print address in format template.options.address
+ */
+
+ if (0 == addrlen)
+ {
+ return TRANSPORT_SESSION_INBOUND_STRING;
+ }
+
+ 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)
+{
+
+ /*
+ * Parse string in format template.options.address
+ */
+
+
+ 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.
*/
void *
-gnunet_plugin_transport_template_init (void *cls)
+libgnunet_plugin_transport_template_init (void *cls)
{
struct GNUNET_TRANSPORT_PluginEnvironment *env = 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_to = &template_plugin_send_to;
api->send = &template_plugin_send;
- api->cancel = &template_plugin_cancel;
+ api->disconnect = &template_plugin_disconnect;
api->address_pretty_printer = &template_plugin_address_pretty_printer;
- api->set_receive_quota = &template_plugin_set_receive_quota;
- api->address_suggested = &template_plugin_address_suggested;
- api->cost_estimate = 42; // FIXME
+ 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;
+ api->get_network = &template_plugin_get_network;
+ LOG (GNUNET_ERROR_TYPE_INFO, "Template plugin successfully loaded\n");
return api;
}
* Exit point from the plugin.
*/
void *
-gnunet_plugin_transport_template_done (void *cls)
+libgnunet_plugin_transport_template_done (void *cls)
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;