src/dv/plugin_transport_dv.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 2, 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 dv/plugin_transport_dv.c
  23  * @brief DV transport service, takes incoming DV requests and deals with
  24  * the DV service
  25  * @author Christian Grothoff
  26  */
  27
  28 /**
  29  * TODO:
  30  *
  31  * As a start, the dv plugin needs to listen for information from the dv
  32  * service.  The plugin (?) will be notified by core (?) when a tcp/udp/whatever
  33  * message comes in that should be for dv.  The plugin will then hand off the message
  34  * to the dv service which will decrypt/validate the message (?) and then send the
  35  * result back to us (the transport) which will then send the message to the transport
  36  * service (yikes).
  37  *
  38  * Or, core will notify the dv service directly which will validate,
  39  * etc. and then just send a message to us.
  40  *
  41  * For starters, this plugin needs to have a client which will listen for messages from
  42  * the dv service that need to be sent up to the gnunet-transport-service.
  43  *
  44  * Messages sent from the dv transport get passed to the dv service which deals
  45  * with the actual sending (how much state does this transport need? should it know
  46  * which peers it is currently connected to and their distances, or just assume that
  47  * anything should be passed along to the dv service?).
  48  */
  49 #include "platform.h"
  50 #include "gnunet_protocols.h"
  51 #include "gnunet_connection_lib.h"
  52 #include "gnunet_server_lib.h"
  53 #include "gnunet_service_lib.h"
  54 #include "gnunet_statistics_service.h"
  55 #include "gnunet_dv_service.h"
  56 #include "gnunet_transport_service.h"
  57 #include "../transport/plugin_transport.h"
  58 #include "dv.h"
  59
  60 #define DEBUG_TEMPLATE GNUNET_NO
  61
  62 /**
  63  * Encapsulation of all of the state of the plugin.
  64  */
  65 struct Plugin;
  66
  67
  68 /**
  69  * Session handle for connections.
  70  */
  71 struct Session
  72 {
  73
  74   /**
  75    * Stored in a linked list.
  76    */
  77   struct Session *next;
  78
  79   /**
  80    * Pointer to the global plugin struct.
  81    */
  82   struct Plugin *plugin;
  83
  84   /**
  85    * The client (used to identify this connection)
  86    */
  87   /* void *client; */
  88
  89   /**
  90    * Continuation function to call once the transmission buffer
  91    * has again space available.  NULL if there is no
  92    * continuation to call.
  93    */
  94   GNUNET_TRANSPORT_TransmitContinuation transmit_cont;
  95
  96   /**
  97    * Closure for transmit_cont.
  98    */
  99   void *transmit_cont_cls;
 100
 101   /**
 102    * To whom are we talking to (set to our identity
 103    * if we are still waiting for the welcome message)
 104    */
 105   struct GNUNET_PeerIdentity sender;
 106
 107   /**
 108    * At what time did we reset last_received last?
 109    */
 110   struct GNUNET_TIME_Absolute last_quota_update;
 111
 112   /**
 113    * How many bytes have we received since the "last_quota_update"
 114    * timestamp?
 115    */
 116   uint64_t last_received;
 117
 118   /**
 119    * Number of bytes per ms that this peer is allowed
 120    * to send to us.
 121    */
 122   uint32_t quota;
 123
 124 };
 125
 126 /**
 127  * Encapsulation of all of the state of the plugin.
 128  */
 129 struct Plugin
 130 {
 131   /**
 132    * Our environment.
 133    */
 134   struct GNUNET_TRANSPORT_PluginEnvironment *env;
 135
 136   /**
 137    * List of open sessions.
 138    */
 139   struct Session *sessions;
 140
 141   /**
 142    * Our server.
 143    */
 144   //struct GNUNET_SERVER_Handle *server;
 145
 146   /*
 147    * Handle to the running service.
 148    */
 149   //struct GNUNET_SERVICE_Context *service;
 150
 151   /**
 152    * Copy of the handler array where the closures are
 153    * set to this struct's instance.
 154    */
 155   struct GNUNET_SERVER_MessageHandler *handlers;
 156
 157   /**
 158    * Handle to the DV service
 159    */
 160   struct GNUNET_DV_Handle *dv_handle;
 161
 162 };
 163
 164 /**
 165  * Handler for messages received from the DV service.
 166  */
 167 void handle_dv_message_received (void *cls,
 168                                  struct GNUNET_PeerIdentity *sender,
 169                                  char *msg,
 170                                  size_t msg_len,
 171                                  uint32_t distance,
 172                                  char *sender_address,
 173                                  size_t sender_address_len)
 174 {
 175   struct Plugin *plugin = cls;
 176 #if DEBUG_DV_MESSAGES
 177   char *my_id;
 178   my_id = GNUNET_strdup(GNUNET_i2s(plugin->env->my_identity));
 179   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
 180                    "plugin_transport_dv",
 181                    _("%s Received message from %s) of type %d, distance %u!\n"),
 182                    my_id, GNUNET_i2s(sender), ntohs(((struct GNUNET_MessageHeader *)msg)->type), distance);
 183   GNUNET_free_non_null(my_id);
 184 #endif
 185   plugin->env->receive(plugin->env->cls,
 186                        sender,
 187                        (struct GNUNET_MessageHeader *)msg,
 188                        distance,
 189                        NULL,
 190                        sender_address,
 191                        sender_address_len);
 192
 193 }
 194
 195
 196 /* Question: how does the transport service learn of a newly connected (gossipped about)
 197  * DV peer?  Should the plugin (here) create a HELLO for that peer and send it along,
 198  * or should the DV service create a HELLO and send it to us via the other part?
 199  */
 200
 201 /**
 202  * Function that can be used by the transport service to transmit
 203  * a message using the plugin.
 204  *
 205  * @param cls closure
 206  * @param target who should receive this message
 207  * @param priority how important is the message
 208  * @param msgbuf the message to transmit
 209  * @param msgbuf_size number of bytes in 'msgbuf'
 210  * @param timeout when should we time out
 211  * @param session the session used
 212  * @param addr the address to use (can be NULL if the plugin
 213  *                is "on its own" (i.e. re-use existing TCP connection))
 214  * @param addrlen length of the address in bytes
 215  * @param force_address GNUNET_YES if the plugin MUST use the given address,
 216  *                otherwise the plugin may use other addresses or
 217  *                existing connections (if available)
 218  * @param cont continuation to call once the message has
 219  *        been transmitted (or if the transport is ready
 220  *        for the next transmission call; or if the
 221  *        peer disconnected...)
 222  * @param cont_cls closure for cont
 223  * @return number of bytes used (on the physical network, with overheads);
 224  *         -1 on hard errors (i.e. address invalid); 0 is a legal value
 225  *         and does NOT mean that the message was not transmitted (DV)
 226  */
 227 static ssize_t
 228 dv_plugin_send (void *cls,
 229                 const struct GNUNET_PeerIdentity *target,
 230                 const char *msgbuf,
 231                 size_t msgbuf_size,
 232                 unsigned int priority,
 233                 struct GNUNET_TIME_Relative timeout,
 234                 struct Session *session,
 235                 const void *addr,
 236                 size_t addrlen,
 237                 int force_address,
 238                 GNUNET_TRANSPORT_TransmitContinuation
 239                 cont, void *cont_cls)
 240 {
 241   int ret = 0;
 242   struct Plugin *plugin = cls;
 243   const char *tempbuf;
 244   int temp_size;
 245 #if DEBUG_DV
 246   char *my_identity;
 247   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DV API: Received send request from transport, calling GNUNET_DV_send\n");
 248   my_identity = GNUNET_strdup(GNUNET_i2s(plugin->env->my_identity));
 249 #endif
 250   temp_size = htons(((struct GNUNET_MessageHeader *)msgbuf)->size);
 251   if (msgbuf_size > temp_size)
 252     {
 253       tempbuf = &msgbuf[temp_size];
 254 #if DEBUG_DV
 255       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));
 256 #endif
 257     }
 258 #if DEBUG_DV
 259   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));
 260 #endif
 261   ret = GNUNET_DV_send(plugin->dv_handle,
 262                        target,
 263                        msgbuf,
 264                        msgbuf_size,
 265                        priority,
 266                        timeout,
 267                        addr,
 268                        addrlen,
 269                        cont,
 270                        cont_cls);
 271 #if DEBUG_DV
 272   GNUNET_free_non_null(my_identity);
 273 #endif
 274
 275   return ret;
 276 }
 277
 278
 279
 280 /**
 281  * Function that can be used to force the plugin to disconnect
 282  * from the given peer and cancel all previous transmissions
 283  * (and their continuations).
 284  *
 285  * @param cls closure
 286  * @param target peer from which to disconnect
 287  */
 288 static void
 289 dv_plugin_disconnect (void *cls,
 290                             const struct GNUNET_PeerIdentity *target)
 291 {
 292   // struct Plugin *plugin = cls;
 293   // TODO: Add message type to send to dv service to "disconnect" a peer
 294 }
 295
 296
 297 /**
 298  * Convert the transports address to a nice, human-readable
 299  * format.
 300  *
 301  * @param cls closure
 302  * @param type name of the transport that generated the address
 303  * @param addr one of the addresses of the host, NULL for the last address
 304  *        the specific address format depends on the transport
 305  * @param addrlen length of the address
 306  * @param numeric should (IP) addresses be displayed in numeric form?
 307  * @param timeout after how long should we give up?
 308  * @param asc function to call on each string
 309  * @param asc_cls closure for asc
 310  */
 311 static void
 312 dv_plugin_address_pretty_printer (void *cls,
 313                                   const char *type,
 314                                   const void *addr,
 315                                   size_t addrlen,
 316                                   int numeric,
 317                                   struct GNUNET_TIME_Relative timeout,
 318                                   GNUNET_TRANSPORT_AddressStringCallback
 319                                   asc, void *asc_cls)
 320 {
 321   asc (asc_cls, NULL);
 322 }
 323
 324 /**
 325  * Convert the DV address to a pretty string.
 326  *
 327  * @param cls closure
 328  * @param addr the (hopefully) DV address
 329  * @param addrlen the length of the address
 330  *
 331  * @return string representing the DV address
 332  */
 333 static const char *address_to_string (void *cls,
 334                                        const void *addr,
 335                                        size_t addrlen)
 336 {
 337   static char return_buffer[2 * 4 + 2]; // Two four character peer identity prefixes a ':' and '\0'
 338
 339   struct GNUNET_CRYPTO_HashAsciiEncoded peer_hash;
 340   struct GNUNET_CRYPTO_HashAsciiEncoded via_hash;
 341   struct GNUNET_PeerIdentity *peer;
 342   struct GNUNET_PeerIdentity *via;
 343   char *addr_buf = (char *)addr;
 344
 345   if (addrlen == (2 * sizeof(struct GNUNET_PeerIdentity)))
 346     {
 347       peer = (struct GNUNET_PeerIdentity *)addr_buf;
 348       via = (struct GNUNET_PeerIdentity *)&addr_buf[sizeof(struct GNUNET_PeerIdentity)];
 349
 350       GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &peer_hash);
 351       peer_hash.encoding[4] = '\0';
 352       GNUNET_CRYPTO_hash_to_enc (&via->hashPubKey, &via_hash);
 353       via_hash.encoding[4] = '\0';
 354       GNUNET_snprintf (return_buffer,
 355                        sizeof (return_buffer),
 356                        "%s:%s",
 357                        &peer_hash,
 358                        &via_hash);
 359     }
 360   else
 361     return NULL;
 362
 363   return return_buffer;
 364 }
 365
 366 /**
 367  * Another peer has suggested an address for this
 368  * peer and transport plugin.  Check that this could be a valid
 369  * address.  If so, consider adding it to the list
 370  * of addresses.
 371  *
 372  * @param cls closure
 373  * @param addr pointer to the address
 374  * @param addrlen length of addr
 375  * @return GNUNET_OK if this is a plausible address for this peer
 376  *         and transport
 377  *
 378  * FIXME: does this mean anything for the DV plugin?
 379  */
 380 static int
 381 dv_plugin_address_suggested (void *cls,
 382                                   void *addr, size_t addrlen)
 383 {
 384   /* struct Plugin *plugin = cls; */
 385
 386   /* check if the address is plausible; if so,
 387      add it to our list! */
 388   return GNUNET_NO;
 389 }
 390
 391
 392 /**
 393  * Entry point for the plugin.
 394  */
 395 void *
 396 libgnunet_plugin_transport_dv_init (void *cls)
 397 {
 398   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
 399   struct GNUNET_TRANSPORT_PluginFunctions *api;
 400   struct Plugin *plugin;
 401
 402   plugin = GNUNET_malloc (sizeof (struct Plugin));
 403   plugin->env = env;
 404   //plugin->service = service;
 405   //plugin->server = GNUNET_SERVICE_get_server (service);
 406
 407   plugin->dv_handle = GNUNET_DV_connect(env->sched, env->cfg, &handle_dv_message_received, plugin);
 408
 409   if (plugin->dv_handle == NULL)
 410   {
 411     GNUNET_free(plugin);
 412     return NULL;
 413   }
 414
 415   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
 416   api->cls = plugin;
 417   api->send = &dv_plugin_send;
 418   api->disconnect = &dv_plugin_disconnect;
 419   api->address_pretty_printer = &dv_plugin_address_pretty_printer;
 420   api->check_address = &dv_plugin_address_suggested;
 421   api->address_to_string = &address_to_string;
 422   return api;
 423 }
 424
 425
 426 /**
 427  * Exit point from the plugin.
 428  */
 429 void *
 430 libgnunet_plugin_transport_dv_done (void *cls)
 431 {
 432   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
 433   struct Plugin *plugin = api->cls;
 434
 435   GNUNET_free (plugin);
 436   GNUNET_free (api);
 437   return NULL;
 438 }
 439
 440 /* end of plugin_transport_template.c */