src/peerstore/peerstore_common.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2012-2013 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  * @file peerstore/peerstore_common.c
  22  * @brief Helper peerstore functions
  23  * @author Omar Tarabai
  24  */
  25
  26 #include "peerstore_common.h"
  27
  28 /**
  29  * Creates a hash of the given key combination
  30  *
  31  */
  32 void
  33 PEERSTORE_hash_key(const char *sub_system,
  34     const struct GNUNET_PeerIdentity *peer,
  35     const char *key,
  36     struct GNUNET_HashCode *ret)
  37 {
  38   size_t sssize;
  39   size_t psize;
  40   size_t ksize;
  41   size_t totalsize;
  42   void *block;
  43   void *blockptr;
  44
  45   sssize = strlen(sub_system) + 1;
  46   psize = sizeof(struct GNUNET_PeerIdentity);
  47   ksize = strlen(key) + 1;
  48   totalsize = sssize + psize + ksize;
  49   block = GNUNET_malloc(totalsize);
  50   blockptr = block;
  51   memcpy(blockptr, sub_system, sssize);
  52   blockptr += sssize;
  53   memcpy(blockptr, peer, psize);
  54   blockptr += psize;
  55   memcpy(blockptr, key, ksize);
  56   GNUNET_CRYPTO_hash(block, totalsize, ret);
  57   GNUNET_free(block);
  58 }
  59
  60 /**
  61  * Creates a record message ready to be sent
  62  *
  63  * @param sub_system sub system string
  64  * @param peer Peer identity (can be NULL)
  65  * @param key record key string (can be NULL)
  66  * @param value record value BLOB (can be NULL)
  67  * @param value_size record value size in bytes (set to 0 if value is NULL)
  68  * @param expiry absolute time after which the record expires
  69  * @param msg_type message type to be set in header
  70  * @return pointer to record message struct
  71  */
  72 struct StoreRecordMessage *
  73 PEERSTORE_create_record_message(const char *sub_system,
  74     const struct GNUNET_PeerIdentity *peer,
  75     const char *key,
  76     const void *value,
  77     size_t value_size,
  78     struct GNUNET_TIME_Absolute *expiry,
  79     uint16_t msg_type)
  80 {
  81   struct StoreRecordMessage *srm;
  82   size_t ss_size;
  83   size_t key_size;
  84   size_t request_size;
  85   void *dummy;
  86
  87   ss_size = strlen(sub_system) + 1;
  88   if(NULL == key)
  89     key_size = 0;
  90   else
  91     key_size = strlen(key) + 1;
  92   request_size = sizeof(struct StoreRecordMessage) +
  93       ss_size +
  94       key_size +
  95       value_size;
  96   srm = GNUNET_malloc(request_size);
  97   srm->header.size = htons(request_size);
  98   srm->header.type = htons(msg_type);
  99   srm->key_size = htons(key_size);
 100   if(NULL != expiry)
 101     srm->expiry = *expiry;
 102   if(NULL == peer)
 103     srm->peer_set = htons(GNUNET_NO);
 104   else
 105   {
 106     srm->peer_set = htons(GNUNET_YES);
 107     srm->peer = *peer;
 108   }
 109   srm->sub_system_size = htons(ss_size);
 110   srm->value_size = htons(value_size);
 111   dummy = &srm[1];
 112   memcpy(dummy, sub_system, ss_size);
 113   dummy += ss_size;
 114   memcpy(dummy, key, key_size);
 115   dummy += key_size;
 116   memcpy(dummy, value, value_size);
 117   return srm;
 118
 119 }
 120
 121 /**
 122  * Creates a MQ envelope for a single record
 123  *
 124  * @param sub_system sub system string
 125  * @param peer Peer identity (can be NULL)
 126  * @param key record key string (can be NULL)
 127  * @param value record value BLOB (can be NULL)
 128  * @param value_size record value size in bytes (set to 0 if value is NULL)
 129  * @param expiry time after which the record expires
 130  * @param options options specific to the storage operation
 131  * @param msg_type message type to be set in header
 132  * @return pointer to record message struct
 133  */
 134 struct GNUNET_MQ_Envelope *
 135 PEERSTORE_create_record_mq_envelope(const char *sub_system,
 136                                     const struct GNUNET_PeerIdentity *peer,
 137                                     const char *key,
 138                                     const void *value,
 139                                     size_t value_size,
 140                                     struct GNUNET_TIME_Absolute *expiry,
 141                                     enum GNUNET_PEERSTORE_StoreOption options,
 142                                     uint16_t msg_type)
 143 {
 144   struct StoreRecordMessage *srm;
 145   struct GNUNET_MQ_Envelope *ev;
 146   size_t ss_size;
 147   size_t key_size;
 148   size_t msg_size;
 149   void *dummy;
 150
 151   GNUNET_assert(NULL != sub_system);
 152   ss_size = strlen(sub_system) + 1;
 153   if(NULL == key)
 154     key_size = 0;
 155   else
 156     key_size = strlen(key) + 1;
 157   msg_size = ss_size +
 158       key_size +
 159       value_size;
 160   ev = GNUNET_MQ_msg_extra(srm, msg_size, msg_type);
 161   srm->key_size = htons(key_size);
 162   if(NULL != expiry)
 163     srm->expiry = *expiry;
 164   if(NULL == peer)
 165     srm->peer_set = htons(GNUNET_NO);
 166   else
 167   {
 168     srm->peer_set = htons(GNUNET_YES);
 169     srm->peer = *peer;
 170   }
 171   srm->sub_system_size = htons(ss_size);
 172   srm->value_size = htons(value_size);
 173   srm->options = options;
 174   dummy = &srm[1];
 175   memcpy(dummy, sub_system, ss_size);
 176   dummy += ss_size;
 177   memcpy(dummy, key, key_size);
 178   dummy += key_size;
 179   memcpy(dummy, value, value_size);
 180
 181   return ev;
 182 }
 183
 184 /**
 185  * Parses a message carrying a record
 186  *
 187  * @param message the actual message
 188  * @return Pointer to record or NULL if error
 189  */
 190 struct GNUNET_PEERSTORE_Record *
 191 PEERSTORE_parse_record_message(const struct GNUNET_MessageHeader *message)
 192 {
 193   struct StoreRecordMessage *srm;
 194   struct GNUNET_PEERSTORE_Record *record;
 195   uint16_t req_size;
 196   uint16_t ss_size;
 197   uint16_t key_size;
 198   uint16_t value_size;
 199   char *dummy;
 200
 201   req_size = ntohs(message->size);
 202   if(req_size < sizeof(struct StoreRecordMessage))
 203     return NULL;
 204   srm = (struct StoreRecordMessage *)message;
 205   ss_size = ntohs(srm->sub_system_size);
 206   key_size = ntohs(srm->key_size);
 207   value_size = ntohs(srm->value_size);
 208   if(ss_size + key_size + value_size + sizeof(struct StoreRecordMessage)
 209         != req_size)
 210     return NULL;
 211   record = GNUNET_new(struct GNUNET_PEERSTORE_Record);
 212   if(GNUNET_YES == ntohs(srm->peer_set))
 213   {
 214     record->peer = GNUNET_new(struct GNUNET_PeerIdentity);
 215     memcpy(record->peer, &srm->peer, sizeof(struct GNUNET_PeerIdentity));
 216   }
 217   record->expiry = GNUNET_new(struct GNUNET_TIME_Absolute);
 218   *(record->expiry) = srm->expiry;
 219   dummy = (char *)&srm[1];
 220   if(ss_size > 0)
 221   {
 222     record->sub_system = GNUNET_strdup(dummy);
 223     dummy += ss_size;
 224   }
 225   if(key_size > 0)
 226   {
 227     record->key = GNUNET_strdup(dummy);
 228     dummy += key_size;
 229   }
 230   if(value_size > 0)
 231   {
 232     record->value = GNUNET_malloc(value_size);
 233     memcpy(record->value, dummy, value_size);
 234   }
 235   record->value_size = value_size;
 236
 237   return record;
 238 }
 239
 240 /**
 241  * Free any memory allocated for this record
 242  *
 243  * @param record
 244  */
 245 void PEERSTORE_destroy_record(struct GNUNET_PEERSTORE_Record *record)
 246 {
 247   if(NULL != record->sub_system)
 248     GNUNET_free(record->sub_system);
 249   if(NULL != record->peer)
 250     GNUNET_free(record->peer);
 251   if(NULL != record->key)
 252     GNUNET_free(record->key);
 253   if(NULL != record->value)
 254   {
 255     GNUNET_free(record->value);
 256     record->value = 0;
 257   }
 258   if(NULL != record->expiry)
 259     GNUNET_free(record->expiry);
 260   GNUNET_free(record);
 261 }