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 options routing options for this message
  43  * @param type type of the value
  44  * @param size number of bytes in data; must be less than 64k
  45  * @param data the data to store
  46  * @param exp desired expiration time for the value
  47  * @param timeout how long to wait for transmission of this request
  48  * @param cont continuation to call when done (transmitting request to service)
  49  * @param cont_cls closure for cont
  50  * @return GNUNET_YES if put message is queued for transmission
  51  */
  52 void
  53 GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle,
  54                 const GNUNET_HashCode * key,
  55                 enum GNUNET_DHT_RouteOption options,
  56                 enum GNUNET_BLOCK_Type type,
  57                 size_t size,
  58                 const char *data,
  59                 struct GNUNET_TIME_Absolute exp,
  60                 struct GNUNET_TIME_Relative timeout,
  61                 GNUNET_SCHEDULER_Task cont,
  62                 void *cont_cls)
  63 {
  64   char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
  65   struct GNUNET_DHT_PutMessage *put_msg;
  66
  67   if (size >= sizeof (buf) - sizeof (struct GNUNET_DHT_PutMessage))
  68     {
  69       GNUNET_break (0);
  70       return;
  71     }
  72   put_msg = (struct GNUNET_DHT_PutMessage*) buf;
  73   put_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_PUT);
  74   put_msg->header.size = htons (sizeof (struct GNUNET_DHT_PutMessage) + size);
  75   put_msg->type = htons (type);
  76   put_msg->expiration = GNUNET_TIME_absolute_hton (exp);
  77   memcpy (&put_msg[1], data, size);
  78   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  79               "Starting route for %u byte `%s' message\n",
  80               (unsigned int) (sizeof (struct GNUNET_DHT_PutMessage) + size),
  81               "PUT");
  82   GNUNET_break (NULL ==
  83                 GNUNET_DHT_route_start (handle,
  84                                         key,
  85                                         DEFAULT_PUT_REPLICATION, options,
  86                                         &put_msg->header,
  87                                         timeout,
  88                                         NULL, NULL,
  89                                         cont, cont_cls));
  90 }
  91
  92
  93
  94 /**
  95  * Handle to control a get operation.
  96  */
  97 struct GNUNET_DHT_GetHandle
  98 {
  99   /**
 100    * Handle to the actual route operation for the get
 101    */
 102   struct GNUNET_DHT_RouteHandle *route_handle;
 103
 104   /**
 105    * Iterator to call on data receipt
 106    */
 107   GNUNET_DHT_GetIterator iter;
 108
 109   /**
 110    * Closure for the iterator callback
 111    */
 112   void *iter_cls;
 113
 114 };
 115
 116
 117
 118 /**
 119  * Iterator called on each result obtained from a generic route
 120  * operation
 121  *
 122  * @param cls the 'struct GNUNET_DHT_GetHandle'
 123  * @param key key that was used
 124  * @param reply response
 125  */
 126 static void
 127 get_reply_iterator (void *cls,
 128                     const GNUNET_HashCode *key,
 129                     const struct GNUNET_MessageHeader *reply)
 130 {
 131   struct GNUNET_DHT_GetHandle *get_handle = cls;
 132   const struct GNUNET_DHT_GetResultMessage *result;
 133   const struct GNUNET_PeerIdentity *const*get_path;
 134   const struct GNUNET_PeerIdentity *const*put_path;
 135   size_t payload;
 136
 137   if (ntohs (reply->type) != GNUNET_MESSAGE_TYPE_DHT_GET_RESULT)
 138     {
 139       GNUNET_break (0);
 140       return;
 141     }
 142
 143   GNUNET_assert (ntohs (reply->size) >=
 144                  sizeof (struct GNUNET_DHT_GetResultMessage));
 145   result = (const struct GNUNET_DHT_GetResultMessage *) reply;
 146   payload = ntohs (reply->size) - sizeof(struct GNUNET_DHT_GetResultMessage);
 147   get_path = NULL; // FIXME: parse path info!
 148   put_path = NULL; // FIXME: parse path info!
 149
 150   get_handle->iter (get_handle->iter_cls,
 151                     GNUNET_TIME_absolute_ntoh (result->expiration),
 152                     key,
 153                     get_path,
 154                     put_path,
 155                     ntohs (result->type),
 156                     payload,
 157                     &result[1]);
 158 }
 159
 160
 161
 162 /**
 163  * Perform an asynchronous GET operation on the DHT identified. See
 164  * also "GNUNET_BLOCK_evaluate".
 165  *
 166  * @param handle handle to the DHT service
 167  * @param timeout how long to wait for transmission of this request to the service
 168  * @param type expected type of the response object
 169  * @param key the key to look up
 170  * @param options routing options for this message
 171  * @param bf bloom filter associated with query (can be NULL)
 172  * @param bf_mutator mutation value for bf
 173  * @param xquery extrended query data (can be NULL, depending on type)
 174  * @param xquery_size number of bytes in xquery
 175  * @param iter function to call on each result
 176  * @param iter_cls closure for iter
 177  *
 178  * @return handle to stop the async get
 179  */
 180 struct GNUNET_DHT_GetHandle *
 181 GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,
 182                       struct GNUNET_TIME_Relative timeout,
 183                       enum GNUNET_BLOCK_Type type,
 184                       const GNUNET_HashCode * key,
 185                       enum GNUNET_DHT_RouteOption options,
 186                       const struct GNUNET_CONTAINER_BloomFilter *bf,
 187                       int32_t bf_mutator,
 188                       const void *xquery,
 189                       size_t xquery_size,
 190                       GNUNET_DHT_GetIterator iter,
 191                       void *iter_cls)
 192 {
 193   struct GNUNET_DHT_GetHandle *get_handle;
 194   struct GNUNET_DHT_GetMessage get_msg;
 195
 196   /* FIXME: transmit bf, mutator, xquery & xquery_size as well... */
 197   get_handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_GetHandle));
 198   get_handle->iter = iter;
 199   get_handle->iter_cls = iter_cls;
 200   get_msg.header.type = htons (GNUNET_MESSAGE_TYPE_DHT_GET);
 201   get_msg.header.size = htons (sizeof (struct GNUNET_DHT_GetMessage));
 202   get_msg.type = htons (type);
 203   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 204               "Starting route for %u byte `%s' message\n",
 205               (unsigned int) sizeof (struct GNUNET_DHT_GetMessage),
 206               "GET");
 207   get_handle->route_handle =
 208     GNUNET_DHT_route_start (handle,
 209                             key,
 210                             DEFAULT_GET_REPLICATION,
 211                             options,
 212                             &get_msg.header,
 213                             timeout,
 214                             &get_reply_iterator, get_handle,
 215                             NULL, NULL);
 216   GNUNET_break (NULL != get_handle->route_handle);
 217   return get_handle;
 218 }
 219
 220
 221 /**
 222  * Stop async DHT-get.
 223  *
 224  * @param get_handle handle to the GET operation to stop
 225  */
 226 void
 227 GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
 228 {
 229   GNUNET_DHT_route_stop (get_handle->route_handle);
 230   GNUNET_free (get_handle);
 231 }
 232
 233
 234 /* end of dht_api_get_put.c */