uncrustify as demanded.

1 files changed, 186 insertions, 160 deletions

diff --git a/src/credential/plugin_gnsrecord_credential.c b/src/credential/plugin_gnsrecord_credential.c
index c03f2b3e4..9207aa7ad 100644
--- a/src/credential/plugin_gnsrecord_credential.c
+++ b/src/credential/plugin_gnsrecord_credential.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file credential/plugin_gnsrecord_credential.c
@@ -43,72 +43,85 @@
  * @return NULL on error, otherwise human-readable representation of the value
  */
 static char *
-credential_value_to_string (void *cls, uint32_t type, const void *data,
-                            size_t data_size)
+credential_value_to_string(void *cls, uint32_t type, const void *data,
+                           size_t data_size)
 {
-
   const char *cdata;
 
-  switch (type) {
-  case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
-    struct GNUNET_CREDENTIAL_DelegationRecord sets;
-    char *attr_str;
-    char *subject_pkey;
-    char *tmp_str;
-    int i;
-    if (data_size < sizeof (struct GNUNET_CREDENTIAL_DelegationRecord))
-      return NULL; /* malformed */
-    GNUNET_memcpy (&sets, data, sizeof (sets));
-    cdata = data;
-    struct GNUNET_CREDENTIAL_DelegationSet set[ntohl (sets.set_count)];
-    if (GNUNET_OK != GNUNET_CREDENTIAL_delegation_set_deserialize (
-                         GNUNET_ntohll (sets.data_size), &cdata[sizeof (sets)],
-                         ntohl (sets.set_count), set))
-      return NULL;
-
-    for (i = 0; i < ntohl (sets.set_count); i++) {
-      subject_pkey =
-          GNUNET_CRYPTO_ecdsa_public_key_to_string (&set[i].subject_key);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d len attr\n",
-                  set[i].subject_attribute_len);
-      if (0 == set[i].subject_attribute_len) {
-        if (0 == i) {
-          GNUNET_asprintf (&attr_str, "%s", subject_pkey);
-        } else {
-          GNUNET_asprintf (&tmp_str, "%s,%s", attr_str, subject_pkey);
-          GNUNET_free (attr_str);
-          attr_str = tmp_str;
+  switch (type)
+    {
+    case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
+      struct GNUNET_CREDENTIAL_DelegationRecord sets;
+      char *attr_str;
+      char *subject_pkey;
+      char *tmp_str;
+      int i;
+      if (data_size < sizeof(struct GNUNET_CREDENTIAL_DelegationRecord))
+        return NULL; /* malformed */
+      GNUNET_memcpy(&sets, data, sizeof(sets));
+      cdata = data;
+      struct GNUNET_CREDENTIAL_DelegationSet set[ntohl(sets.set_count)];
+      if (GNUNET_OK != GNUNET_CREDENTIAL_delegation_set_deserialize(
+            GNUNET_ntohll(sets.data_size), &cdata[sizeof(sets)],
+            ntohl(sets.set_count), set))
+        return NULL;
+
+      for (i = 0; i < ntohl(sets.set_count); i++)
+        {
+          subject_pkey =
+            GNUNET_CRYPTO_ecdsa_public_key_to_string(&set[i].subject_key);
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%d len attr\n",
+                     set[i].subject_attribute_len);
+          if (0 == set[i].subject_attribute_len)
+            {
+              if (0 == i)
+                {
+                  GNUNET_asprintf(&attr_str, "%s", subject_pkey);
+                }
+              else
+                {
+                  GNUNET_asprintf(&tmp_str, "%s,%s", attr_str, subject_pkey);
+                  GNUNET_free(attr_str);
+                  attr_str = tmp_str;
+                }
+            }
+          else
+            {
+              if (0 == i)
+                {
+                  GNUNET_asprintf(&attr_str, "%s %s", subject_pkey,
+                                  set[i].subject_attribute);
+                }
+              else
+                {
+                  GNUNET_asprintf(&tmp_str, "%s,%s %s", attr_str, subject_pkey,
+                                  set[i].subject_attribute);
+                  GNUNET_free(attr_str);
+                  attr_str = tmp_str;
+                }
+            }
+          GNUNET_free(subject_pkey);
         }
-      } else {
-        if (0 == i) {
-          GNUNET_asprintf (&attr_str, "%s %s", subject_pkey,
-                           set[i].subject_attribute);
-        } else {
-          GNUNET_asprintf (&tmp_str, "%s,%s %s", attr_str, subject_pkey,
-                           set[i].subject_attribute);
-          GNUNET_free (attr_str);
-          attr_str = tmp_str;
-        }
-      }
-      GNUNET_free (subject_pkey);
+      return attr_str;
+    }
+
+    case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
+      struct GNUNET_CREDENTIAL_Credential *cred;
+      char *cred_str;
+
+      cred = GNUNET_CREDENTIAL_credential_deserialize(data, data_size);
+      cred_str = GNUNET_CREDENTIAL_credential_to_string(cred);
+      GNUNET_free(cred);
+      return cred_str;
+    }
+
+    case GNUNET_GNSRECORD_TYPE_POLICY: {
+      return GNUNET_strndup(data, data_size);
+    }
+
+    default:
+      return NULL;
     }
-    return attr_str;
-  }
-  case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
-    struct GNUNET_CREDENTIAL_Credential *cred;
-    char *cred_str;
-
-    cred = GNUNET_CREDENTIAL_credential_deserialize (data, data_size);
-    cred_str = GNUNET_CREDENTIAL_credential_to_string (cred);
-    GNUNET_free (cred);
-    return cred_str;
-  }
-  case GNUNET_GNSRECORD_TYPE_POLICY: {
-    return GNUNET_strndup (data, data_size);
-  }
-  default:
-    return NULL;
-  }
 }
 
 
@@ -124,100 +137,114 @@ credential_value_to_string (void *cls, uint32_t type, const void *data,
  * @return #GNUNET_OK on success
  */
 static int
-credential_string_to_value (void *cls, uint32_t type, const char *s,
-                            void **data, size_t *data_size)
+credential_string_to_value(void *cls, uint32_t type, const char *s,
+                           void **data, size_t *data_size)
 {
   if (NULL == s)
     return GNUNET_SYSERR;
-  switch (type) {
-  case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
-    struct GNUNET_CREDENTIAL_DelegationRecord *sets;
-    char attr_str[253 + 1];
-    char subject_pkey[52 + 1];
-    char *token;
-    char *tmp_str;
-    int matches = 0;
-    int entries;
-    size_t tmp_data_size;
-    int i;
-
-    tmp_str = GNUNET_strdup (s);
-    token = strtok (tmp_str, ",");
-    entries = 0;
-    tmp_data_size = 0;
-    *data_size = sizeof (struct GNUNET_CREDENTIAL_DelegationRecord);
-    while (NULL != token) {
-      matches = SSCANF (token, "%s %s", subject_pkey, attr_str);
-      if (0 == matches) {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    _ ("Unable to parse ATTR record string `%s'\n"), s);
-        GNUNET_free (tmp_str);
-        return GNUNET_SYSERR;
-      }
-      if (1 == matches) {
-        tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet);
-      } else if (2 == matches) {
-        tmp_data_size += sizeof (struct GNUNET_CREDENTIAL_DelegationRecordSet) +
-                         strlen (attr_str) + 1;
-      }
-      entries++;
-      token = strtok (NULL, ",");
+  switch (type)
+    {
+    case GNUNET_GNSRECORD_TYPE_ATTRIBUTE: {
+      struct GNUNET_CREDENTIAL_DelegationRecord *sets;
+      char attr_str[253 + 1];
+      char subject_pkey[52 + 1];
+      char *token;
+      char *tmp_str;
+      int matches = 0;
+      int entries;
+      size_t tmp_data_size;
+      int i;
+
+      tmp_str = GNUNET_strdup(s);
+      token = strtok(tmp_str, ",");
+      entries = 0;
+      tmp_data_size = 0;
+      *data_size = sizeof(struct GNUNET_CREDENTIAL_DelegationRecord);
+      while (NULL != token)
+        {
+          matches = SSCANF(token, "%s %s", subject_pkey, attr_str);
+          if (0 == matches)
+            {
+              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                         _("Unable to parse ATTR record string `%s'\n"), s);
+              GNUNET_free(tmp_str);
+              return GNUNET_SYSERR;
+            }
+          if (1 == matches)
+            {
+              tmp_data_size += sizeof(struct GNUNET_CREDENTIAL_DelegationRecordSet);
+            }
+          else if (2 == matches)
+            {
+              tmp_data_size += sizeof(struct GNUNET_CREDENTIAL_DelegationRecordSet) +
+                               strlen(attr_str) + 1;
+            }
+          entries++;
+          token = strtok(NULL, ",");
+        }
+      GNUNET_free(tmp_str);
+      tmp_str = GNUNET_strdup(s);
+      token = strtok(tmp_str, ",");
+      if (NULL == token)
+        {
+          GNUNET_free(tmp_str);
+          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Malformed string %s\n", s);
+          return GNUNET_SYSERR;
+        }
+      struct GNUNET_CREDENTIAL_DelegationSet set[entries];
+      memset(set, 0, sizeof(struct GNUNET_CREDENTIAL_DelegationSet) * entries);
+      for (i = 0; i < entries; i++)
+        {
+          matches = SSCANF(token, "%s %s", subject_pkey, attr_str);
+          GNUNET_CRYPTO_ecdsa_public_key_from_string(
+            subject_pkey, strlen(subject_pkey), &set[i].subject_key);
+          if (2 == matches)
+            {
+              set[i].subject_attribute_len = strlen(attr_str) + 1;
+              set[i].subject_attribute = GNUNET_strdup(attr_str);
+            }
+          token = strtok(NULL, ",");
+        }
+      tmp_data_size = GNUNET_CREDENTIAL_delegation_set_get_size(entries, set);
+
+      if (-1 == tmp_data_size)
+        {
+          GNUNET_free(tmp_str);
+          return GNUNET_SYSERR;
+        }
+      *data_size += tmp_data_size;
+      *data = sets = GNUNET_malloc(*data_size);
+      GNUNET_CREDENTIAL_delegation_set_serialize(entries, set, tmp_data_size,
+                                                 (char *)&sets[1]);
+      for (i = 0; i < entries; i++)
+        {
+          if (0 != set[i].subject_attribute_len)
+            GNUNET_free((char *)set[i].subject_attribute);
+        }
+      sets->set_count = htonl(entries);
+      sets->data_size = GNUNET_htonll(tmp_data_size);
+
+      GNUNET_free(tmp_str);
+      return GNUNET_OK;
     }
-    GNUNET_free (tmp_str);
-    tmp_str = GNUNET_strdup (s);
-    token = strtok (tmp_str, ",");
-    if (NULL == token) {
-      GNUNET_free (tmp_str);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed string %s\n", s);
-      return GNUNET_SYSERR;
+
+    case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
+      struct GNUNET_CREDENTIAL_Credential *cred;
+      cred = GNUNET_CREDENTIAL_credential_from_string(s);
+
+      *data_size = GNUNET_CREDENTIAL_credential_serialize(cred, (char **)data);
+      return GNUNET_OK;
     }
-    struct GNUNET_CREDENTIAL_DelegationSet set[entries];
-    memset (set, 0, sizeof (struct GNUNET_CREDENTIAL_DelegationSet) * entries);
-    for (i = 0; i < entries; i++) {
-      matches = SSCANF (token, "%s %s", subject_pkey, attr_str);
-      GNUNET_CRYPTO_ecdsa_public_key_from_string (
-          subject_pkey, strlen (subject_pkey), &set[i].subject_key);
-      if (2 == matches) {
-        set[i].subject_attribute_len = strlen (attr_str) + 1;
-        set[i].subject_attribute = GNUNET_strdup (attr_str);
-      }
-      token = strtok (NULL, ",");
+
+    case GNUNET_GNSRECORD_TYPE_POLICY: {
+      *data_size = strlen(s);
+      *data = GNUNET_strdup(s);
+      return GNUNET_OK;
     }
-    tmp_data_size = GNUNET_CREDENTIAL_delegation_set_get_size (entries, set);
 
-    if (-1 == tmp_data_size) {
-      GNUNET_free (tmp_str);
+    default:
       return GNUNET_SYSERR;
     }
-    *data_size += tmp_data_size;
-    *data = sets = GNUNET_malloc (*data_size);
-    GNUNET_CREDENTIAL_delegation_set_serialize (entries, set, tmp_data_size,
-                                                (char *)&sets[1]);
-    for (i = 0; i < entries; i++) {
-      if (0 != set[i].subject_attribute_len)
-        GNUNET_free ((char *)set[i].subject_attribute);
-    }
-    sets->set_count = htonl (entries);
-    sets->data_size = GNUNET_htonll (tmp_data_size);
-
-    GNUNET_free (tmp_str);
-    return GNUNET_OK;
-  }
-  case GNUNET_GNSRECORD_TYPE_CREDENTIAL: {
-    struct GNUNET_CREDENTIAL_Credential *cred;
-    cred = GNUNET_CREDENTIAL_credential_from_string (s);
-
-    *data_size = GNUNET_CREDENTIAL_credential_serialize (cred, (char **)data);
-    return GNUNET_OK;
-  }
-  case GNUNET_GNSRECORD_TYPE_POLICY: {
-    *data_size = strlen (s);
-    *data = GNUNET_strdup (s);
-    return GNUNET_OK;
-  }
-  default:
-    return GNUNET_SYSERR;
-  }
 }
 
 
@@ -225,14 +252,13 @@ credential_string_to_value (void *cls, uint32_t type, const char *s,
  * Mapping of record type numbers to human-readable
  * record type names.
  */
-static struct
-{
+static struct {
   const char *name;
   uint32_t number;
-} name_map[] = {{"CRED", GNUNET_GNSRECORD_TYPE_CREDENTIAL},
-                {"ATTR", GNUNET_GNSRECORD_TYPE_ATTRIBUTE},
-                {"POLICY", GNUNET_GNSRECORD_TYPE_POLICY},
-                {NULL, UINT32_MAX}};
+} name_map[] = { { "CRED", GNUNET_GNSRECORD_TYPE_CREDENTIAL },
+                 { "ATTR", GNUNET_GNSRECORD_TYPE_ATTRIBUTE },
+                 { "POLICY", GNUNET_GNSRECORD_TYPE_POLICY },
+                 { NULL, UINT32_MAX } };
 
 
 /**
@@ -243,13 +269,13 @@ static struct
  * @return corresponding number, UINT32_MAX on error
  */
 static uint32_t
-credential_typename_to_number (void *cls, const char *gns_typename)
+credential_typename_to_number(void *cls, const char *gns_typename)
 {
   unsigned int i;
 
   i = 0;
   while ((name_map[i].name != NULL) &&
-         (0 != strcasecmp (gns_typename, name_map[i].name)))
+         (0 != strcasecmp(gns_typename, name_map[i].name)))
     i++;
   return name_map[i].number;
 }
@@ -263,7 +289,7 @@ credential_typename_to_number (void *cls, const char *gns_typename)
  * @return corresponding typestring, NULL on error
  */
 static const char *
-credential_number_to_typename (void *cls, uint32_t type)
+credential_number_to_typename(void *cls, uint32_t type)
 {
   unsigned int i;
 
@@ -281,11 +307,11 @@ credential_number_to_typename (void *cls, uint32_t type)
  * @return the exported block API
  */
 void *
-libgnunet_plugin_gnsrecord_credential_init (void *cls)
+libgnunet_plugin_gnsrecord_credential_init(void *cls)
 {
   struct GNUNET_GNSRECORD_PluginFunctions *api;
 
-  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api = GNUNET_new(struct GNUNET_GNSRECORD_PluginFunctions);
   api->value_to_string = &credential_value_to_string;
   api->string_to_value = &credential_string_to_value;
   api->typename_to_number = &credential_typename_to_number;
@@ -301,11 +327,11 @@ libgnunet_plugin_gnsrecord_credential_init (void *cls)
  * @return NULL
  */
 void *
-libgnunet_plugin_gnsrecord_credential_done (void *cls)
+libgnunet_plugin_gnsrecord_credential_done(void *cls)
 {
   struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
 
-  GNUNET_free (api);
+  GNUNET_free(api);
   return NULL;
 }