自学教程：C++ GNUNET_h2s函数代码示例

static voidkey_iterator (void *cls, const struct GNUNET_HashCode *key,	      const char *proof,              int accepting, unsigned int num_edges,              const struct REGEX_BLOCK_Edge *edges){  unsigned int i;  struct IteratorContext *ctx = cls;  char *out_str;  char *state_id = GNUNET_strdup (GNUNET_h2s (key));  GNUNET_assert (NULL != proof);  if (GNUNET_YES == ctx->should_save_graph)  {    if (GNUNET_YES == accepting)      GNUNET_asprintf (&out_str, "/"%s/" [shape=doublecircle]/n", state_id);    else      GNUNET_asprintf (&out_str, "/"%s/" [shape=circle]/n", state_id);    fwrite (out_str, strlen (out_str), 1, ctx->graph_filep);    GNUNET_free (out_str);    for (i = 0; i < num_edges; i++)    {      transition_counter++;      GNUNET_asprintf (&out_str, "/"%s/" -> /"%s/" [label = /"%s (%s)/"]/n",                       state_id, GNUNET_h2s (&edges[i].destination),                       edges[i].label, proof);      fwrite (out_str, strlen (out_str), 1, ctx->graph_filep);      GNUNET_free (out_str);    }  }  else  {    for (i = 0; i < num_edges; i++)      transition_counter++;  }  for (i = 0; i < ctx->string_count; i++)  {    if (0 == strcmp (proof, ctx->strings[i]))      ctx->match_count++;  }  if (GNUNET_OK != REGEX_BLOCK_check_proof (proof, strlen (proof), key))  {    ctx->error++;    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                "Proof check failed: proof: %s key: %s/n", proof, state_id);  }  GNUNET_free (state_id);}

/** * Process a given reply that might match the given * request. * * @param cls the 'struct GNUNET_DHT_ClientResultMessage' * @param key query of the request * @param value the 'struct GNUNET_DHT_RouteHandle' of a request matching the same key * @return GNUNET_YES to continue to iterate over all results, *         GNUNET_NO if the reply is malformed */static intprocess_reply (void *cls, const GNUNET_HashCode * key, void *value){  const struct GNUNET_DHT_ClientResultMessage *dht_msg = cls;  struct GNUNET_DHT_GetHandle *get_handle = value;  const struct GNUNET_PeerIdentity *put_path;  const struct GNUNET_PeerIdentity *get_path;  uint32_t put_path_length;  uint32_t get_path_length;  size_t data_length;  size_t msize;  size_t meta_length;  const void *data;  if (dht_msg->unique_id != get_handle->unique_id)  {    /* UID mismatch */    LOG (GNUNET_ERROR_TYPE_DEBUG,         "Ignoring reply for %s: UID mismatch: %llu/%llu/n", GNUNET_h2s (key),         dht_msg->unique_id, get_handle->unique_id);    return GNUNET_YES;  }  msize = ntohs (dht_msg->header.size);  put_path_length = ntohl (dht_msg->put_path_length);  get_path_length = ntohl (dht_msg->get_path_length);  meta_length =      sizeof (struct GNUNET_DHT_ClientResultMessage) +      sizeof (struct GNUNET_PeerIdentity) * (get_path_length + put_path_length);  if ((msize < meta_length) ||      (get_path_length >       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)) ||      (put_path_length >       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_PeerIdentity)))  {    GNUNET_break (0);    return GNUNET_NO;  }  data_length = msize - meta_length;  LOG (GNUNET_ERROR_TYPE_DEBUG, "Giving %u byte reply for %s to application/n",       (unsigned int) data_length, GNUNET_h2s (key));  put_path = (const struct GNUNET_PeerIdentity *) &dht_msg[1];  get_path = &put_path[put_path_length];  data = &get_path[get_path_length];  get_handle->iter (get_handle->iter_cls,                    GNUNET_TIME_absolute_ntoh (dht_msg->expiration), key,                    get_path, get_path_length, put_path, put_path_length,                    ntohl (dht_msg->type), data_length, data);  return GNUNET_YES;}

/** * Get a result for a particular key from the datastore.  The processor * will only be called once. * * @param h handle to the datastore * @param offset offset of the result (modulo num-results); set to *               a random 64-bit value initially; then increment by *               one each time; detect that all results have been found by uid *               being again the first uid ever returned. * @param key maybe NULL (to match all entries) * @param type desired type, 0 for any * @param queue_priority ranking of this request in the priority queue * @param max_queue_size at what queue size should this request be dropped *        (if other requests of higher priority are in the queue) * @param timeout how long to wait at most for a response * @param proc function to call on each matching value; *        will be called once with a NULL value at the end * @param proc_cls closure for proc * @return NULL if the entry was not queued, otherwise a handle that can be used to *         cancel */struct GNUNET_DATASTORE_QueueEntry *GNUNET_DATASTORE_get_key (struct GNUNET_DATASTORE_Handle *h, uint64_t offset,                          const struct GNUNET_HashCode * key,                          enum GNUNET_BLOCK_Type type,                          unsigned int queue_priority,                          unsigned int max_queue_size,                          struct GNUNET_TIME_Relative timeout,                          GNUNET_DATASTORE_DatumProcessor proc, void *proc_cls){  struct GNUNET_DATASTORE_QueueEntry *qe;  struct GetMessage *gm;  union QueueContext qc;  GNUNET_assert (NULL != proc);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Asked to look for data of type %u under key `%s'/n",       (unsigned int) type, GNUNET_h2s (key));  qc.rc.proc = proc;  qc.rc.proc_cls = proc_cls;  qe = make_queue_entry (h, sizeof (struct GetMessage), queue_priority,                         max_queue_size, timeout, &process_result_message, &qc);  if (qe == NULL)  {    LOG (GNUNET_ERROR_TYPE_DEBUG, "Could not queue request for `%s'/n",         GNUNET_h2s (key));    return NULL;  }#if INSANE_STATISTICS  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# GET requests executed"),                            1, GNUNET_NO);#endif  gm = (struct GetMessage *) &qe[1];  gm->header.type = htons (GNUNET_MESSAGE_TYPE_DATASTORE_GET);  gm->type = htonl (type);  gm->offset = GNUNET_htonll (offset);  if (key != NULL)  {    gm->header.size = htons (sizeof (struct GetMessage));    gm->key = *key;  }  else  {    gm->header.size =        htons (sizeof (struct GetMessage) - sizeof (struct GNUNET_HashCode));  }  process_queue (h);  return qe;}

/** * Store content in DHT. * * @param cls closure * @param key key for the content * @param size number of bytes in data * @param data content stored * @param type type of the content * @param priority priority of the content * @param anonymity anonymity-level for the content * @param expiration expiration time for the content * @param uid unique identifier for the datum; *        maybe 0 if no unique identifier is available */static voidprocess_dht_put_content (void *cls,			 const struct GNUNET_HashCode * key,			 size_t size,                         const void *data,			 enum GNUNET_BLOCK_Type type,                         uint32_t priority, uint32_t anonymity,                         struct GNUNET_TIME_Absolute expiration, uint64_t uid){  struct PutOperator *po = cls;  po->dht_qe = NULL;  if (key == NULL)  {    po->zero_anonymity_count_estimate = po->current_offset - 1;    po->current_offset = 0;    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_task, po);    return;  }  po->zero_anonymity_count_estimate =      GNUNET_MAX (po->current_offset, po->zero_anonymity_count_estimate);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Retrieved block `%s' of type %u for DHT PUT/n", GNUNET_h2s (key),              type);  po->dht_put = GNUNET_DHT_put (GSF_dht, key, DEFAULT_PUT_REPLICATION,				GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, type, size, data,				expiration, GNUNET_TIME_UNIT_FOREVER_REL,				&delay_dht_put_blocks, po);}

/** * Handler for port close requests. * * @param cls Identification of the client. * @param pmsg The actual message. */static voidhandle_port_close (void *cls,                   const struct GNUNET_CADET_PortMessage *pmsg){  struct CadetClient *c = cls;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Open port %s requested by client %u/n",       GNUNET_h2s (&pmsg->port),       c->id);  if (GNUNET_YES !=      GNUNET_CONTAINER_multihashmap_remove (c->ports,                                            &pmsg->port,                                            c))  {    GNUNET_break (0);    GNUNET_SERVICE_client_drop (c->client);    return;  }  GNUNET_assert (GNUNET_YES ==                 GNUNET_CONTAINER_multihashmap_remove (open_ports,                                                       &pmsg->port,                                                       c));  GNUNET_SERVICE_client_continue (c->client);}

/** * We've paired up a client session with an incoming CADET request. * Initiate set intersection work. * * @param s client session to start intersection for */static voidstart_intersection (struct BobServiceSession *s){  struct GNUNET_HashCode set_sid;  GNUNET_CRYPTO_hash (&s->session_id,                      sizeof (struct GNUNET_HashCode),                      &set_sid);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Got session with key %s and %u elements, starting intersection./n",              GNUNET_h2s (&s->session_id),              (unsigned int) s->total);  s->intersection_op    = GNUNET_SET_prepare (&s->cadet->peer,                          &set_sid,                          NULL,                          GNUNET_SET_RESULT_REMOVED,                          &cb_intersection_element_removed,                          s);  if (GNUNET_OK !=      GNUNET_SET_commit (s->intersection_op,                         s->intersection_set))  {    GNUNET_break (0);    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;    prepare_client_end_notification (s);    return;  }  GNUNET_SET_destroy (s->intersection_set);  s->intersection_set = NULL;}

/** * Function called whenever a channel is destroyed.  Should clean up * any associated state. * * It must NOT call #GNUNET_CADET_channel_destroy() on the channel. * * @param cls closure (set from #GNUNET_CADET_connect()) * @param channel connection to the other end (henceforth invalid) * @param channel_ctx place where local state associated *                   with the channel is stored */static voidcb_channel_destruction (void *cls,                        const struct GNUNET_CADET_Channel *channel,                        void *channel_ctx){  struct CadetIncomingSession *in = channel_ctx;  struct BobServiceSession *s;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Peer disconnected, terminating session %s with peer %s/n",              GNUNET_h2s (&in->session_id),              GNUNET_i2s (&in->peer));  if (NULL != in->cadet_mq)  {    GNUNET_MQ_destroy (in->cadet_mq);    in->cadet_mq = NULL;  }  in->channel = NULL;  if (NULL != (s = in->s))  {    if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)    {      s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;      prepare_client_end_notification (s);    }  }  destroy_cadet_session (in);}

static voidinit_notify_peer2 (void *cls, struct GNUNET_CORE_Handle *server,                   const struct GNUNET_PeerIdentity *my_identity){  struct TestMessageContext *pos = cls;  total_server_connections++;  pos->peer2connected = GNUNET_YES;  if (pos->peer1notified == GNUNET_YES) /* Peer 1 has been notified of connection to peer 2 */  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Scheduling message send to peer `%s' from peer `%s' (init_notify_peer2)/n",                GNUNET_i2s (my_identity),                GNUNET_h2s (&pos->peer1->id.hashPubKey));    if (NULL ==        GNUNET_CORE_notify_transmit_ready (pos->peer1handle, GNUNET_YES, 0,                                           TIMEOUT, &pos->peer2->id,                                           sizeof (struct GNUNET_TestMessage),                                           &transmit_ready, pos))    {      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                  "RECEIVED NULL when asking core (1) for transmission to peer `%4s'/n",                  GNUNET_i2s (&pos->peer2->id));      transmit_ready_failed++;    }    else    {      transmit_ready_scheduled++;    }  }}

/** * Method called whenever another peer has added us to a channel * the other peer initiated. * * @param cls Closure. * @param channel New handle to the channel. * @param initiator Peer that started the channel. * @param port Port this channel is connected to. * @param options channel option flags * @return Initial channel context for the channel *         (can be NULL -- that's not an error). */static void *incoming_channel (void *cls, struct GNUNET_CADET_Channel *channel,                 const struct GNUNET_PeerIdentity *initiator,                 const struct GNUNET_HashCode *port,                 enum GNUNET_CADET_ChannelOption options){  GNUNET_log (GNUNET_ERROR_TYPE_INFO,              "Incoming channel from %s to peer %d:%s/n",              GNUNET_i2s (initiator),              (int) (long) cls, GNUNET_h2s (port));  ok++;  GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d/n", ok);  if ((long) cls == peers_requested - 1)    incoming_ch = channel;  else  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                "Incoming channel for unknown client %lu/n", (long) cls);    GNUNET_break(0);  }  if (NULL != disconnect_task)  {    GNUNET_SCHEDULER_cancel (disconnect_task);    disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,                                                    &gather_stats_and_exit,                                                    (void *) __LINE__);  }  return NULL;}

/** * An iterator over a set of items stored in the datastore * that deletes until we're happy with respect to our quota. * * @param cls closure * @param key key for the content * @param size number of bytes in data * @param data content stored * @param type type of the content * @param priority priority of the content * @param anonymity anonymity-level for the content * @param expiration expiration time for the content * @param uid unique identifier for the datum; *        maybe 0 if no unique identifier is available * * @return GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue *         (continue on call to "next", of course), *         GNUNET_NO to delete the item and continue (if supported) */static intquota_processor (void *cls, const struct GNUNET_HashCode * key, uint32_t size,                 const void *data, enum GNUNET_BLOCK_Type type,                 uint32_t priority, uint32_t anonymity,                 struct GNUNET_TIME_Absolute expiration, uint64_t uid){  unsigned long long *need = cls;  if (NULL == key)    return GNUNET_SYSERR;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Deleting %llu bytes of low-priority (%u) content `%s' of type %u at %s prior to expiration (still trying to free another %llu bytes)/n",              (unsigned long long) (size + GNUNET_DATASTORE_ENTRY_OVERHEAD),	      (unsigned int) priority,              GNUNET_h2s (key), type,	      GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (expiration),						      GNUNET_YES),	      *need);  if (size + GNUNET_DATASTORE_ENTRY_OVERHEAD > *need)    *need = 0;  else    *need -= size + GNUNET_DATASTORE_ENTRY_OVERHEAD;  if (priority > 0)    min_expiration = GNUNET_TIME_UNIT_FOREVER_ABS;  else    min_expiration = expiration;  GNUNET_STATISTICS_update (stats,                            gettext_noop ("# bytes purged (low-priority)"),                            size, GNUNET_YES);  GNUNET_CONTAINER_bloomfilter_remove (filter, key);  return GNUNET_NO;}

/** * Notify of all peer1's peers, once peer 2 is found, schedule connect * to peer two for message send. * * @param cls closure * @param peer peer identity this notification is about * @param atsi performance data for the connection * @param atsi_count number of ATS information included */static voidconnect_notify_peer2 (void *cls, const struct GNUNET_PeerIdentity *peer,                      const struct GNUNET_ATS_Information *atsi,                      unsigned int atsi_count){  struct TestMessageContext *pos = cls;  if (0 == memcmp (&pos->peer1->id, peer, sizeof (struct GNUNET_PeerIdentity)))  {    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Core connection from `%s' to `%4s' verfied, sending message!/n",                GNUNET_i2s (&pos->peer2->id), GNUNET_h2s (&peer->hashPubKey));    if (NULL ==        GNUNET_CORE_notify_transmit_ready (pos->peer1handle, GNUNET_YES, 0,                                           TIMEOUT, &pos->peer2->id,                                           sizeof (struct GNUNET_TestMessage),                                           &transmit_ready, pos))    {      /* This probably shouldn't happen, but it does (timing issue?) */      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                  "RECEIVED NULL when asking core (1) for transmission to peer `%4s'/n",                  GNUNET_i2s (&pos->peer2->id));      transmit_ready_failed++;      total_other_expected_messages--;    }    else    {      transmit_ready_scheduled++;    }  }}

/** * Handle a GET request we've received from another peer. * * @param key the query * @param type requested data type * @param xquery extended query * @param xquery_size number of bytes in @a xquery * @param reply_bf where the reply bf is (to be) stored, possibly updated, can be NULL * @param reply_bf_mutator mutation value for @a reply_bf * @return evaluation result for the local replies */enum GNUNET_BLOCK_EvaluationResultGDS_DATACACHE_handle_get (const struct GNUNET_HashCode *key,                          enum GNUNET_BLOCK_Type type,                          const void *xquery,                          size_t xquery_size,                          struct GNUNET_CONTAINER_BloomFilter **reply_bf,                          uint32_t reply_bf_mutator){  struct GetRequestContext ctx;  unsigned int r;  if (NULL == datacache)    return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;  GNUNET_STATISTICS_update (GDS_stats,                            gettext_noop ("# GET requests given to datacache"),                            1,                            GNUNET_NO);  ctx.eval = GNUNET_BLOCK_EVALUATION_REQUEST_VALID;  ctx.key = *key;  ctx.xquery = xquery;  ctx.xquery_size = xquery_size;  ctx.reply_bf = reply_bf;  ctx.reply_bf_mutator = reply_bf_mutator;  r = GNUNET_DATACACHE_get (datacache,                            key,                            type,                            &datacache_get_iterator,                            &ctx);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "DATACACHE GET for key %s completed (%d). %u results found./n",       GNUNET_h2s (key),       ctx.eval,       r);  return ctx.eval;}

/** * Route the given request via the DHT.  This includes updating * the bloom filter and retransmission times, building the P2P * message and initiating the routing operation. */static voidtransmit_request (struct ClientQueryRecord *cqr){  int32_t reply_bf_mutator;  struct GNUNET_CONTAINER_BloomFilter *reply_bf;  struct GNUNET_CONTAINER_BloomFilter *peer_bf;  GNUNET_STATISTICS_update (GDS_stats,                            gettext_noop                            ("# GET requests from clients injected"), 1,                            GNUNET_NO);  reply_bf_mutator =      (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,                                          UINT32_MAX);  reply_bf =      GNUNET_BLOCK_construct_bloomfilter (reply_bf_mutator, cqr->seen_replies,                                          cqr->seen_replies_count);  peer_bf =      GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE,                                         GNUNET_CONSTANTS_BLOOMFILTER_K);  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Initiating GET for %s, replication %u, already have %u replies/n",       GNUNET_h2s(&cqr->key), cqr->replication, cqr->seen_replies_count);  GDS_NEIGHBOURS_handle_get (cqr->type, cqr->msg_options, cqr->replication,                             0 /* hop count */ ,                             &cqr->key, cqr->xquery, cqr->xquery_size, reply_bf,                             reply_bf_mutator, peer_bf);  GNUNET_CONTAINER_bloomfilter_free (reply_bf);  GNUNET_CONTAINER_bloomfilter_free (peer_bf);  /* exponential back-off for retries.   * max GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD (15 min) */  cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF (cqr->retry_frequency);  cqr->retry_time = GNUNET_TIME_relative_to_absolute (cqr->retry_frequency);}

/** * Look for a block by directly contacting a particular peer. * * @param target peer that should have the block * @param query hash to query for the block * @param type desired type for the block * @param proc function to call with result * @param proc_cls closure for 'proc' * @return handle to cancel the operation */struct GSF_StreamRequest *GSF_stream_query (const struct GNUNET_PeerIdentity *target,		  const struct GNUNET_HashCode *query,		  enum GNUNET_BLOCK_Type type,		  GSF_StreamReplyProcessor proc, void *proc_cls){  struct StreamHandle *sh;  struct GSF_StreamRequest *sr;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Preparing to send query for %s via stream to %s/n",	      GNUNET_h2s (query),	      GNUNET_i2s (target));  sh = get_stream (target);  sr = GNUNET_malloc (sizeof (struct GSF_StreamRequest));  sr->sh = sh;  sr->proc = proc;  sr->proc_cls = proc_cls;  sr->type = type;  sr->query = *query;  GNUNET_CONTAINER_DLL_insert (sh->pending_head,			       sh->pending_tail,			       sr);  if (GNUNET_YES == sh->is_ready)    transmit_pending (sh);  return sr;}

/** * Encrypt the next block of the file (and call proc and progress * accordingly; or of course "cont" if we have already completed * encoding of the entire file). * * @param te tree encoder to use */voidGNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te){  struct ContentHashKey *mychk;  const void *pt_block;  uint16_t pt_size;  char iob[DBLOCK_SIZE];  char enc[DBLOCK_SIZE];  struct GNUNET_CRYPTO_SymmetricSessionKey sk;  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;  unsigned int off;  GNUNET_assert (GNUNET_NO == te->in_next);  te->in_next = GNUNET_YES;  if (te->chk_tree_depth == te->current_depth)  {    off = CHK_PER_INODE * (te->chk_tree_depth - 1);    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TE done, reading CHK `%s' from %u/n",                GNUNET_h2s (&te->chk_tree[off].query), off);    te->uri = GNUNET_new (struct GNUNET_FS_Uri);    te->uri->type = GNUNET_FS_URI_CHK;    te->uri->data.chk.chk = te->chk_tree[off];    te->uri->data.chk.file_length = GNUNET_htonll (te->size);    te->in_next = GNUNET_NO;    te->cont (te->cls, NULL);    return;  }

/** * TEST FUNCTION * Remove after using. */voidGDS_ROUTING_test_print (void){  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;  struct RoutingTrail *trail;  struct GNUNET_PeerIdentity print_peer;  struct GNUNET_HashCode key_ret;  int i;  struct GNUNET_PeerIdentity my_identity = *GDS_NEIGHBOURS_get_id();  print_peer = my_identity;   FPRINTF (stderr,_("/nSUPU ***PRINTING ROUTING TABLE ***** of =%s"),GNUNET_i2s(&print_peer));  iter =GNUNET_CONTAINER_multihashmap_iterator_create (routing_table);  for (i = 0; i < GNUNET_CONTAINER_multihashmap_size(routing_table); i++)  {    if(GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter,                                                                  &key_ret,                                                                  (const void **)&trail))    {      FPRINTF (stderr,_("/nSUPU %s, %s, %d, trail->trail_id = %s"),              __FILE__, __func__,__LINE__, GNUNET_h2s(&trail->trail_id));      GNUNET_memcpy (&print_peer, &trail->next_hop, sizeof (struct GNUNET_PeerIdentity));      FPRINTF (stderr,_("/nSUPU %s, %s, %d, trail->next_hop = %s"),              __FILE__, __func__,__LINE__, GNUNET_i2s(&print_peer));      GNUNET_memcpy (&print_peer, &trail->prev_hop, sizeof (struct GNUNET_PeerIdentity));      FPRINTF (stderr,_("/nSUPU %s, %s, %d, trail->prev_hop = %s"),              __FILE__, __func__,__LINE__, GNUNET_i2s(&print_peer));    }  }}

/** * Function to process DHT string to regex matching. * Called on each result obtained for the DHT search. * * @param cls Closure (search context). * @param exp When will this value expire. * @param key Key of the result. * @param get_path Path of the get request. * @param get_path_length Lenght of get_path. * @param put_path Path of the put request. * @param put_path_length Length of the put_path. * @param type Type of the result. * @param size Number of bytes in data. * @param data Pointer to the result data. */static voiddht_get_string_accept_handler (void *cls, struct GNUNET_TIME_Absolute exp,                               const struct GNUNET_HashCode *key,                               const struct GNUNET_PeerIdentity *get_path,                               unsigned int get_path_length,                               const struct GNUNET_PeerIdentity *put_path,                               unsigned int put_path_length,                               enum GNUNET_BLOCK_Type type,                               size_t size, const void *data){  const struct RegexAcceptBlock *block = data;  struct RegexSearchContext *ctx = cls;  struct REGEX_INTERNAL_Search *info = ctx->info;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Regex result accept for %s (key %s)/n",       info->description, GNUNET_h2s(key));  GNUNET_STATISTICS_update (info->stats,			    "# regex accepting blocks found",                            1, GNUNET_NO);  GNUNET_STATISTICS_update (info->stats,			    "# regex accepting block bytes found",                            size, GNUNET_NO);  info->callback (info->callback_cls,                  &block->peer,                  get_path, get_path_length,                  put_path, put_path_length);}

/** * Create a new query plan entry. * * @param cp peer with the entry * @param pr request with the entry */voidGSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr){  const struct GNUNET_PeerIdentity *id;  struct PeerPlan *pp;  struct GSF_PendingRequestData *prd;  struct GSF_RequestPlan *rp;  struct GSF_PendingRequestPlanBijection *bi;  struct MergeContext mpc;  GNUNET_assert (NULL != cp);  id = GSF_connected_peer_get_identity2_ (cp);  pp = GNUNET_CONTAINER_multihashmap_get (plans, &id->hashPubKey);  if (NULL == pp)  {    pp = GNUNET_malloc (sizeof (struct PeerPlan));    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);    pp->priority_heap =        GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);    pp->delay_heap =        GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);    pp->cp = cp;    GNUNET_CONTAINER_multihashmap_put (plans, 				       &id->hashPubKey, pp,                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);  }  mpc.merged = GNUNET_NO;  mpc.pr = pr;  GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,                                              &GSF_pending_request_get_data_                                              (pr)->query, &merge_pr, &mpc); // 8 MB in 'merge_pr'  if (GNUNET_NO != mpc.merged)    return;  GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,                                              &GSF_pending_request_get_data_                                              (pr)->query, &merge_pr, &mpc);  if (GNUNET_NO != mpc.merged)    return;  plan_count++;  GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# query plan entries"), 1,                            GNUNET_NO);  prd = GSF_pending_request_get_data_ (pr);  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Planning transmission of query `%s' to peer `%s'/n",              GNUNET_h2s (&prd->query), GNUNET_i2s (id));  rp = GNUNET_malloc (sizeof (struct GSF_RequestPlan)); // 8 MB  bi = GNUNET_malloc (sizeof (struct GSF_PendingRequestPlanBijection));  bi->rp = rp;  bi->pr = pr;  GNUNET_CONTAINER_MDLL_insert (PR, prd->pr_head, prd->pr_tail, bi);  GNUNET_CONTAINER_MDLL_insert (PE, rp->pe_head, rp->pe_tail, bi);  rp->pp = pp;  GNUNET_assert (GNUNET_YES ==                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,                                                    get_rp_key (rp), rp,                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); // 8 MB  plan (pp, rp); // +5 MB (plan/heap-insert)}

/** * Handler for requests of new channels. * * @param cls Identification of the client. * @param ccm The actual message. */static voidhandle_channel_create (void *cls,                       const struct GNUNET_CADET_ChannelCreateMessage *ccm){  struct CadetClient *c = cls;  struct CadetChannel *ch;  struct GNUNET_CADET_ClientChannelNumber chid;  struct CadetPeer *dst;  chid = ccm->channel_id;  if (ntohl (chid.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)  {    /* Channel ID not in allowed range. */    GNUNET_break (0);    GNUNET_SERVICE_client_drop (c->client);    return;  }  ch = GNUNET_CONTAINER_multihashmap32_get (c->own_channels,                                            ntohl (chid.channel_of_client));  if (NULL != ch)  {    /* Channel ID already in use. Not allowed. */    GNUNET_break (0);    GNUNET_SERVICE_client_drop (c->client);    return;  }  dst = GCP_get (&ccm->peer,                 GNUNET_YES);  /* Create channel */  ch = GCCH_channel_local_new (c,                               chid,                               dst,                               &ccm->port,                               ntohl (ccm->opt));  if (NULL == ch)  {    GNUNET_break (0);    GNUNET_SERVICE_client_drop (c->client);    return;  }  GNUNET_assert (GNUNET_YES ==                 GNUNET_CONTAINER_multihashmap32_put (c->own_channels,                                                      ntohl (chid.channel_of_client),                                                      ch,                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));  LOG (GNUNET_ERROR_TYPE_DEBUG,       "New channel %s to %s at port %s requested by client %u/n",       GCCH_2s (ch),       GNUNET_i2s (&ccm->peer),       GNUNET_h2s (&ccm->port),       c->id);  GNUNET_SERVICE_client_continue (c->client);}

/** * Method called whenever a given peer connects. * * @param cls closure * @param peer peer identity this notification is about * @param atsi performance data for the connection */static voidconnect_notify_peers (void *cls, const struct GNUNET_PeerIdentity *peer,                      const struct GNUNET_ATS_Information *atsi){  struct TestMessageContext *pos = cls;  if (0 == memcmp (peer, &pos->peer2->id, sizeof (struct GNUNET_PeerIdentity)))  {    pos->peer1notified = GNUNET_YES;#if VERBOSE > 1    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Peer `%s' notified of connection to peer `%s'/n",                GNUNET_i2s (&pos->peer1->id), GNUNET_h2s (&peer->hashPubKey));#endif  }  else    return;  if (pos->peer2connected == GNUNET_YES)        /* Already connected and notified of connection, send message! */  {#if VERBOSE > 1    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                "Scheduling message send to peer `%s' from peer `%s' (init_notify_peer2)/n",                GNUNET_i2s (&pos->peer2->id),                GNUNET_h2s (&pos->peer1->id.hashPubKey));#endif    if (NULL ==        GNUNET_CORE_notify_transmit_ready (pos->peer1handle, 0, timeout,                                           &pos->peer2->id,                                           sizeof (struct GNUNET_TestMessage),                                           &transmit_ready, pos))    {      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,                  "RECEIVED NULL when asking core (1) for transmission to peer `%4s'/n",                  GNUNET_i2s (&pos->peer2->id));      transmit_ready_failed++;    }    else    {      transmit_ready_scheduled++;    }  }}

/** * Print information about the given node and its edges * to stdout. * * @param cls closure, unused. * @param key hash for current state. * @param proof proof for current state. * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not. * @param num_edges number of edges leaving current state. * @param edges edges leaving current state. */static voidprint_edge (void *cls,	    const struct GNUNET_HashCode *key,	    const char *proof,	    int accepting,	    unsigned int num_edges,	    const struct REGEX_BLOCK_Edge *edges){  unsigned int i;  printf ("%s: %s, proof: `%s'/n",	  GNUNET_h2s (key),	  accepting ? "ACCEPTING" : "",	  proof);  for (i = 0; i < num_edges; i++)    printf ("    `%s': %s/n",	    edges[i].label,	    GNUNET_h2s (&edges[i].destination));}

/** * Iterate over the results for a particular key * in the datacache. * * @param h handle to the datacache * @param key what to look up * @param type entries of which type are relevant? * @param iter maybe NULL (to just count) * @param iter_cls closure for iter * @return the number of results found */unsigned intGNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h,                      const GNUNET_HashCode * key, enum GNUNET_BLOCK_Type type,                      GNUNET_DATACACHE_Iterator iter, void *iter_cls){  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# requests received"), 1,                            GNUNET_NO);  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing request for key `%s'/n",       GNUNET_h2s (key));  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_test (h->filter, key))  {    GNUNET_STATISTICS_update (h->stats,                              gettext_noop                              ("# requests filtered by bloom filter"), 1,                              GNUNET_NO);    LOG (GNUNET_ERROR_TYPE_DEBUG, "Bloomfilter filters request for key `%s'/n",         GNUNET_h2s (key));    return 0;                   /* can not be present */  }  return h->api->get (h->api->cls, key, type, iter, iter_cls);}

/** * Perform an asynchronous GET operation on the DHT identified. See * also #GNUNET_BLOCK_evaluate. * * @param handle handle to the DHT service * @param type expected type of the response object * @param key the key to look up * @param desired_replication_level estimate of how many                  nearest peers this request should reach * @param options routing options for this message * @param xquery extended query data (can be NULL, depending on type) * @param xquery_size number of bytes in @a xquery * @param iter function to call on each result * @param iter_cls closure for iter * @return handle to stop the async get */struct GNUNET_DHT_GetHandle *GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle,                      enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode * key,                      uint32_t desired_replication_level,                      enum GNUNET_DHT_RouteOption options, const void *xquery,                      size_t xquery_size, GNUNET_DHT_GetIterator iter,                      void *iter_cls){  struct GNUNET_DHT_ClientGetMessage *get_msg;  struct GNUNET_DHT_GetHandle *get_handle;  size_t msize;  struct PendingMessage *pending;  msize = sizeof (struct GNUNET_DHT_ClientGetMessage) + xquery_size;  if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||      (xquery_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE))  {    GNUNET_break (0);    return NULL;  }  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending query for %s to DHT %p/n",       GNUNET_h2s (key), handle);  pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);  get_msg = (struct GNUNET_DHT_ClientGetMessage *) &pending[1];  pending->msg = &get_msg->header;  pending->handle = handle;  pending->free_on_send = GNUNET_NO;  get_msg->header.size = htons (msize);  get_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);  get_msg->options = htonl ((uint32_t) options);  get_msg->desired_replication_level = htonl (desired_replication_level);  get_msg->type = htonl (type);  get_msg->key = *key;  get_msg->unique_id = ++handle->uid_gen;  memcpy (&get_msg[1], xquery, xquery_size);  GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,                               pending);  pending->in_pending_queue = GNUNET_YES;  get_handle = GNUNET_new (struct GNUNET_DHT_GetHandle);  get_handle->key = *key;  get_handle->dht_handle = handle;  get_handle->iter = iter;  get_handle->iter_cls = iter_cls;  get_handle->message = pending;  get_handle->unique_id = get_msg->unique_id;  GNUNET_CONTAINER_multihashmap_put (handle->active_requests,                                     &get_handle->key,                                     get_handle,                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);  process_pending_messages (handle);  return get_handle;}

/** * Iterator over hash map entries that frees all entries * that match the given client and unique ID. * * @param cls unique ID and client to search for in source routes * @param key current key code * @param value value in the hash map, a ClientQueryRecord * @return GNUNET_YES (we should continue to iterate) */static intremove_by_unique_id (void *cls, const struct GNUNET_HashCode * key, void *value){  const struct RemoveByUniqueIdContext *ctx = cls;  struct ClientQueryRecord *record = value;  if (record->unique_id != ctx->unique_id)    return GNUNET_YES;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Removing client %p's record for key %s (by unique id)/n",              ctx->client->client_handle, GNUNET_h2s (key));  return remove_client_records (ctx->client, key, record);}

/** * Function called by plugins to notify the datacache * about content deletions. * * @param cls closure * @param key key of the content that was deleted * @param size number of bytes that were made available */static voidenv_delete_notify (void *cls, const GNUNET_HashCode * key, size_t size){  struct GNUNET_DATACACHE_Handle *h = cls;  LOG (GNUNET_ERROR_TYPE_DEBUG, "Content under key `%s' discarded/n",       GNUNET_h2s (key));  GNUNET_assert (h->utilization >= size);  h->utilization -= size;  GNUNET_CONTAINER_bloomfilter_remove (h->filter, key);  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# bytes stored"), -size,                            GNUNET_NO);}

/** * Store an item in the datastore.  If the item is already present, * the priorities are summed up and the higher expiration time and * lower anonymity level is used. * * @param h handle to the datastore * @param rid reservation ID to use (from "reserve"); use 0 if no *            prior reservation was made * @param key key for the value * @param size number of bytes in data * @param data content stored * @param type type of the content * @param priority priority of the content * @param anonymity anonymity-level for the content * @param replication how often should the content be replicated to other peers? * @param expiration expiration time for the content * @param queue_priority ranking of this request in the priority queue * @param max_queue_size at what queue size should this request be dropped *        (if other requests of higher priority are in the queue) * @param timeout timeout for the operation * @param cont continuation to call when done * @param cont_cls closure for cont * @return NULL if the entry was not queued, otherwise a handle that can be used to *         cancel; note that even if NULL is returned, the callback will be invoked *         (or rather, will already have been invoked) */struct GNUNET_DATASTORE_QueueEntry *GNUNET_DATASTORE_put (struct GNUNET_DATASTORE_Handle *h, uint32_t rid,                      const struct GNUNET_HashCode * key, size_t size,                      const void *data, enum GNUNET_BLOCK_Type type,                      uint32_t priority, uint32_t anonymity,                      uint32_t replication,                      struct GNUNET_TIME_Absolute expiration,                      unsigned int queue_priority, unsigned int max_queue_size,                      struct GNUNET_TIME_Relative timeout,                      GNUNET_DATASTORE_ContinuationWithStatus cont,                      void *cont_cls){  struct GNUNET_DATASTORE_QueueEntry *qe;  struct DataMessage *dm;  size_t msize;  union QueueContext qc;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Asked to put %u bytes of data under key `%s' for %llu ms/n", size,       GNUNET_h2s (key),       GNUNET_TIME_absolute_get_remaining (expiration).rel_value);  msize = sizeof (struct DataMessage) + size;  GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);  qc.sc.cont = cont;  qc.sc.cont_cls = cont_cls;  qe = make_queue_entry (h, msize, queue_priority, max_queue_size, timeout,                         &process_status_message, &qc);  if (qe == NULL)  {    LOG (GNUNET_ERROR_TYPE_DEBUG, "Could not create queue entry for PUT/n");    return NULL;  }  GNUNET_STATISTICS_update (h->stats, gettext_noop ("# PUT requests executed"),                            1, GNUNET_NO);  dm = (struct DataMessage *) &qe[1];  dm->header.type = htons (GNUNET_MESSAGE_TYPE_DATASTORE_PUT);  dm->header.size = htons (msize);  dm->rid = htonl (rid);  dm->size = htonl ((uint32_t) size);  dm->type = htonl (type);  dm->priority = htonl (priority);  dm->anonymity = htonl (anonymity);  dm->replication = htonl (replication);  dm->reserved = htonl (0);  dm->uid = GNUNET_htonll (0);  dm->expiration = GNUNET_TIME_absolute_hton (expiration);  dm->key = *key;  memcpy (&dm[1], data, size);  process_queue (h);  return qe;}

/** * Stop async DHT-get. * * @param get_handle handle to the GET operation to stop */voidGNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle){  struct GNUNET_DHT_Handle *handle;  const struct GNUNET_DHT_ClientGetMessage *get_msg;  struct GNUNET_DHT_ClientGetStopMessage *stop_msg;  struct PendingMessage *pending;  handle = get_handle->message->handle;  get_msg =      (const struct GNUNET_DHT_ClientGetMessage *) get_handle->message->msg;  LOG (GNUNET_ERROR_TYPE_DEBUG,       "Sending STOP for %s to DHT via %p/n",       GNUNET_h2s (&get_msg->key), handle);  /* generate STOP */  pending =      GNUNET_malloc (sizeof (struct PendingMessage) +                     sizeof (struct GNUNET_DHT_ClientGetStopMessage));  stop_msg = (struct GNUNET_DHT_ClientGetStopMessage *) &pending[1];  pending->msg = &stop_msg->header;  pending->handle = handle;  pending->free_on_send = GNUNET_YES;  stop_msg->header.size =      htons (sizeof (struct GNUNET_DHT_ClientGetStopMessage));  stop_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP);  stop_msg->reserved = htonl (0);  stop_msg->unique_id = get_msg->unique_id;  stop_msg->key = get_msg->key;  GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,                               pending);  pending->in_pending_queue = GNUNET_YES;  /* remove 'GET' from active status */  GNUNET_assert (GNUNET_YES ==                 GNUNET_CONTAINER_multihashmap_remove (handle->active_requests,                                                       &get_handle->key,                                                       get_handle));  if (GNUNET_YES == get_handle->message->in_pending_queue)  {    GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,                                 get_handle->message);    get_handle->message->in_pending_queue = GNUNET_NO;  }  GNUNET_free (get_handle->message);  GNUNET_array_grow (get_handle->seen_results,		     get_handle->seen_results_end,		     0);  GNUNET_free (get_handle);  process_pending_messages (handle);}

/** * Function called once the hash computation over an * indexed file has completed. * * @param cls closure, our publishing context * @param res resulting hash, NULL on error */static voidhash_for_index_val (void *cls, const struct GNUNET_HashCode * res){  struct IndexInfo *ii = cls;  ii->fhc = NULL;  if ((res == NULL) ||      (0 != memcmp (res, &ii->file_id, sizeof (struct GNUNET_HashCode))))  {    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,                _                ("Hash mismatch trying to index file `%s' which has hash `%s'/n"),                ii->filename, GNUNET_h2s (res));    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Wanted `%s'/n",                GNUNET_h2s (&ii->file_id));    GNUNET_SERVER_transmit_context_append_data (ii->tc, NULL, 0,                                                GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);    GNUNET_SERVER_transmit_context_run (ii->tc, GNUNET_TIME_UNIT_MINUTES);    GNUNET_free (ii);    return;  }  signal_index_ok (ii);}

/** * Store an item in the datastore. * * @param cls closure * @param key key for the item * @param size number of bytes in data * @param data content stored * @param type type of the content * @param priority priority of the content * @param anonymity anonymity-level for the content * @param replication replication-level for the content * @param expiration expiration time for the content * @param msg set to error message * @return GNUNET_OK on success */static intmysql_plugin_put (void *cls, const struct GNUNET_HashCode * key, uint32_t size,                  const void *data, enum GNUNET_BLOCK_Type type,                  uint32_t priority, uint32_t anonymity, uint32_t replication,                  struct GNUNET_TIME_Absolute expiration, char **msg){  struct Plugin *plugin = cls;  unsigned int irepl = replication;  unsigned int ipriority = priority;  unsigned int ianonymity = anonymity;  unsigned long long lexpiration = expiration.abs_value_us;  unsigned long long lrvalue =      (unsigned long long) GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,                                                     UINT64_MAX);  unsigned long hashSize;  unsigned long hashSize2;  unsigned long lsize;  struct GNUNET_HashCode vhash;  if (size > MAX_DATUM_SIZE)  {    GNUNET_break (0);    return GNUNET_SYSERR;  }  hashSize = sizeof (struct GNUNET_HashCode);  hashSize2 = sizeof (struct GNUNET_HashCode);  lsize = size;  GNUNET_CRYPTO_hash (data, size, &vhash);  if (GNUNET_OK !=      GNUNET_MYSQL_statement_run_prepared (plugin->mc, plugin->insert_entry, NULL,                              MYSQL_TYPE_LONG, &irepl, GNUNET_YES,                              MYSQL_TYPE_LONG, &type, GNUNET_YES,                              MYSQL_TYPE_LONG, &ipriority, GNUNET_YES,                              MYSQL_TYPE_LONG, &ianonymity, GNUNET_YES,                              MYSQL_TYPE_LONGLONG, &lexpiration, GNUNET_YES,                              MYSQL_TYPE_LONGLONG, &lrvalue, GNUNET_YES,                              MYSQL_TYPE_BLOB, key, hashSize, &hashSize,                              MYSQL_TYPE_BLOB, &vhash, hashSize2, &hashSize2,                              MYSQL_TYPE_BLOB, data, lsize, &lsize, -1))    return GNUNET_SYSERR;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,              "Inserted value `%s' with size %u into gn090 table/n",              GNUNET_h2s (key), (unsigned int) size);  if (size > 0)    plugin->env->duc (plugin->env->cls, size);  return GNUNET_OK;}

/** * Explicitly remove some content from the database. * The "cont"inuation will be called with status * "GNUNET_OK" if content was removed, "GNUNET_NO" * if no matching entry was found and "GNUNET_SYSERR" * on all other types of errors. * * @param h handle to the datastore * @param key key for the value * @param size number of bytes in data * @param data content stored * @param queue_priority ranking of this request in the priority queue * @param max_queue_size at what queue size should this request be dropped *        (if other requests of higher priority are in the queue) * @param timeout how long to wait at most for a response * @param cont continuation to call when done * @param cont_cls closure for cont * @return NULL if the entry was not queued, otherwise a handle that can be used to *         cancel; note that even if NULL is returned, the callback will be invoked *         (or rather, will already have been invoked) */struct GNUNET_DATASTORE_QueueEntry *GNUNET_DATASTORE_remove (struct GNUNET_DATASTORE_Handle *h,                         const struct GNUNET_HashCode * key, size_t size,                         const void *data, unsigned int queue_priority,                         unsigned int max_queue_size,                         struct GNUNET_TIME_Relative timeout,                         GNUNET_DATASTORE_ContinuationWithStatus cont,                         void *cont_cls){  struct GNUNET_DATASTORE_QueueEntry *qe;  struct DataMessage *dm;  size_t msize;  union QueueContext qc;  if (cont == NULL)    cont = &drop_status_cont;  LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to remove %u bytes under key `%s'/n",       size, GNUNET_h2s (key));  qc.sc.cont = cont;  qc.sc.cont_cls = cont_cls;  msize = sizeof (struct DataMessage) + size;  GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);  qe = make_queue_entry (h, msize, queue_priority, max_queue_size, timeout,                         &process_status_message, &qc);  if (qe == NULL)  {    LOG (GNUNET_ERROR_TYPE_DEBUG, "Could not create queue entry for REMOVE/n");    return NULL;  }  GNUNET_STATISTICS_update (h->stats,                            gettext_noop ("# REMOVE requests executed"), 1,                            GNUNET_NO);  dm = (struct DataMessage *) &qe[1];  dm->header.type = htons (GNUNET_MESSAGE_TYPE_DATASTORE_REMOVE);  dm->header.size = htons (msize);  dm->rid = htonl (0);  dm->size = htonl (size);  dm->type = htonl (0);  dm->priority = htonl (0);  dm->anonymity = htonl (0);  dm->uid = GNUNET_htonll (0);  dm->expiration = GNUNET_TIME_absolute_hton (GNUNET_TIME_UNIT_ZERO_ABS);  dm->key = *key;  memcpy (&dm[1], data, size);  process_queue (h);  return qe;}