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"
*/
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 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 priority how important is the 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,
- unsigned int priority,
- 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.
*
* @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 priority how important is the message
- * @param msg the message to transmit
+ * @param msgbuf the message to transmit
+ * @param msgbuf_size number of bytes in 'msgbuf'
+ * @param timeout when should we time out
+ * @param session which session must be used (or NULL for "any")
+ * @param addr the address to use (can be NULL if the plugin
+ * is "on its own" (i.e. re-use existing TCP connection))
+ * @param addrlen length of the address in bytes
+ * @param force_address GNUNET_YES if the plugin MUST use the given address,
+ * otherwise the plugin may use other addresses or
+ * existing connections (if available)
* @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...)
* @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,
- unsigned int priority,
- const struct GNUNET_MessageHeader *msg,
+ const struct GNUNET_PeerIdentity *
+ target,
+ const char *msgbuf,
+ size_t msgbuf_size,
+ unsigned int priority,
struct GNUNET_TIME_Relative timeout,
- GNUNET_TRANSPORT_TransmitContinuation cont,
- void *cont_cls)
+ struct Session *session,
+ const void *addr,
+ size_t addrlen,
+ int force_address,
+ GNUNET_TRANSPORT_TransmitContinuation
+ cont, void *cont_cls)
{
- // struct Plugin *plugin = cls;
- return NULL;
+ int bytes_sent = 0;
+ /* 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
* 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
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!
-}
/**
*/
static int
template_plugin_address_suggested (void *cls,
- const void *addr, size_t addrlen)
+ 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!
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;
+}
+
+
+
+
/**
* Entry point for the plugin.
*/
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;
return api;
}
projects / oweals / gnunet.git / blobdiff