src/dht/dht_api_get_put.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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 3, 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 dht/dht_api_get_put.c
  23  * @brief library to perform DHT gets and puts
  24  * @author Christian Grothoff
  25  * @author Nathan Evans
  26  */
  27
  28 #include "platform.h"
  29 #include "gnunet_constants.h"
  30 #include "gnunet_arm_service.h"
  31 #include "gnunet_protocols.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_dht_service.h"
  34 #include "dht.h"
  35
  36
  37 /**
  38  * Perform a PUT operation storing data in the DHT.
  39  *
  40  * @param handle handle to DHT service
  41  * @param key the key to store under
  42  * @param desired_replication_level estimate of how many
  43  *                nearest peers this request should reach
  44  * @param options routing options for this message
  45  * @param type type of the value
  46  * @param size number of bytes in data; must be less than 64k
  47  * @param data the data to store
  48  * @param exp desired expiration time for the value
  49  * @param timeout how long to wait for transmission of this request
  50  * @param cont continuation to call when done (transmitting request to service)
  51  * @param cont_cls closure for cont
  52  * @return GNUNET_YES if put message is queued for transmission
  53  */
  54 void
  55 GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
  56                 const GNUNET_HashCode * key,
  57                 uint32_t desired_replication_level,
  58                 enum GNUNET_DHT_RouteOption options,
  59                 enum GNUNET_BLOCK_Type type,
  60                 size_t size,
  61                 const char *data,
  62                 struct GNUNET_TIME_Absolute exp,
  63                 struct GNUNET_TIME_Relative timeout,
  64                 GNUNET_SCHEDULER_Task cont,
  65                 void *cont_cls)
  66 {
  67   char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
  68   struct GNUNET_DHT_PutMessage *put_msg;
  69
  70   if (size >= sizeof (buf) - sizeof (struct GNUNET_DHT_PutMessage))
  71     {
  72       GNUNET_break (0);
  73       return;
  74     }
  75   put_msg = (struct GNUNET_DHT_PutMessage*) buf;
  76   put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_PUT);
  77   put_msg->header.size = htons (sizeof (struct GNUNET_DHT_PutMessage) + size);
  78   put_msg->type = htonl ((uint32_t)type);
  79   put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
  80   memcpy (&put_msg[1], data, size);
  81   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  82               "Starting route for %u byte `%s' message of type %u \n",
  83               (unsigned int) (sizeof (struct GNUNET_DHT_PutMessage) + size),
  84               "PUT", type);
  85   GNUNET_break (NULL ==
  86                 GNUNET_DHT_route_start (handle,
  87                                         key,
  88                                         desired_replication_level, options,
  89                                         &put_msg->header,
  90                                         timeout,
  91                                         NULL, NULL,
  92                                         cont, cont_cls));
  93 }
  94
  95
  96
  97 /**
  98  * Handle to control a get operation.
  99  */
 100 struct GNUNET_DHT_GetHandle
 101 {
 102   /**
 103    * Handle to the actual route operation for the get
 104    */
 105   struct GNUNET_DHT_RouteHandle *route_handle;
 106
 107   /**
 108    * Iterator to call on data receipt
 109    */
 110   GNUNET_DHT_GetIterator iter;
 111
 112   /**
 113    * Closure for the iterator callback
 114    */
 115   void *iter_cls;
 116
 117 };
 118
 119
 120
 121 /**
 122  * Iterator called on each result obtained from a generic route
 123  * operation
 124  *
 125  * @param cls the 'struct GNUNET_DHT_GetHandle'
 126  * @param key key that was used
 127  * @param get_path NULL-terminated array of pointers
 128  *                 to the peers on reverse GET path (or NULL if not recorded)
 129  * @param put_path NULL-terminated array of pointers
 130  *                 to the peers on the PUT path (or NULL if not recorded)
 131  * @param reply response
 132  */
 133 static void
 134 get_reply_iterator (void *cls,
 135                     const GNUNET_HashCode *key,
 136                     const struct GNUNET_PeerIdentity * const *get_path,
 137                     const struct GNUNET_PeerIdentity * const *put_path,
 138                     const struct GNUNET_MessageHeader *reply)
 139 {
 140   struct GNUNET_DHT_GetHandle *get_handle = cls;
 141   const struct GNUNET_DHT_GetResultMessage *result;
 142   size_t payload;
 143
 144   if (ntohs (reply->type) != GNUNET_MESSAGE_TYPE_DHT_GET_RESULT)
 145     {
 146       GNUNET_break (0);
 147       return;
 148     }
 149
 150   GNUNET_assert (ntohs (reply->size) >=
 151                  sizeof (struct GNUNET_DHT_GetResultMessage));
 152   result = (const struct GNUNET_DHT_GetResultMessage *) reply;
 153   payload = ntohs (reply->size) - sizeof(struct GNUNET_DHT_GetResultMessage);
 154   get_handle->iter (get_handle->iter_cls,
 155                     GNUNET_TIME_absolute_ntoh (result->expiration),
 156                     key,
 157                     get_path,
 158                     put_path,
 159                     ntohs (result->type),
 160                     payload,
 161                     &result[1]);
 162 }
 163
 164
 165
 166 /**
 167  * Perform an asynchronous GET operation on the DHT identified. See
 168  * also "GNUNET_BLOCK_evaluate".
 169  *
 170  * @param handle handle to the DHT service
 171  * @param timeout how long to wait for transmission of this request to the service
 172  * @param type expected type of the response object
 173  * @param key the key to look up
 174  * @param desired_replication_level estimate of how many
 175                   nearest peers this request should reach
 176  * @param options routing options for this message
 177  * @param bf bloom filter associated with query (can be NULL)
 178  * @param bf_mutator mutation value for bf
 179  * @param xquery extended query data (can be NULL, depending on type)
 180  * @param xquery_size number of bytes in xquery
 181  * @param iter function to call on each result
 182  * @param iter_cls closure for iter
 183  *
 184  * @return handle to stop the async get
 185  */
 186 struct GNUNET_DHT_GetHandle *
 187 GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
 188                       struct GNUNET_TIME_Relative timeout,
 189                       enum GNUNET_BLOCK_Type type,
 190                       const GNUNET_HashCode * key,
 191                       uint32_t desired_replication_level,
 192                       enum GNUNET_DHT_RouteOption options,
 193                       const struct GNUNET_CONTAINER_BloomFilter *bf,
 194                       int32_t bf_mutator,
 195                       const void *xquery,
 196                       size_t xquery_size,
 197                       GNUNET_DHT_GetIterator iter,
 198                       void *iter_cls)
 199 {
 200   struct GNUNET_DHT_GetHandle *get_handle;
 201   char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
 202   struct GNUNET_DHT_GetMessage *get_msg;
 203   size_t bf_size;
 204
 205   bf_size = GNUNET_CONTAINER_bloomfilter_get_size (bf);
 206   if ( (sizeof (buf) <=
 207         sizeof (struct GNUNET_DHT_GetMessage) + xquery_size + bf_size) ||
 208        (sizeof (buf) <= bf_size))
 209     {
 210       GNUNET_break (0);
 211       return NULL;
 212     }
 213   get_handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_GetHandle));
 214   get_handle->iter = iter;
 215   get_handle->iter_cls = iter_cls;
 216   get_msg = (struct GNUNET_DHT_GetMessage*) buf;
 217   get_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_GET);
 218   get_msg->header.size = htons (sizeof (struct GNUNET_DHT_GetMessage) +
 219                                 xquery_size +
 220                                 bf_size);
 221   get_msg->type = htonl ((uint32_t) type);
 222   get_msg->bf_mutator = bf_mutator;
 223   get_msg->xquery_size = htons ((uint16_t) xquery_size);
 224   get_msg->bf_size = htons (bf_size);
 225   if (xquery != NULL)
 226     memcpy (&buf[sizeof(struct GNUNET_DHT_GetMessage)],
 227             xquery,
 228             xquery_size);
 229   else
 230     GNUNET_assert (xquery_size == 0);
 231   (void) GNUNET_CONTAINER_bloomfilter_get_raw_data (bf,
 232                                                     &buf[sizeof(struct GNUNET_DHT_GetMessage) + xquery_size],
 233                                                     bf_size);
 234   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 235               "Starting route for %u byte `%s' message\n",
 236               (unsigned int) (sizeof (struct GNUNET_DHT_GetMessage) + xquery_size + bf_size) ,
 237               "GET");
 238   get_handle->route_handle =
 239     GNUNET_DHT_route_start (handle,
 240                             key,
 241                             desired_replication_level,
 242                             options,
 243                             &get_msg->header,
 244                             timeout,
 245                             &get_reply_iterator, get_handle,
 246                             NULL, NULL);
 247   GNUNET_break (NULL != get_handle->route_handle);
 248   return get_handle;
 249 }
 250
 251
 252 /**
 253  * Stop async DHT-get.
 254  *
 255  * @param get_handle handle to the GET operation to stop
 256  *
 257  * On return get_handle will no longer be valid, caller
 258  * must not use again!!!
 259  */
 260 void
 261 GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
 262 {
 263   GNUNET_DHT_route_stop (get_handle->route_handle);
 264   GNUNET_free (get_handle);
 265 }
 266
 267
 268 /* end of dht_api_get_put.c */