uncrustify as demanded.

[oweals/gnunet.git] / src / peerstore / peerstore_common.c

diff --git a/src/peerstore/peerstore_common.c b/src/peerstore/peerstore_common.c
index 0e2cc0514bd3810dd7c5431c961f2e71753dcf4f..7fceb1ec03a431bc24cab44e9cd2444065121d27 100644 (file)
--- a/src/peerstore/peerstore_common.c
+++ b/src/peerstore/peerstore_common.c
@@ -11,7 +11,7 @@
       WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       Affero General Public License for more details.
-     
+
       You should have received a copy of the GNU Affero General Public License
       along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -30,10 +30,10 @@
  *
  */
 void
-PEERSTORE_hash_key (const char *sub_system,
-                    const struct GNUNET_PeerIdentity *peer,
-                    const char *key,
-                    struct GNUNET_HashCode *ret)
+PEERSTORE_hash_key(const char *sub_system,
+                   const struct GNUNET_PeerIdentity *peer,
+                   const char *key,
+                   struct GNUNET_HashCode *ret)
 {
   size_t sssize;
   size_t psize;
@@ -42,19 +42,19 @@ PEERSTORE_hash_key (const char *sub_system,
   void *block;
   void *blockptr;
 
-  sssize = strlen (sub_system) + 1;
-  psize = sizeof (struct GNUNET_PeerIdentity);
-  ksize = strlen (key) + 1;
+  sssize = strlen(sub_system) + 1;
+  psize = sizeof(struct GNUNET_PeerIdentity);
+  ksize = strlen(key) + 1;
   totalsize = sssize + psize + ksize;
-  block = GNUNET_malloc (totalsize);
+  block = GNUNET_malloc(totalsize);
   blockptr = block;
-  GNUNET_memcpy (blockptr, sub_system, sssize);
+  GNUNET_memcpy(blockptr, sub_system, sssize);
   blockptr += sssize;
-  GNUNET_memcpy (blockptr, peer, psize);
+  GNUNET_memcpy(blockptr, peer, psize);
   blockptr += psize;
-  GNUNET_memcpy (blockptr, key, ksize);
-  GNUNET_CRYPTO_hash (block, totalsize, ret);
-  GNUNET_free (block);
+  GNUNET_memcpy(blockptr, key, ksize);
+  GNUNET_CRYPTO_hash(block, totalsize, ret);
+  GNUNET_free(block);
 }
 
 
@@ -72,14 +72,14 @@ PEERSTORE_hash_key (const char *sub_system,
  * @return pointer to record message struct
  */
 struct GNUNET_MQ_Envelope *
-PEERSTORE_create_record_mq_envelope (const char *sub_system,
-                                     const struct GNUNET_PeerIdentity *peer,
-                                     const char *key,
-                                     const void *value,
-                                     size_t value_size,
-                                     struct GNUNET_TIME_Absolute expiry,
-                                     enum GNUNET_PEERSTORE_StoreOption options,
-                                     uint16_t msg_type)
+PEERSTORE_create_record_mq_envelope(const char *sub_system,
+                                    const struct GNUNET_PeerIdentity *peer,
+                                    const char *key,
+                                    const void *value,
+                                    size_t value_size,
+                                    struct GNUNET_TIME_Absolute expiry,
+                                    enum GNUNET_PEERSTORE_StoreOption options,
+                                    uint16_t msg_type)
 {
   struct StoreRecordMessage *srm;
   struct GNUNET_MQ_Envelope *ev;
@@ -88,32 +88,32 @@ PEERSTORE_create_record_mq_envelope (const char *sub_system,
   size_t msg_size;
   void *dummy;
 
-  GNUNET_assert (NULL != sub_system);
-  ss_size = strlen (sub_system) + 1;
+  GNUNET_assert(NULL != sub_system);
+  ss_size = strlen(sub_system) + 1;
   if (NULL == key)
     key_size = 0;
   else
-    key_size = strlen (key) + 1;
+    key_size = strlen(key) + 1;
   msg_size = ss_size + key_size + value_size;
-  ev = GNUNET_MQ_msg_extra (srm, msg_size, msg_type);
-  srm->key_size = htons (key_size);
-  srm->expiry = GNUNET_TIME_absolute_hton (expiry);
+  ev = GNUNET_MQ_msg_extra(srm, msg_size, msg_type);
+  srm->key_size = htons(key_size);
+  srm->expiry = GNUNET_TIME_absolute_hton(expiry);
   if (NULL == peer)
-    srm->peer_set = htons (GNUNET_NO);
+    srm->peer_set = htons(GNUNET_NO);
   else
-  {
-    srm->peer_set = htons (GNUNET_YES);
-    srm->peer = *peer;
-  }
-  srm->sub_system_size = htons (ss_size);
-  srm->value_size = htons (value_size);
-  srm->options = htonl (options);
+    {
+      srm->peer_set = htons(GNUNET_YES);
+      srm->peer = *peer;
+    }
+  srm->sub_system_size = htons(ss_size);
+  srm->value_size = htons(value_size);
+  srm->options = htonl(options);
   dummy = &srm[1];
-  GNUNET_memcpy (dummy, sub_system, ss_size);
+  GNUNET_memcpy(dummy, sub_system, ss_size);
   dummy += ss_size;
-  GNUNET_memcpy (dummy, key, key_size);
+  GNUNET_memcpy(dummy, key, key_size);
   dummy += key_size;
-  GNUNET_memcpy (dummy, value, value_size);
+  GNUNET_memcpy(dummy, value, value_size);
   return ev;
 }
 
@@ -125,7 +125,7 @@ PEERSTORE_create_record_mq_envelope (const char *sub_system,
  * @return Pointer to record or NULL if error
  */
 struct GNUNET_PEERSTORE_Record *
-PEERSTORE_parse_record_message (const struct StoreRecordMessage *srm)
+PEERSTORE_parse_record_message(const struct StoreRecordMessage *srm)
 {
   struct GNUNET_PEERSTORE_Record *record;
   uint16_t req_size;
@@ -134,39 +134,39 @@ PEERSTORE_parse_record_message (const struct StoreRecordMessage *srm)
   uint16_t value_size;
   char *dummy;
 
-  req_size = ntohs (srm->header.size) - sizeof (*srm);
-  ss_size = ntohs (srm->sub_system_size);
-  key_size = ntohs (srm->key_size);
-  value_size = ntohs (srm->value_size);
+  req_size = ntohs(srm->header.size) - sizeof(*srm);
+  ss_size = ntohs(srm->sub_system_size);
+  key_size = ntohs(srm->key_size);
+  value_size = ntohs(srm->value_size);
   if (ss_size + key_size + value_size != req_size)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  record = GNUNET_new (struct GNUNET_PEERSTORE_Record);
-  if (GNUNET_YES == ntohs (srm->peer_set))
-  {
-    record->peer = srm->peer;
-  }
-  record->expiry = GNUNET_TIME_absolute_ntoh (srm->expiry);
-  dummy = (char *) &srm[1];
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  record = GNUNET_new(struct GNUNET_PEERSTORE_Record);
+  if (GNUNET_YES == ntohs(srm->peer_set))
+    {
+      record->peer = srm->peer;
+    }
+  record->expiry = GNUNET_TIME_absolute_ntoh(srm->expiry);
+  dummy = (char *)&srm[1];
   if (ss_size > 0)
-  {
-    record->sub_system = GNUNET_strdup (dummy);
-    dummy += ss_size;
-  }
+    {
+      record->sub_system = GNUNET_strdup(dummy);
+      dummy += ss_size;
+    }
   if (key_size > 0)
-  {
-    record->key = GNUNET_strdup (dummy);
-    dummy += key_size;
-  }
+    {
+      record->key = GNUNET_strdup(dummy);
+      dummy += key_size;
+    }
   if (value_size > 0)
-  {
-    record->value = GNUNET_malloc (value_size);
-    GNUNET_memcpy (record->value,
-                   dummy,
-                   value_size);
-  }
+    {
+      record->value = GNUNET_malloc(value_size);
+      GNUNET_memcpy(record->value,
+                    dummy,
+                    value_size);
+    }
   record->value_size = value_size;
   return record;
 }
@@ -178,16 +178,16 @@ PEERSTORE_parse_record_message (const struct StoreRecordMessage *srm)
  * @param record
  */
 void
-PEERSTORE_destroy_record (struct GNUNET_PEERSTORE_Record *record)
+PEERSTORE_destroy_record(struct GNUNET_PEERSTORE_Record *record)
 {
   if (NULL != record->sub_system)
-    GNUNET_free (record->sub_system);
+    GNUNET_free(record->sub_system);
   if (NULL != record->key)
-    GNUNET_free (record->key);
+    GNUNET_free(record->key);
   if (NULL != record->value)
-  {
-    GNUNET_free (record->value);
-    record->value = 0;
-  }
-  GNUNET_free (record);
+    {
+      GNUNET_free(record->value);
+      record->value = 0;
+    }
+  GNUNET_free(record);
 }