1 files changed, 222 insertions, 222 deletions

diff --git a/src/credential/credential_serialization.c b/src/credential/credential_serialization.c
index 5ee3cfb07..eac310272 100644
--- a/src/credential/credential_serialization.c
+++ b/src/credential/credential_serialization.c
@@ -11,17 +11,17 @@
      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/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 
 /**
  * @file credential/credential_serialization.c
- * @brief API to serialize and deserialize delegation chains 
+ * @brief API to serialize and deserialize delegation chains
  * and credentials
  * @author Martin Schanzenbach
  */
@@ -41,19 +41,19 @@
  * @return the required size to serialize
  */
 size_t
-GNUNET_CREDENTIAL_delegation_set_get_size (unsigned int ds_count,
-                                           const struct GNUNET_CREDENTIAL_DelegationSet *dsr)
+GNUNET_CREDENTIAL_delegation_set_get_size(unsigned int ds_count,
+                                          const struct GNUNET_CREDENTIAL_DelegationSet *dsr)
 {
   unsigned int i;
   size_t ret;
 
-  ret = sizeof (struct DelegationRecordData) * (ds_count);
+  ret = sizeof(struct DelegationRecordData) * (ds_count);
 
-  for (i=0; i<ds_count;i++)
-  {
-    GNUNET_assert ((ret + dsr[i].subject_attribute_len) >= ret);
-    ret += dsr[i].subject_attribute_len;
-  }
+  for (i = 0; i < ds_count; i++)
+    {
+      GNUNET_assert((ret + dsr[i].subject_attribute_len) >= ret);
+      ret += dsr[i].subject_attribute_len;
+    }
   return ret;
 }
 
@@ -67,35 +67,35 @@ GNUNET_CREDENTIAL_delegation_set_get_size (unsigned int ds_count,
  * @return the size of the data, -1 on failure
  */
 ssize_t
-GNUNET_CREDENTIAL_delegation_set_serialize (unsigned int d_count,
-                                            const struct GNUNET_CREDENTIAL_DelegationSet *dsr,
-                                            size_t dest_size,
-                                            char *dest)
+GNUNET_CREDENTIAL_delegation_set_serialize(unsigned int d_count,
+                                           const struct GNUNET_CREDENTIAL_DelegationSet *dsr,
+                                           size_t dest_size,
+                                           char *dest)
 {
   struct DelegationRecordData rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<d_count;i++)
-  {
-    rec.subject_attribute_len = htonl ((uint32_t) dsr[i].subject_attribute_len);
-    rec.subject_key = dsr[i].subject_key;
-    if (off + sizeof (rec) > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   &rec,
-                   sizeof (rec));
-    off += sizeof (rec);
-    if (0 == dsr[i].subject_attribute_len)
-      continue;
-    if (off + dsr[i].subject_attribute_len > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   dsr[i].subject_attribute,
-                   dsr[i].subject_attribute_len);
-    off += dsr[i].subject_attribute_len;
-  }
+  for (i = 0; i < d_count; i++)
+    {
+      rec.subject_attribute_len = htonl((uint32_t)dsr[i].subject_attribute_len);
+      rec.subject_key = dsr[i].subject_key;
+      if (off + sizeof(rec) > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    &rec,
+                    sizeof(rec));
+      off += sizeof(rec);
+      if (0 == dsr[i].subject_attribute_len)
+        continue;
+      if (off + dsr[i].subject_attribute_len > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    dsr[i].subject_attribute,
+                    dsr[i].subject_attribute_len);
+      off += dsr[i].subject_attribute_len;
+    }
   return off;
 }
 
@@ -110,29 +110,29 @@ GNUNET_CREDENTIAL_delegation_set_serialize (unsigned int d_count,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CREDENTIAL_delegation_set_deserialize (size_t len,
-                                              const char *src,
-                                              unsigned int d_count,
-                                              struct GNUNET_CREDENTIAL_DelegationSet *dsr)
+GNUNET_CREDENTIAL_delegation_set_deserialize(size_t len,
+                                             const char *src,
+                                             unsigned int d_count,
+                                             struct GNUNET_CREDENTIAL_DelegationSet *dsr)
 {
   struct DelegationRecordData rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<d_count;i++)
-  {
-    if (off + sizeof (rec) > len)
-      return GNUNET_SYSERR;
-    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
-    dsr[i].subject_key = rec.subject_key;
-    off += sizeof (rec);
-    dsr[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
-    if (off + dsr[i].subject_attribute_len > len)
-      return GNUNET_SYSERR;
-    dsr[i].subject_attribute = (char*)&src[off];
-    off += dsr[i].subject_attribute_len;
-  }
+  for (i = 0; i < d_count; i++)
+    {
+      if (off + sizeof(rec) > len)
+        return GNUNET_SYSERR;
+      GNUNET_memcpy(&rec, &src[off], sizeof(rec));
+      dsr[i].subject_key = rec.subject_key;
+      off += sizeof(rec);
+      dsr[i].subject_attribute_len = ntohl((uint32_t)rec.subject_attribute_len);
+      if (off + dsr[i].subject_attribute_len > len)
+        return GNUNET_SYSERR;
+      dsr[i].subject_attribute = (char*)&src[off];
+      off += dsr[i].subject_attribute_len;
+    }
   return GNUNET_OK;
 }
 
@@ -146,19 +146,19 @@ GNUNET_CREDENTIAL_delegation_set_deserialize (size_t len,
  * @return the required size to serialize
  */
 size_t
-GNUNET_CREDENTIAL_credentials_get_size (unsigned int c_count,
-                                        const struct GNUNET_CREDENTIAL_Credential *cd)
+GNUNET_CREDENTIAL_credentials_get_size(unsigned int c_count,
+                                       const struct GNUNET_CREDENTIAL_Credential *cd)
 {
   unsigned int i;
   size_t ret;
 
-  ret = sizeof (struct CredentialEntry) * (c_count);
+  ret = sizeof(struct CredentialEntry) * (c_count);
 
-  for (i=0; i<c_count;i++)
-  {
-    GNUNET_assert ((ret + cd[i].issuer_attribute_len) >= ret);
-    ret += cd[i].issuer_attribute_len;
-  }
+  for (i = 0; i < c_count; i++)
+    {
+      GNUNET_assert((ret + cd[i].issuer_attribute_len) >= ret);
+      ret += cd[i].issuer_attribute_len;
+    }
   return ret;
 }
 /**
@@ -171,38 +171,38 @@ GNUNET_CREDENTIAL_credentials_get_size (unsigned int c_count,
  * @return the size of the data, -1 on failure
  */
 ssize_t
-GNUNET_CREDENTIAL_credentials_serialize (unsigned int c_count,
-                                         const struct GNUNET_CREDENTIAL_Credential *cd,
-                                         size_t dest_size,
-                                         char *dest)
+GNUNET_CREDENTIAL_credentials_serialize(unsigned int c_count,
+                                        const struct GNUNET_CREDENTIAL_Credential *cd,
+                                        size_t dest_size,
+                                        char *dest)
 {
   struct CredentialEntry c_rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<c_count;i++)
-  {
-    c_rec.issuer_attribute_len = htonl ((uint32_t) cd[i].issuer_attribute_len);
-    c_rec.issuer_key = cd[i].issuer_key;
-    c_rec.subject_key = cd[i].subject_key;
-    c_rec.signature = cd[i].signature;
-    c_rec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CREDENTIAL);
-    c_rec.purpose.size = htonl ((sizeof (struct CredentialEntry) + cd[i].issuer_attribute_len) - sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
-    c_rec.expiration = GNUNET_htonll (cd[i].expiration.abs_value_us);
-    if (off + sizeof (c_rec) > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   &c_rec,
-                   sizeof (c_rec));
-    off += sizeof (c_rec);
-    if (off + cd[i].issuer_attribute_len > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   cd[i].issuer_attribute,
-                   cd[i].issuer_attribute_len);
-    off += cd[i].issuer_attribute_len;
-  }
+  for (i = 0; i < c_count; i++)
+    {
+      c_rec.issuer_attribute_len = htonl((uint32_t)cd[i].issuer_attribute_len);
+      c_rec.issuer_key = cd[i].issuer_key;
+      c_rec.subject_key = cd[i].subject_key;
+      c_rec.signature = cd[i].signature;
+      c_rec.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL);
+      c_rec.purpose.size = htonl((sizeof(struct CredentialEntry) + cd[i].issuer_attribute_len) - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
+      c_rec.expiration = GNUNET_htonll(cd[i].expiration.abs_value_us);
+      if (off + sizeof(c_rec) > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    &c_rec,
+                    sizeof(c_rec));
+      off += sizeof(c_rec);
+      if (off + cd[i].issuer_attribute_len > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    cd[i].issuer_attribute,
+                    cd[i].issuer_attribute_len);
+      off += cd[i].issuer_attribute_len;
+    }
 
   return off;
 }
@@ -219,32 +219,32 @@ GNUNET_CREDENTIAL_credentials_serialize (unsigned int c_count,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CREDENTIAL_credentials_deserialize (size_t len,
-                                           const char *src,
-                                           unsigned int c_count,
-                                           struct GNUNET_CREDENTIAL_Credential *cd)
+GNUNET_CREDENTIAL_credentials_deserialize(size_t len,
+                                          const char *src,
+                                          unsigned int c_count,
+                                          struct GNUNET_CREDENTIAL_Credential *cd)
 {
   struct CredentialEntry c_rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<c_count;i++)
-  {
-    if (off + sizeof (c_rec) > len)
-      return GNUNET_SYSERR;
-    GNUNET_memcpy (&c_rec, &src[off], sizeof (c_rec));
-    cd[i].issuer_attribute_len = ntohl ((uint32_t) c_rec.issuer_attribute_len);
-    cd[i].issuer_key = c_rec.issuer_key;
-    cd[i].subject_key = c_rec.subject_key;
-    cd[i].signature = c_rec.signature;
-    cd[i].expiration.abs_value_us = GNUNET_ntohll(c_rec.expiration);
-    off += sizeof (c_rec);
-    if (off + cd[i].issuer_attribute_len > len)
-      return GNUNET_SYSERR;
-    cd[i].issuer_attribute = &src[off];
-    off += cd[i].issuer_attribute_len;
-  }
+  for (i = 0; i < c_count; i++)
+    {
+      if (off + sizeof(c_rec) > len)
+        return GNUNET_SYSERR;
+      GNUNET_memcpy(&c_rec, &src[off], sizeof(c_rec));
+      cd[i].issuer_attribute_len = ntohl((uint32_t)c_rec.issuer_attribute_len);
+      cd[i].issuer_key = c_rec.issuer_key;
+      cd[i].subject_key = c_rec.subject_key;
+      cd[i].signature = c_rec.signature;
+      cd[i].expiration.abs_value_us = GNUNET_ntohll(c_rec.expiration);
+      off += sizeof(c_rec);
+      if (off + cd[i].issuer_attribute_len > len)
+        return GNUNET_SYSERR;
+      cd[i].issuer_attribute = &src[off];
+      off += cd[i].issuer_attribute_len;
+    }
   return GNUNET_OK;
 }
 
@@ -261,24 +261,24 @@ GNUNET_CREDENTIAL_credentials_deserialize (size_t len,
  * @return the required size to serialize
  */
 size_t
-GNUNET_CREDENTIAL_delegation_chain_get_size (unsigned int d_count,
-                                             const struct GNUNET_CREDENTIAL_Delegation *dd,
-                                             unsigned int c_count,
-                                             const struct GNUNET_CREDENTIAL_Credential *cd)
+GNUNET_CREDENTIAL_delegation_chain_get_size(unsigned int d_count,
+                                            const struct GNUNET_CREDENTIAL_Delegation *dd,
+                                            unsigned int c_count,
+                                            const struct GNUNET_CREDENTIAL_Credential *cd)
 {
   unsigned int i;
   size_t ret;
 
-  ret = sizeof (struct ChainEntry) * (d_count);
+  ret = sizeof(struct ChainEntry) * (d_count);
 
-  for (i=0; i<d_count;i++)
-  {
-    GNUNET_assert ((ret +
-                    dd[i].issuer_attribute_len +
-                    dd[i].subject_attribute_len) >= ret);
-    ret += dd[i].issuer_attribute_len + dd[i].subject_attribute_len;
-  }
-  return ret+GNUNET_CREDENTIAL_credentials_get_size(c_count, cd);
+  for (i = 0; i < d_count; i++)
+    {
+      GNUNET_assert((ret +
+                     dd[i].issuer_attribute_len +
+                     dd[i].subject_attribute_len) >= ret);
+      ret += dd[i].issuer_attribute_len + dd[i].subject_attribute_len;
+    }
+  return ret + GNUNET_CREDENTIAL_credentials_get_size(c_count, cd);
 }
 
 /**
@@ -293,49 +293,49 @@ GNUNET_CREDENTIAL_delegation_chain_get_size (unsigned int d_count,
  * @return the size of the data, -1 on failure
  */
 ssize_t
-GNUNET_CREDENTIAL_delegation_chain_serialize (unsigned int d_count,
-                                              const struct GNUNET_CREDENTIAL_Delegation *dd,
-                                              unsigned int c_count,
-                                              const struct GNUNET_CREDENTIAL_Credential *cd,
-                                              size_t dest_size,
-                                              char *dest)
+GNUNET_CREDENTIAL_delegation_chain_serialize(unsigned int d_count,
+                                             const struct GNUNET_CREDENTIAL_Delegation *dd,
+                                             unsigned int c_count,
+                                             const struct GNUNET_CREDENTIAL_Credential *cd,
+                                             size_t dest_size,
+                                             char *dest)
 {
   struct ChainEntry rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<d_count;i++)
-  {
-    rec.issuer_attribute_len = htonl ((uint32_t) dd[i].issuer_attribute_len);
-    rec.subject_attribute_len = htonl ((uint32_t) dd[i].subject_attribute_len);
-    rec.issuer_key = dd[i].issuer_key;
-    rec.subject_key = dd[i].subject_key;
-    if (off + sizeof (rec) > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   &rec,
-                   sizeof (rec));
-    off += sizeof (rec);
-    if (off + dd[i].issuer_attribute_len > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   dd[i].issuer_attribute,
-                   dd[i].issuer_attribute_len);
-    off += dd[i].issuer_attribute_len;
-    if (0 == dd[i].subject_attribute_len)
-      continue;
-    if (off + dd[i].subject_attribute_len > dest_size)
-      return -1;
-    GNUNET_memcpy (&dest[off],
-                   dd[i].subject_attribute,
-                   dd[i].subject_attribute_len);
-    off += dd[i].subject_attribute_len;
-  }
-  return off+GNUNET_CREDENTIAL_credentials_serialize (c_count,
-                                                      cd,
-                                                      dest_size-off,
-                                                      &dest[off]);
+  for (i = 0; i < d_count; i++)
+    {
+      rec.issuer_attribute_len = htonl((uint32_t)dd[i].issuer_attribute_len);
+      rec.subject_attribute_len = htonl((uint32_t)dd[i].subject_attribute_len);
+      rec.issuer_key = dd[i].issuer_key;
+      rec.subject_key = dd[i].subject_key;
+      if (off + sizeof(rec) > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    &rec,
+                    sizeof(rec));
+      off += sizeof(rec);
+      if (off + dd[i].issuer_attribute_len > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    dd[i].issuer_attribute,
+                    dd[i].issuer_attribute_len);
+      off += dd[i].issuer_attribute_len;
+      if (0 == dd[i].subject_attribute_len)
+        continue;
+      if (off + dd[i].subject_attribute_len > dest_size)
+        return -1;
+      GNUNET_memcpy(&dest[off],
+                    dd[i].subject_attribute,
+                    dd[i].subject_attribute_len);
+      off += dd[i].subject_attribute_len;
+    }
+  return off + GNUNET_CREDENTIAL_credentials_serialize(c_count,
+                                                       cd,
+                                                       dest_size - off,
+                                                       &dest[off]);
 }
 
 
@@ -351,107 +351,107 @@ GNUNET_CREDENTIAL_delegation_chain_serialize (unsigned int d_count,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CREDENTIAL_delegation_chain_deserialize (size_t len,
-                                                const char *src,
-                                                unsigned int d_count,
-                                                struct GNUNET_CREDENTIAL_Delegation *dd,
-                                                unsigned int c_count,
-                                                struct GNUNET_CREDENTIAL_Credential *cd)
+GNUNET_CREDENTIAL_delegation_chain_deserialize(size_t len,
+                                               const char *src,
+                                               unsigned int d_count,
+                                               struct GNUNET_CREDENTIAL_Delegation *dd,
+                                               unsigned int c_count,
+                                               struct GNUNET_CREDENTIAL_Credential *cd)
 {
   struct ChainEntry rec;
   unsigned int i;
   size_t off;
 
   off = 0;
-  for (i=0;i<d_count;i++)
-  {
-    if (off + sizeof (rec) > len)
-      return GNUNET_SYSERR;
-    GNUNET_memcpy (&rec, &src[off], sizeof (rec));
-    dd[i].issuer_attribute_len = ntohl ((uint32_t) rec.issuer_attribute_len);
-    dd[i].issuer_key = rec.issuer_key;
-    dd[i].subject_key = rec.subject_key;
-    off += sizeof (rec);
-    if (off + dd[i].issuer_attribute_len > len)
-      return GNUNET_SYSERR;
-    dd[i].issuer_attribute = &src[off];
-    off += dd[i].issuer_attribute_len;
-    dd[i].subject_attribute_len = ntohl ((uint32_t) rec.subject_attribute_len);
-    if (off + dd[i].subject_attribute_len > len)
-      return GNUNET_SYSERR;
-    dd[i].subject_attribute = &src[off];
-    off += dd[i].subject_attribute_len;
-  }
-  return GNUNET_CREDENTIAL_credentials_deserialize (len-off,
-                                                    &src[off],
-                                                    c_count,
-                                                    cd);
+  for (i = 0; i < d_count; i++)
+    {
+      if (off + sizeof(rec) > len)
+        return GNUNET_SYSERR;
+      GNUNET_memcpy(&rec, &src[off], sizeof(rec));
+      dd[i].issuer_attribute_len = ntohl((uint32_t)rec.issuer_attribute_len);
+      dd[i].issuer_key = rec.issuer_key;
+      dd[i].subject_key = rec.subject_key;
+      off += sizeof(rec);
+      if (off + dd[i].issuer_attribute_len > len)
+        return GNUNET_SYSERR;
+      dd[i].issuer_attribute = &src[off];
+      off += dd[i].issuer_attribute_len;
+      dd[i].subject_attribute_len = ntohl((uint32_t)rec.subject_attribute_len);
+      if (off + dd[i].subject_attribute_len > len)
+        return GNUNET_SYSERR;
+      dd[i].subject_attribute = &src[off];
+      off += dd[i].subject_attribute_len;
+    }
+  return GNUNET_CREDENTIAL_credentials_deserialize(len - off,
+                                                   &src[off],
+                                                   c_count,
+                                                   cd);
 }
 int
-GNUNET_CREDENTIAL_credential_serialize (struct GNUNET_CREDENTIAL_Credential *cred,
-                                        char **data)
+GNUNET_CREDENTIAL_credential_serialize(struct GNUNET_CREDENTIAL_Credential *cred,
+                                       char **data)
 {
   size_t size;
   struct CredentialEntry *cdata;
 
-  size = sizeof (struct CredentialEntry) + strlen (cred->issuer_attribute) + 1;
-  *data = GNUNET_malloc (size);
+  size = sizeof(struct CredentialEntry) + strlen(cred->issuer_attribute) + 1;
+  *data = GNUNET_malloc(size);
   cdata = (struct CredentialEntry*)*data;
   cdata->subject_key = cred->subject_key;
   cdata->issuer_key = cred->issuer_key;
-  cdata->expiration = GNUNET_htonll (cred->expiration.abs_value_us);
+  cdata->expiration = GNUNET_htonll(cred->expiration.abs_value_us);
   cdata->signature = cred->signature;
-  cdata->issuer_attribute_len = htonl (strlen (cred->issuer_attribute) + 1);
-  cdata->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CREDENTIAL);
-  cdata->purpose.size = htonl (size - sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
-  GNUNET_memcpy (&cdata[1],
-                 cred->issuer_attribute,
-                 strlen (cred->issuer_attribute));
-
-  if(GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL, 
-                                             &cdata->purpose,
-                                             &cdata->signature,
-                                             &cdata->issuer_key))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Invalid credential\n");
-    //return NULL;
-  }
+  cdata->issuer_attribute_len = htonl(strlen(cred->issuer_attribute) + 1);
+  cdata->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL);
+  cdata->purpose.size = htonl(size - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
+  GNUNET_memcpy(&cdata[1],
+                cred->issuer_attribute,
+                strlen(cred->issuer_attribute));
+
+  if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL,
+                                              &cdata->purpose,
+                                              &cdata->signature,
+                                              &cdata->issuer_key))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Invalid credential\n");
+      //return NULL;
+    }
   return size;
 }
 
 struct GNUNET_CREDENTIAL_Credential*
-GNUNET_CREDENTIAL_credential_deserialize (const char* data,
-                                          size_t data_size)
+GNUNET_CREDENTIAL_credential_deserialize(const char* data,
+                                         size_t data_size)
 {
   struct GNUNET_CREDENTIAL_Credential *cred;
   struct CredentialEntry *cdata;
   char *issuer_attribute;
 
-  if (data_size < sizeof (struct CredentialEntry))
+  if (data_size < sizeof(struct CredentialEntry))
     return NULL;
   cdata = (struct CredentialEntry*)data;
-  if(GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL, 
-                                             &cdata->purpose,
-                                             &cdata->signature,
-                                             &cdata->issuer_key))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Invalid credential\n");
-    //return NULL;
-  }
+  if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_CREDENTIAL,
+                                              &cdata->purpose,
+                                              &cdata->signature,
+                                              &cdata->issuer_key))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "Invalid credential\n");
+      //return NULL;
+    }
   issuer_attribute = (char*)&cdata[1];
 
-  cred = GNUNET_malloc (sizeof (struct GNUNET_CREDENTIAL_Credential) + ntohl(cdata->issuer_attribute_len));
+  cred = GNUNET_malloc(sizeof(struct GNUNET_CREDENTIAL_Credential) + ntohl(cdata->issuer_attribute_len));
 
   cred->issuer_key = cdata->issuer_key;
   cred->subject_key = cdata->subject_key;
-  GNUNET_memcpy (&cred[1],
-                 issuer_attribute,
-                 ntohl (cdata->issuer_attribute_len));
+  GNUNET_memcpy(&cred[1],
+                issuer_attribute,
+                ntohl(cdata->issuer_attribute_len));
   cred->signature = cdata->signature;
   cred->issuer_attribute = (char*)&cred[1];
-  cred->expiration.abs_value_us = GNUNET_ntohll (cdata->expiration);
+  cred->expiration.abs_value_us = GNUNET_ntohll(cdata->expiration);
   return cred;
 }