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
* @file dv/plugin_transport_dv.c
* @brief DV transport service, takes incoming DV requests and deals with
* the DV service
+ * @author Nathan Evans
* @author Christian Grothoff
*/
-/**
- * TODO:
- *
- * As a start, the dv plugin needs to listen for information from the dv
- * service. The plugin (?) will be notified by core (?) when a tcp/udp/whatever
- * message comes in that should be for dv. The plugin will then hand off the message
- * to the dv service which will decrypt/validate the message (?) and then send the
- * result back to us (the transport) which will then send the message to the transport
- * service (yikes).
- *
- * Or, core will notify the dv service directly which will validate,
- * etc. and then just send a message to us.
- *
- * For starters, this plugin needs to have a client which will listen for messages from
- * the dv service that need to be sent up to the gnunet-transport-service.
- *
- * Messages sent from the dv transport get passed to the dv service which deals
- * with the actual sending (how much state does this transport need? should it know
- * which peers it is currently connected to and their distances, or just assume that
- * anything should be passed along to the dv service?).
- */
#include "platform.h"
#include "gnunet_protocols.h"
#include "gnunet_connection_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_dv_service.h"
#include "gnunet_transport_service.h"
-#include "../transport/plugin_transport.h"
+#include "gnunet_transport_plugin.h"
#include "dv.h"
#define DEBUG_TEMPLATE GNUNET_NO
my_id = GNUNET_strdup(GNUNET_i2s(plugin->env->my_identity));
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
"plugin_transport_dv",
- _("%s Received message from %s) of type %d, distance %u!\n"),
+ _("%s Received message from %s of type %d, distance %u!\n"),
my_id, GNUNET_i2s(sender), ntohs(((struct GNUNET_MessageHeader *)msg)->type), distance);
GNUNET_free_non_null(my_id);
#endif
+ struct GNUNET_TRANSPORT_ATS_Information ats[2];
+ ats[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
+ ats[0].value = htonl (distance);
+ ats[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
+ ats[1].value = htonl (0);
+
plugin->env->receive(plugin->env->cls,
sender,
(struct GNUNET_MessageHeader *)msg,
- distance,
- NULL,
+ (const struct GNUNET_TRANSPORT_ATS_Information *) &ats,
+ 2,
+ NULL,
sender_address,
sender_address_len);
{
int ret = 0;
struct Plugin *plugin = cls;
- const char *tempbuf;
- int temp_size;
-#if DEBUG_DV
- char *my_identity;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: Received send request from transport, calling GNUNET_DV_send\n");
- my_identity = GNUNET_strdup(GNUNET_i2s(plugin->env->my_identity));
-#endif
- temp_size = htons(((struct GNUNET_MessageHeader *)msgbuf)->size);
- if (msgbuf_size > temp_size)
- {
- tempbuf = &msgbuf[temp_size];
-#if DEBUG_DV
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s DV PLUGIN SEND SPECIAL type %d to %s\n", my_identity, ntohs(((struct GNUNET_MessageHeader *)tempbuf)->type), GNUNET_i2s(target));
-#endif
- }
-#if DEBUG_DV
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s DV PLUGIN SEND type %d to %s\n", my_identity, ntohs(((struct GNUNET_MessageHeader *)msgbuf)->type), GNUNET_i2s(target));
-#endif
+
ret = GNUNET_DV_send(plugin->dv_handle,
target,
msgbuf,
addrlen,
cont,
cont_cls);
-#if DEBUG_DV
- GNUNET_free_non_null(my_identity);
-#endif
-
return ret;
}
*/
static void
dv_plugin_disconnect (void *cls,
- const struct GNUNET_PeerIdentity *target)
+ const struct GNUNET_PeerIdentity *target)
{
// struct Plugin *plugin = cls;
// TODO: Add message type to send to dv service to "disconnect" a peer
GNUNET_TRANSPORT_AddressStringCallback
asc, void *asc_cls)
{
- asc (asc_cls, NULL);
+ char *dest_peer;
+ char *via_peer;
+ char *print_string;
+ char *addr_buf = (char *)addr;
+
+ if (addrlen != sizeof(struct GNUNET_PeerIdentity) * 2)
+ {
+ asc (asc_cls, NULL);
+ }
+ else
+ {
+ dest_peer = GNUNET_strdup(GNUNET_i2s((struct GNUNET_PeerIdentity *)addr));
+ via_peer = GNUNET_strdup(GNUNET_i2s((struct GNUNET_PeerIdentity *)&addr_buf[sizeof(struct GNUNET_PeerIdentity)]));
+ GNUNET_asprintf(&print_string, "DV Peer `%s' via peer`%s'", dest_peer, via_peer);
+ asc (asc_cls, print_string);
+ asc (asc_cls, NULL);
+ GNUNET_free(via_peer);
+ GNUNET_free(dest_peer);
+ GNUNET_free(print_string);
+ }
}
/**
}
/**
- * Another peer has suggested an address for this
- * peer and transport plugin. Check that this could be a valid
- * address. If so, consider adding it to the list
- * of addresses.
+ * Another peer has suggested an address for this peer and transport
+ * plugin. Check that this could be a valid address. This function
+ * is not expected to 'validate' the address in the sense of trying to
+ * connect to it but simply to see if the binary format is technically
+ * legal for establishing a connection to this peer (and make sure that
+ * the address really corresponds to our network connection/settings
+ * and not some potential man-in-the-middle).
*
* @param cls closure
* @param addr pointer to the address
* @param addrlen length of addr
* @return GNUNET_OK if this is a plausible address for this peer
- * and transport
+ * and transport, GNUNET_SYSERR if not
*
- * FIXME: does this mean anything for the DV plugin?
*/
static int
-dv_plugin_address_suggested (void *cls,
- void *addr, size_t addrlen)
+dv_plugin_check_address (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! */
- return GNUNET_NO;
+ struct Plugin *plugin = cls;
+ /* Verify that the first peer of this address matches our peer id! */
+ if ((addrlen != (2 * sizeof(struct GNUNET_PeerIdentity))) || (0 != memcmp(addr, plugin->env->my_identity, sizeof(struct GNUNET_PeerIdentity))))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Address not correct size or identity doesn't match ours!\n", GNUNET_i2s(plugin->env->my_identity));
+ if (addrlen == (2 * sizeof(struct GNUNET_PeerIdentity)))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer in address is %s\n", GNUNET_i2s(addr));
+ }
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
}
plugin = GNUNET_malloc (sizeof (struct Plugin));
plugin->env = env;
- //plugin->service = service;
- //plugin->server = GNUNET_SERVICE_get_server (service);
- plugin->dv_handle = GNUNET_DV_connect(env->sched, env->cfg, &handle_dv_message_received, plugin);
+ plugin->dv_handle = GNUNET_DV_connect(env->cfg, &handle_dv_message_received, plugin);
if (plugin->dv_handle == NULL)
{
api->send = &dv_plugin_send;
api->disconnect = &dv_plugin_disconnect;
api->address_pretty_printer = &dv_plugin_address_pretty_printer;
- api->check_address = &dv_plugin_address_suggested;
+ api->check_address = &dv_plugin_check_address;
api->address_to_string = &address_to_string;
return api;
}
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
+ if (plugin->dv_handle != NULL)
+ GNUNET_DV_disconnect(plugin->dv_handle);
+
GNUNET_free (plugin);
GNUNET_free (api);
return NULL;