1 files changed, 395 insertions, 397 deletions

diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
index 1ea77f63a..c2ec01c04 100644
--- a/src/util/container_meta_data.c
+++ b/src/util/container_meta_data.c
@@ -162,10 +162,10 @@ GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
   if (md == NULL)
     return;
   while (NULL != (item = md->items))
-    {
-      md->items = item->next;
-      meta_item_free (item);
-    }
+  {
+    md->items = item->next;
+    meta_item_free (item);
+  }
   GNUNET_free_non_null (md->sbuf);
   GNUNET_free (md);
 }
@@ -184,10 +184,10 @@ GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
   if (md == NULL)
     return;
   while (NULL != (item = md->items))
-    {
-      md->items = item->next;
-      meta_item_free (item);
-    }
+  {
+    md->items = item->next;
+    meta_item_free (item);
+  }
   GNUNET_free_non_null (md->sbuf);
   memset (md, 0, sizeof (struct GNUNET_CONTAINER_MetaData));
 }
@@ -206,9 +206,9 @@ GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md)
  */
 int
 GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
-                                       *md1,
-                                       const struct GNUNET_CONTAINER_MetaData
-                                       *md2)
+                                       *md1,
+                                       const struct GNUNET_CONTAINER_MetaData
+                                       *md2)
 {
   struct MetaItem *i;
   struct MetaItem *j;
@@ -221,24 +221,24 @@ GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
 
   i = md1->items;
   while (NULL != i)
+  {
+    found = GNUNET_NO;
+    j = md2->items;
+    while (NULL != j)
     {
-      found = GNUNET_NO;
-      j = md2->items;
-      while (NULL != j)
-        {
-          if ((i->type == j->type) && (i->format == j->format) &&
-              (i->data_size == j->data_size) &&
-              (0 == memcmp (i->data, j->data, i->data_size)))
-            {
-              found = GNUNET_YES;
-              break;
-            }
-          j = j->next;
-        }
-      if (found == GNUNET_NO)
-        return GNUNET_NO;
-      i = i->next;
+      if ((i->type == j->type) && (i->format == j->format) &&
+          (i->data_size == j->data_size) &&
+          (0 == memcmp (i->data, j->data, i->data_size)))
+      {
+        found = GNUNET_YES;
+        break;
+      }
+      j = j->next;
     }
+    if (found == GNUNET_NO)
+      return GNUNET_NO;
+    i = i->next;
+  }
   return GNUNET_YES;
 }
 
@@ -263,11 +263,11 @@ GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
  */
 int
 GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
-                                   const char *plugin_name,
-                                   enum EXTRACTOR_MetaType type,
-                                   enum EXTRACTOR_MetaFormat format,
-                                   const char *data_mime_type,
-                                   const char *data, size_t data_len)
+                                   const char *plugin_name,
+                                   enum EXTRACTOR_MetaType type,
+                                   enum EXTRACTOR_MetaFormat format,
+                                   const char *data_mime_type, const char *data,
+                                   size_t data_len)
 {
   struct MetaItem *prev;
   struct MetaItem *pos;
@@ -277,28 +277,28 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
   prev = NULL;
   pos = md->items;
   while (NULL != pos)
+  {
+    if (pos->data_size < data_len)
+      break;
+    if ((pos->type == type) && (pos->data_size == data_len) &&
+        (0 == memcmp (pos->data, data, data_len)))
     {
-      if (pos->data_size < data_len)
-        break;
-      if ((pos->type == type) && (pos->data_size == data_len) &&
-          (0 == memcmp (pos->data, data, data_len)))
-        {
-          if ((pos->mime_type == NULL) && (data_mime_type != NULL))
-            {
-              pos->mime_type = GNUNET_strdup (data_mime_type);
-              invalidate_sbuf (md);
-            }
-          if ((pos->format == EXTRACTOR_METAFORMAT_C_STRING) &&
-              (format == EXTRACTOR_METAFORMAT_UTF8))
-            {
-              pos->format = EXTRACTOR_METAFORMAT_UTF8;
-              invalidate_sbuf (md);
-            }
-          return GNUNET_SYSERR;
-        }
-      prev = pos;
-      pos = pos->next;
+      if ((pos->mime_type == NULL) && (data_mime_type != NULL))
+      {
+        pos->mime_type = GNUNET_strdup (data_mime_type);
+        invalidate_sbuf (md);
+      }
+      if ((pos->format == EXTRACTOR_METAFORMAT_C_STRING) &&
+          (format == EXTRACTOR_METAFORMAT_UTF8))
+      {
+        pos->format = EXTRACTOR_METAFORMAT_UTF8;
+        invalidate_sbuf (md);
+      }
+      return GNUNET_SYSERR;
     }
+    prev = pos;
+    pos = pos->next;
+  }
   md->item_count++;
   i = GNUNET_malloc (sizeof (struct MetaItem));
   i->type = type;
@@ -310,23 +310,23 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
   else
     prev->next = i;
   i->mime_type =
-    (data_mime_type == NULL) ? NULL : GNUNET_strdup (data_mime_type);
+      (data_mime_type == NULL) ? NULL : GNUNET_strdup (data_mime_type);
   i->plugin_name = (plugin_name == NULL) ? NULL : GNUNET_strdup (plugin_name);
   i->data = GNUNET_malloc (data_len);
   memcpy (i->data, data, data_len);
   /* change OS native dir separators to unix '/' and others to '_' */
   if (type == EXTRACTOR_METATYPE_FILENAME)
+  {
+    p = i->data;
+    while ((*p != '\0') && (p < i->data + data_len))
     {
-      p = i->data;
-      while ((*p != '\0') && (p < i->data + data_len))
-        {
-          if (*p == DIR_SEPARATOR)
-            *p = '/';
-          else if (*p == '\\')
-            *p = '_';
-          p++;
-        }
+      if (*p == DIR_SEPARATOR)
+        *p = '/';
+      else if (*p == '\\')
+        *p = '_';
+      p++;
     }
+  }
   invalidate_sbuf (md);
   return GNUNET_OK;
 }
@@ -349,14 +349,14 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
  * @return 0 (to continue)
  */
 static int
-merge_helper (void *cls, const char *plugin_name,
-              enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format,
-              const char *data_mime_type, const char *data, size_t data_len)
+merge_helper (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
+              enum EXTRACTOR_MetaFormat format, const char *data_mime_type,
+              const char *data, size_t data_len)
 {
   struct GNUNET_CONTAINER_MetaData *md = cls;
 
   (void) GNUNET_CONTAINER_meta_data_insert (md, plugin_name, type, format,
-                                            data_mime_type, data, data_len);
+                                            data_mime_type, data, data_len);
   return 0;
 }
 
@@ -370,7 +370,7 @@ merge_helper (void *cls, const char *plugin_name,
  */
 void
 GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md,
-                                  const struct GNUNET_CONTAINER_MetaData *in)
+                                  const struct GNUNET_CONTAINER_MetaData *in)
 {
   GNUNET_CONTAINER_meta_data_iterate (in, &merge_helper, md);
 }
@@ -388,8 +388,8 @@ GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md,
  */
 int
 GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
-                                   enum EXTRACTOR_MetaType type,
-                                   const char *data, size_t data_len)
+                                   enum EXTRACTOR_MetaType type,
+                                   const char *data, size_t data_len)
 {
   struct MetaItem *pos;
   struct MetaItem *prev;
@@ -397,24 +397,24 @@ GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
   prev = NULL;
   pos = md->items;
   while (NULL != pos)
+  {
+    if ((pos->type == type) &&
+        ((data == NULL) ||
+         ((pos->data_size == data_len) &&
+          (0 == memcmp (pos->data, data, data_len)))))
     {
-      if ((pos->type == type) &&
-          ((data == NULL) ||
-           ((pos->data_size == data_len) &&
-            (0 == memcmp (pos->data, data, data_len)))))
-        {
-          if (prev == NULL)
-            md->items = pos->next;
-          else
-            prev->next = pos->next;
-          meta_item_free (pos);
-          md->item_count--;
-          invalidate_sbuf (md);
-          return GNUNET_OK;
-        }
-      prev = pos;
-      pos = pos->next;
+      if (prev == NULL)
+        md->items = pos->next;
+      else
+        prev->next = pos->next;
+      meta_item_free (pos);
+      md->item_count--;
+      invalidate_sbuf (md);
+      return GNUNET_OK;
     }
+    prev = pos;
+    pos = pos->next;
+  }
   return GNUNET_SYSERR;
 }
 
@@ -427,20 +427,19 @@ GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
  */
 void
 GNUNET_CONTAINER_meta_data_add_publication_date (struct
-                                                 GNUNET_CONTAINER_MetaData
-                                                 *md)
+                                                 GNUNET_CONTAINER_MetaData *md)
 {
   char *dat;
   struct GNUNET_TIME_Absolute t;
 
   t = GNUNET_TIME_absolute_get ();
   GNUNET_CONTAINER_meta_data_delete (md, EXTRACTOR_METATYPE_PUBLICATION_DATE,
-                                     NULL, 0);
+                                     NULL, 0);
   dat = GNUNET_STRINGS_absolute_time_to_string (t);
   GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
-                                     EXTRACTOR_METATYPE_PUBLICATION_DATE,
-                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                     dat, strlen (dat) + 1);
+                                     EXTRACTOR_METATYPE_PUBLICATION_DATE,
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     dat, strlen (dat) + 1);
   GNUNET_free (dat);
 }
 
@@ -454,9 +453,9 @@ GNUNET_CONTAINER_meta_data_add_publication_date (struct
  * @return number of entries
  */
 int
-GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData
-                                    *md, EXTRACTOR_MetaDataProcessor iter,
-                                    void *iter_cls)
+GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
+                                    EXTRACTOR_MetaDataProcessor iter,
+                                    void *iter_cls)
 {
   struct MetaItem *pos;
 
@@ -466,13 +465,13 @@ GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData
     return md->item_count;
   pos = md->items;
   while (NULL != pos)
-    {
-      if (0 !=
-          iter (iter_cls, pos->plugin_name, pos->type, pos->format,
-                pos->mime_type, pos->data, pos->data_size))
-        return md->item_count;
-      pos = pos->next;
-    }
+  {
+    if (0 !=
+        iter (iter_cls, pos->plugin_name, pos->type, pos->format,
+              pos->mime_type, pos->data, pos->data_size))
+      return md->item_count;
+    pos = pos->next;
+  }
   return md->item_count;
 }
 
@@ -489,7 +488,7 @@ GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData
  */
 char *
 GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData
-                                        *md, enum EXTRACTOR_MetaType type)
+                                        *md, enum EXTRACTOR_MetaType type)
 {
   struct MetaItem *pos;
 
@@ -497,13 +496,13 @@ GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData
     return NULL;
   pos = md->items;
   while (NULL != pos)
-    {
-      if ((type == pos->type) &&
-          ((pos->format == EXTRACTOR_METAFORMAT_UTF8) ||
-           (pos->format == EXTRACTOR_METAFORMAT_C_STRING)))
-        return GNUNET_strdup (pos->data);
-      pos = pos->next;
-    }
+  {
+    if ((type == pos->type) &&
+        ((pos->format == EXTRACTOR_METAFORMAT_UTF8) ||
+         (pos->format == EXTRACTOR_METAFORMAT_C_STRING)))
+      return GNUNET_strdup (pos->data);
+    pos = pos->next;
+  }
   return NULL;
 }
 
@@ -521,8 +520,8 @@ GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData
  */
 char *
 GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
-                                               GNUNET_CONTAINER_MetaData *md,
-                                               ...)
+                                               GNUNET_CONTAINER_MetaData *md,
+                                               ...)
 {
   char *ret;
   va_list args;
@@ -533,15 +532,15 @@ GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
   ret = NULL;
   va_start (args, md);
   while (1)
-    {
-      type = va_arg (args, enum EXTRACTOR_MetaType);
-
-      if (type == -1)
-        break;
-      ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type);
-      if (ret != NULL)
-        break;
-    }
+  {
+    type = va_arg (args, enum EXTRACTOR_MetaType);
+
+    if (type == -1)
+      break;
+    ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type);
+    if (ret != NULL)
+      break;
+  }
   va_end (args);
   return ret;
 }
@@ -556,9 +555,8 @@ GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
  * @return number of bytes in thumbnail, 0 if not available
  */
 size_t
-GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
-                                          GNUNET_CONTAINER_MetaData * md,
-                                          unsigned char **thumb)
+GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData
+                                          * md, unsigned char **thumb)
 {
   struct MetaItem *pos;
   struct MetaItem *match;
@@ -568,19 +566,19 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
   match = NULL;
   pos = md->items;
   while (NULL != pos)
+  {
+    if ((NULL != pos->mime_type) &&
+        (0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
+        (pos->format == EXTRACTOR_METAFORMAT_BINARY))
     {
-      if ((NULL != pos->mime_type) &&
-          (0 == strncasecmp ("image/", pos->mime_type, strlen ("image/"))) &&
-          (pos->format == EXTRACTOR_METAFORMAT_BINARY))
-        {
-          if (match == NULL)
-            match = pos;
-          else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
-                   (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
-            match = pos;
-        }
-      pos = pos->next;
+      if (match == NULL)
+        match = pos;
+      else if ((match->type != EXTRACTOR_METATYPE_THUMBNAIL) &&
+               (pos->type == EXTRACTOR_METATYPE_THUMBNAIL))
+        match = pos;
     }
+    pos = pos->next;
+  }
   if ((match == NULL) || (match->data_size == 0))
     return 0;
   *thumb = GNUNET_malloc (match->data_size);
@@ -597,7 +595,7 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
  */
 struct GNUNET_CONTAINER_MetaData *
 GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
-                                      *md)
+                                      *md)
 {
   struct GNUNET_CONTAINER_MetaData *ret;
   struct MetaItem *pos;
@@ -607,12 +605,12 @@ GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
   ret = GNUNET_CONTAINER_meta_data_create ();
   pos = md->items;
   while (NULL != pos)
-    {
-      GNUNET_CONTAINER_meta_data_insert (ret, pos->plugin_name, pos->type,
-                                         pos->format, pos->mime_type,
-                                         pos->data, pos->data_size);
-      pos = pos->next;
-    }
+  {
+    GNUNET_CONTAINER_meta_data_insert (ret, pos->plugin_name, pos->type,
+                                       pos->format, pos->mime_type, pos->data,
+                                       pos->data_size);
+    pos = pos->next;
+  }
   return ret;
 }
 
@@ -633,7 +631,7 @@ GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
  */
 static int
 try_compression (const char *data, size_t oldSize, char **result,
-                 size_t * newSize)
+                 size_t * newSize)
 {
   char *tmp;
   uLongf dlen;
@@ -648,14 +646,14 @@ try_compression (const char *data, size_t oldSize, char **result,
   tmp = GNUNET_malloc (dlen);
   if (Z_OK ==
       compress2 ((Bytef *) tmp, &dlen, (const Bytef *) data, oldSize, 9))
+  {
+    if (dlen < oldSize)
     {
-      if (dlen < oldSize)
-        {
-          *result = tmp;
-          *newSize = dlen;
-          return GNUNET_YES;
-        }
+      *result = tmp;
+      *newSize = dlen;
+      return GNUNET_YES;
     }
+  }
   GNUNET_free (tmp);
   return GNUNET_NO;
 }
@@ -756,10 +754,10 @@ struct MetaDataEntry
  */
 ssize_t
 GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
-                                      *md, char **target, size_t max,
-                                      enum
-                                      GNUNET_CONTAINER_MetaDataSerializationOptions
-                                      opt)
+                                      *md, char **target, size_t max,
+                                      enum
+                                      GNUNET_CONTAINER_MetaDataSerializationOptions
+                                      opt)
 {
   struct GNUNET_CONTAINER_MetaData *vmd;
   struct MetaItem *pos;
@@ -781,79 +779,79 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
   int comp;
 
   if (max < sizeof (struct MetaDataHeader))
-    return GNUNET_SYSERR;       /* far too small */
+    return GNUNET_SYSERR;       /* far too small */
   if (md == NULL)
     return 0;
 
   if (md->sbuf != NULL)
+  {
+    /* try to use serialization cache */
+    if (md->sbuf_size <= max)
     {
-      /* try to use serialization cache */
-      if (md->sbuf_size <= max)
-        {
-          if (NULL == *target)
-            *target = GNUNET_malloc (md->sbuf_size);
-          memcpy (*target, md->sbuf, md->sbuf_size);
-          return md->sbuf_size;
-        }
-      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
-        return GNUNET_SYSERR;   /* can say that this will fail */
-      /* need to compute a partial serialization, sbuf useless ... */
+      if (NULL == *target)
+        *target = GNUNET_malloc (md->sbuf_size);
+      memcpy (*target, md->sbuf, md->sbuf_size);
+      return md->sbuf_size;
     }
+    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
+      return GNUNET_SYSERR;     /* can say that this will fail */
+    /* need to compute a partial serialization, sbuf useless ... */
+  }
   dst = NULL;
   msize = 0;
   pos = md->items;
   while (NULL != pos)
-    {
-      msize += sizeof (struct MetaDataEntry);
-      msize += pos->data_size;
-      if (pos->plugin_name != NULL)
-        msize += strlen (pos->plugin_name) + 1;
-      if (pos->mime_type != NULL)
-        msize += strlen (pos->mime_type) + 1;
-      pos = pos->next;
-    }
+  {
+    msize += sizeof (struct MetaDataEntry);
+    msize += pos->data_size;
+    if (pos->plugin_name != NULL)
+      msize += strlen (pos->plugin_name) + 1;
+    if (pos->mime_type != NULL)
+      msize += strlen (pos->mime_type) + 1;
+    pos = pos->next;
+  }
   size = (size_t) msize;
   if (size != msize)
-    {
-      GNUNET_break (0);         /* integer overflow */
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);           /* integer overflow */
+    return GNUNET_SYSERR;
+  }
   if (size >= GNUNET_MAX_MALLOC_CHECKED)
-    {
-      /* too large to be processed */
-      return GNUNET_SYSERR;
-    }
+  {
+    /* too large to be processed */
+    return GNUNET_SYSERR;
+  }
   ent = GNUNET_malloc (size);
   mdata = (char *) &ent[md->item_count];
   off = size - (md->item_count * sizeof (struct MetaDataEntry));
   i = 0;
   pos = md->items;
   while (NULL != pos)
-    {
-      ent[i].type = htonl ((uint32_t) pos->type);
-      ent[i].format = htonl ((uint32_t) pos->format);
-      ent[i].data_size = htonl ((uint32_t) pos->data_size);
-      if (pos->plugin_name == NULL)
-        plen = 0;
-      else
-        plen = strlen (pos->plugin_name) + 1;
-      ent[i].plugin_name_len = htonl ((uint32_t) plen);
-      if (pos->mime_type == NULL)
-        mlen = 0;
-      else
-        mlen = strlen (pos->mime_type) + 1;
-      ent[i].mime_type_len = htonl ((uint32_t) mlen);
-      off -= pos->data_size;
-      memcpy (&mdata[off], pos->data, pos->data_size);
-      off -= plen;
-      if (pos->plugin_name != NULL)
-        memcpy (&mdata[off], pos->plugin_name, plen);
-      off -= mlen;
-      if (pos->mime_type != NULL)
-        memcpy (&mdata[off], pos->mime_type, mlen);
-      i++;
-      pos = pos->next;
-    }
+  {
+    ent[i].type = htonl ((uint32_t) pos->type);
+    ent[i].format = htonl ((uint32_t) pos->format);
+    ent[i].data_size = htonl ((uint32_t) pos->data_size);
+    if (pos->plugin_name == NULL)
+      plen = 0;
+    else
+      plen = strlen (pos->plugin_name) + 1;
+    ent[i].plugin_name_len = htonl ((uint32_t) plen);
+    if (pos->mime_type == NULL)
+      mlen = 0;
+    else
+      mlen = strlen (pos->mime_type) + 1;
+    ent[i].mime_type_len = htonl ((uint32_t) mlen);
+    off -= pos->data_size;
+    memcpy (&mdata[off], pos->data, pos->data_size);
+    off -= plen;
+    if (pos->plugin_name != NULL)
+      memcpy (&mdata[off], pos->plugin_name, plen);
+    off -= mlen;
+    if (pos->mime_type != NULL)
+      memcpy (&mdata[off], pos->mime_type, mlen);
+    i++;
+    pos = pos->next;
+  }
   GNUNET_assert (off == 0);
 
   clen = 0;
@@ -862,95 +860,95 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
   i = 0;
   pos = md->items;
   while (pos != NULL)
+  {
+    comp = GNUNET_NO;
+    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
+      comp = try_compression ((const char *) &ent[i], left, &cdata, &clen);
+
+    if ((md->sbuf == NULL) && (i == 0))
+    {
+      /* fill 'sbuf'; this "modifies" md, but since this is only
+       * an internal cache we will cast away the 'const' instead
+       * of making the API look strange. */
+      vmd = (struct GNUNET_CONTAINER_MetaData *) md;
+      hdr = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
+      hdr->size = htonl (left);
+      hdr->entries = htonl (md->item_count);
+      if (GNUNET_YES == comp)
+      {
+        GNUNET_assert (clen < left);
+        hdr->version = htonl (2 | HEADER_COMPRESSED);
+        memcpy (&hdr[1], cdata, clen);
+        vmd->sbuf_size = clen + sizeof (struct MetaDataHeader);
+      }
+      else
+      {
+        hdr->version = htonl (2);
+        memcpy (&hdr[1], &ent[0], left);
+        vmd->sbuf_size = left + sizeof (struct MetaDataHeader);
+      }
+      vmd->sbuf = (char *) hdr;
+    }
+
+    if (((left + sizeof (struct MetaDataHeader)) <= max) ||
+        ((comp == GNUNET_YES) && (clen <= max)))
+    {
+      /* success, this now fits! */
+      if (GNUNET_YES == comp)
+      {
+        if (dst == NULL)
+          dst = GNUNET_malloc (clen + sizeof (struct MetaDataHeader));
+        hdr = (struct MetaDataHeader *) dst;
+        hdr->version = htonl (2 | HEADER_COMPRESSED);
+        hdr->size = htonl (left);
+        hdr->entries = htonl (md->item_count - i);
+        memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen);
+        GNUNET_free (cdata);
+        GNUNET_free (ent);
+        rlen = clen + sizeof (struct MetaDataHeader);
+      }
+      else
+      {
+        if (dst == NULL)
+          dst = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
+        hdr = (struct MetaDataHeader *) dst;
+        hdr->version = htonl (2);
+        hdr->entries = htonl (md->item_count - i);
+        hdr->size = htonl (left);
+        memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left);
+        GNUNET_free (ent);
+        rlen = left + sizeof (struct MetaDataHeader);
+      }
+      if (NULL != *target)
+      {
+        memcpy (*target, dst, clen + sizeof (struct MetaDataHeader));
+        GNUNET_free (dst);
+      }
+      else
+      {
+        *target = dst;
+      }
+      return rlen;
+    }
+
+    if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
     {
-      comp = GNUNET_NO;
-      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS))
-        comp = try_compression ((const char *) &ent[i], left, &cdata, &clen);
-
-      if ((md->sbuf == NULL) && (i == 0))
-        {
-          /* fill 'sbuf'; this "modifies" md, but since this is only
-           * an internal cache we will cast away the 'const' instead
-           * of making the API look strange. */
-          vmd = (struct GNUNET_CONTAINER_MetaData *) md;
-          hdr = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
-          hdr->size = htonl (left);
-          hdr->entries = htonl (md->item_count);
-          if (GNUNET_YES == comp)
-            {
-              GNUNET_assert (clen < left);
-              hdr->version = htonl (2 | HEADER_COMPRESSED);
-              memcpy (&hdr[1], cdata, clen);
-              vmd->sbuf_size = clen + sizeof (struct MetaDataHeader);
-            }
-          else
-            {
-              hdr->version = htonl (2);
-              memcpy (&hdr[1], &ent[0], left);
-              vmd->sbuf_size = left + sizeof (struct MetaDataHeader);
-            }
-          vmd->sbuf = (char *) hdr;
-        }
-
-      if (((left + sizeof (struct MetaDataHeader)) <= max) ||
-          ((comp == GNUNET_YES) && (clen <= max)))
-        {
-          /* success, this now fits! */
-          if (GNUNET_YES == comp)
-            {
-              if (dst == NULL)
-                dst = GNUNET_malloc (clen + sizeof (struct MetaDataHeader));
-              hdr = (struct MetaDataHeader *) dst;
-              hdr->version = htonl (2 | HEADER_COMPRESSED);
-              hdr->size = htonl (left);
-              hdr->entries = htonl (md->item_count - i);
-              memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen);
-              GNUNET_free (cdata);
-              GNUNET_free (ent);
-              rlen = clen + sizeof (struct MetaDataHeader);
-            }
-          else
-            {
-              if (dst == NULL)
-                dst = GNUNET_malloc (left + sizeof (struct MetaDataHeader));
-              hdr = (struct MetaDataHeader *) dst;
-              hdr->version = htonl (2);
-              hdr->entries = htonl (md->item_count - i);
-              hdr->size = htonl (left);
-              memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left);
-              GNUNET_free (ent);
-              rlen = left + sizeof (struct MetaDataHeader);
-            }
-          if (NULL != *target)
-            {
-              memcpy (*target, dst, clen + sizeof (struct MetaDataHeader));
-              GNUNET_free (dst);
-            }
-          else
-            {
-              *target = dst;
-            }
-          return rlen;
-        }
-
-      if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART))
-        {
-          /* does not fit! */
-          GNUNET_free (ent);
-          return GNUNET_SYSERR;
-        }
-
-      /* next iteration: ignore the corresponding meta data at the
-       * end and try again without it */
-      left -= sizeof (struct MetaDataEntry);
-      left -= pos->data_size;
-      if (pos->plugin_name != NULL)
-        left -= strlen (pos->plugin_name) + 1;
-      if (pos->mime_type != NULL)
-        left -= strlen (pos->mime_type) + 1;
-      pos = pos->next;
-      i++;
+      /* does not fit! */
+      GNUNET_free (ent);
+      return GNUNET_SYSERR;
     }
+
+    /* next iteration: ignore the corresponding meta data at the
+     * end and try again without it */
+    left -= sizeof (struct MetaDataEntry);
+    left -= pos->data_size;
+    if (pos->plugin_name != NULL)
+      left -= strlen (pos->plugin_name) + 1;
+    if (pos->mime_type != NULL)
+      left -= strlen (pos->mime_type) + 1;
+    pos = pos->next;
+    i++;
+  }
   GNUNET_free (ent);
 
   /* nothing fit, only write header! */
@@ -972,7 +970,7 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
  */
 ssize_t
 GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
-                                                GNUNET_CONTAINER_MetaData *md)
+                                                GNUNET_CONTAINER_MetaData *md)
 {
   ssize_t ret;
   char *ptr;
@@ -981,8 +979,8 @@ GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
     return md->sbuf_size;
   ptr = NULL;
   ret =
-    GNUNET_CONTAINER_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
-                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+      GNUNET_CONTAINER_meta_data_serialize (md, &ptr, GNUNET_MAX_MALLOC_CHECKED,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   if (ret != -1)
     GNUNET_free (ptr);
   return ret;
@@ -1009,14 +1007,14 @@ decompress (const char *input, size_t inputSize, size_t outputSize)
   output = GNUNET_malloc (olen);
   if (Z_OK ==
       uncompress ((Bytef *) output, &olen, (const Bytef *) input, inputSize))
-    {
-      return output;
-    }
+  {
+    return output;
+  }
   else
-    {
-      GNUNET_free (output);
-      return NULL;
-    }
+  {
+    GNUNET_free (output);
+    return NULL;
+  }
 }
 
 
@@ -1058,121 +1056,121 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size)
   compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0;
 
   if (version == 1)
-    return NULL;                /* null pointer */
+    return NULL;                /* null pointer */
   if (version != 2)
-    {
-      GNUNET_break_op (0);      /* unsupported version */
-      return NULL;
-    }
+  {
+    GNUNET_break_op (0);        /* unsupported version */
+    return NULL;
+  }
 
   ic = ntohl (hdr.entries);
   dataSize = ntohl (hdr.size);
   if ((sizeof (struct MetaDataEntry) * ic) > dataSize)
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+
+  if (compressed)
+  {
+    if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
     {
+      /* make sure we don't blow our memory limit because of a mal-formed
+       * message... */
       GNUNET_break_op (0);
       return NULL;
     }
-
-  if (compressed)
+    data =
+        decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
+                    size - sizeof (struct MetaDataHeader), dataSize);
+    if (data == NULL)
     {
-      if (dataSize >= GNUNET_MAX_MALLOC_CHECKED)
-        {
-          /* make sure we don't blow our memory limit because of a mal-formed
-           * message... */
-          GNUNET_break_op (0);
-          return NULL;
-        }
-      data =
-        decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
-                    size - sizeof (struct MetaDataHeader), dataSize);
-      if (data == NULL)
-        {
-          GNUNET_break_op (0);
-          return NULL;
-        }
-      cdata = data;
+      GNUNET_break_op (0);
+      return NULL;
     }
+    cdata = data;
+  }
   else
+  {
+    data = NULL;
+    cdata = (const char *) &input[sizeof (struct MetaDataHeader)];
+    if (dataSize != size - sizeof (struct MetaDataHeader))
     {
-      data = NULL;
-      cdata = (const char *) &input[sizeof (struct MetaDataHeader)];
-      if (dataSize != size - sizeof (struct MetaDataHeader))
-        {
-          GNUNET_break_op (0);
-          return NULL;
-        }
+      GNUNET_break_op (0);
+      return NULL;
     }
+  }
 
   md = GNUNET_CONTAINER_meta_data_create ();
   left = dataSize - ic * sizeof (struct MetaDataEntry);
   mdata = &cdata[ic * sizeof (struct MetaDataEntry)];
   for (i = 0; i < ic; i++)
+  {
+    memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
+            sizeof (struct MetaDataEntry));
+    format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
+    if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+        (format != EXTRACTOR_METAFORMAT_C_STRING) &&
+        (format != EXTRACTOR_METAFORMAT_BINARY))
     {
-      memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)],
-              sizeof (struct MetaDataEntry));
-      format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format);
-      if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
-          (format != EXTRACTOR_METAFORMAT_C_STRING) &&
-          (format != EXTRACTOR_METAFORMAT_BINARY))
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      dlen = ntohl (ent.data_size);
-      plen = ntohl (ent.plugin_name_len);
-      mlen = ntohl (ent.mime_type_len);
-      if (dlen > left)
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      left -= dlen;
-      meta_data = &mdata[left];
-      if ((format == EXTRACTOR_METAFORMAT_UTF8) ||
-          (format == EXTRACTOR_METAFORMAT_C_STRING))
-        {
-          if ((dlen == 0) || (mdata[left + dlen - 1] != '\0'))
-            {
-              GNUNET_break_op (0);
-              break;
-            }
-        }
-      if (plen > left)
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      left -= plen;
-      if ((plen > 0) && (mdata[left + plen - 1] != '\0'))
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      if (plen == 0)
-        plugin_name = NULL;
-      else
-        plugin_name = &mdata[left];
-
-      if (mlen > left)
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      left -= mlen;
-      if ((mlen > 0) && (mdata[left + mlen - 1] != '\0'))
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      if (mlen == 0)
-        mime_type = NULL;
-      else
-        mime_type = &mdata[left];
-      GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
-                                         (enum EXTRACTOR_MetaType)
-                                         ntohl (ent.type), format, mime_type,
-                                         meta_data, dlen);
+      GNUNET_break_op (0);
+      break;
+    }
+    dlen = ntohl (ent.data_size);
+    plen = ntohl (ent.plugin_name_len);
+    mlen = ntohl (ent.mime_type_len);
+    if (dlen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= dlen;
+    meta_data = &mdata[left];
+    if ((format == EXTRACTOR_METAFORMAT_UTF8) ||
+        (format == EXTRACTOR_METAFORMAT_C_STRING))
+    {
+      if ((dlen == 0) || (mdata[left + dlen - 1] != '\0'))
+      {
+        GNUNET_break_op (0);
+        break;
+      }
+    }
+    if (plen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= plen;
+    if ((plen > 0) && (mdata[left + plen - 1] != '\0'))
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    if (plen == 0)
+      plugin_name = NULL;
+    else
+      plugin_name = &mdata[left];
+
+    if (mlen > left)
+    {
+      GNUNET_break_op (0);
+      break;
+    }
+    left -= mlen;
+    if ((mlen > 0) && (mdata[left + mlen - 1] != '\0'))
+    {
+      GNUNET_break_op (0);
+      break;
     }
+    if (mlen == 0)
+      mime_type = NULL;
+    else
+      mime_type = &mdata[left];
+    GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
+                                       (enum EXTRACTOR_MetaType)
+                                       ntohl (ent.type), format, mime_type,
+                                       meta_data, dlen);
+  }
   GNUNET_free_non_null (data);
   return md;
 }