crypto/kernel/crypto_kernel.c: Apply clang-format

1 files changed, 74 insertions, 49 deletions

diff --git a/crypto/kernel/crypto_kernel.c b/crypto/kernel/crypto_kernel.c
index 3caff0e..8746aca 100644
--- a/crypto/kernel/crypto_kernel.c
+++ b/crypto/kernel/crypto_kernel.c
@@ -42,9 +42,8 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
-    #include <config.h>
+#include <config.h>
 #endif
 
 #include "alloc.h"
@@ -54,8 +53,8 @@
 /* the debug module for the crypto_kernel */
 
 srtp_debug_module_t srtp_mod_crypto_kernel = {
-    0,                /* debugging is off by default */
-    "crypto kernel"   /* printable name for module   */
+    0,              /* debugging is off by default */
+    "crypto kernel" /* printable name for module   */
 };
 
 /*
@@ -107,13 +106,12 @@ srtp_crypto_kernel_t crypto_kernel = {
 
 #define MAX_RNG_TRIALS 25
 
-srtp_err_status_t srtp_crypto_kernel_init ()
+srtp_err_status_t srtp_crypto_kernel_init()
 {
     srtp_err_status_t status;
 
     /* check the security state */
     if (crypto_kernel.state == srtp_crypto_kernel_state_secure) {
-
         /*
          * we're already in the secure state, but we've been asked to
          * re-initialize, so we just re-run the self-tests and then return
@@ -150,15 +148,18 @@ srtp_err_status_t srtp_crypto_kernel_init ()
     }
 
     /* load cipher types */
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_null_cipher, SRTP_NULL_CIPHER);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_null_cipher,
+                                                 SRTP_NULL_CIPHER);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_128, SRTP_AES_ICM_128);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_128,
+                                                 SRTP_AES_ICM_128);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_256, SRTP_AES_ICM_256);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_256,
+                                                 SRTP_AES_ICM_256);
     if (status) {
         return status;
     }
@@ -167,15 +168,18 @@ srtp_err_status_t srtp_crypto_kernel_init ()
         return status;
     }
 #ifdef OPENSSL
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_192, SRTP_AES_ICM_192);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_192,
+                                                 SRTP_AES_ICM_192);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_128_openssl, SRTP_AES_GCM_128);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_128_openssl,
+                                                 SRTP_AES_GCM_128);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_256_openssl, SRTP_AES_GCM_256);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_256_openssl,
+                                                 SRTP_AES_GCM_256);
     if (status) {
         return status;
     }
@@ -205,19 +209,21 @@ srtp_err_status_t srtp_crypto_kernel_init ()
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_status ()
+srtp_err_status_t srtp_crypto_kernel_status()
 {
     srtp_err_status_t status;
-    srtp_kernel_cipher_type_t  *ctype = crypto_kernel.cipher_type_list;
-    srtp_kernel_auth_type_t    *atype = crypto_kernel.auth_type_list;
+    srtp_kernel_cipher_type_t *ctype = crypto_kernel.cipher_type_list;
+    srtp_kernel_auth_type_t *atype = crypto_kernel.auth_type_list;
 
     /* for each cipher type, describe and test */
     while (ctype != NULL) {
-        srtp_err_report(srtp_err_level_info, "cipher: %s\n", ctype->cipher_type->description);
+        srtp_err_report(srtp_err_level_info, "cipher: %s\n",
+                        ctype->cipher_type->description);
         srtp_err_report(srtp_err_level_info, "  self-test: ");
         status = srtp_cipher_type_self_test(ctype->cipher_type);
         if (status) {
-            srtp_err_report(srtp_err_level_error, "failed with error code %d\n", status);
+            srtp_err_report(srtp_err_level_error, "failed with error code %d\n",
+                            status);
             exit(status);
         }
         srtp_err_report(srtp_err_level_info, "passed\n");
@@ -226,11 +232,13 @@ srtp_err_status_t srtp_crypto_kernel_status ()
 
     /* for each auth type, describe and test */
     while (atype != NULL) {
-        srtp_err_report(srtp_err_level_info, "auth func: %s\n", atype->auth_type->description);
+        srtp_err_report(srtp_err_level_info, "auth func: %s\n",
+                        atype->auth_type->description);
         srtp_err_report(srtp_err_level_info, "  self-test: ");
         status = srtp_auth_type_self_test(atype->auth_type);
         if (status) {
-            srtp_err_report(srtp_err_level_error, "failed with error code %d\n", status);
+            srtp_err_report(srtp_err_level_error, "failed with error code %d\n",
+                            status);
             exit(status);
         }
         srtp_err_report(srtp_err_level_info, "passed\n");
@@ -242,7 +250,7 @@ srtp_err_status_t srtp_crypto_kernel_status ()
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_list_debug_modules ()
+srtp_err_status_t srtp_crypto_kernel_list_debug_modules()
 {
     srtp_kernel_debug_module_t *dm = crypto_kernel.debug_module_list;
 
@@ -252,7 +260,7 @@ srtp_err_status_t srtp_crypto_kernel_list_debug_modules ()
         srtp_err_report(srtp_err_level_info, "  %s ", dm->mod->name);
         if (dm->mod->on) {
             srtp_err_report(srtp_err_level_info, "(on)\n");
-        } else{
+        } else {
             srtp_err_report(srtp_err_level_info, "(off)\n");
         }
         dm = dm->next;
@@ -261,7 +269,7 @@ srtp_err_status_t srtp_crypto_kernel_list_debug_modules ()
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_shutdown ()
+srtp_err_status_t srtp_crypto_kernel_shutdown()
 {
     /*
      * free dynamic memory used in crypto_kernel at present
@@ -271,8 +279,7 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
     while (crypto_kernel.cipher_type_list != NULL) {
         srtp_kernel_cipher_type_t *ctype = crypto_kernel.cipher_type_list;
         crypto_kernel.cipher_type_list = ctype->next;
-        debug_print(srtp_mod_crypto_kernel,
-                    "freeing memory for cipher %s",
+        debug_print(srtp_mod_crypto_kernel, "freeing memory for cipher %s",
                     ctype->cipher_type->description);
         srtp_crypto_free(ctype);
     }
@@ -292,8 +299,7 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
         srtp_kernel_debug_module_t *kdm = crypto_kernel.debug_module_list;
         crypto_kernel.debug_module_list = kdm->next;
         debug_print(srtp_mod_crypto_kernel,
-                    "freeing memory for debug module %s",
-                    kdm->mod->name);
+                    "freeing memory for debug module %s", kdm->mod->name);
         srtp_crypto_free(kdm);
     }
 
@@ -303,7 +309,10 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
     return srtp_err_status_ok;
 }
 
-static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id, int replace)
+static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type(
+    const srtp_cipher_type_t *new_ct,
+    srtp_cipher_type_id_t id,
+    int replace)
 {
     srtp_kernel_cipher_type_t *ctype, *new_ctype;
     srtp_err_status_t status;
@@ -330,13 +339,14 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
             if (!replace) {
                 return srtp_err_status_bad_param;
             }
-            status = srtp_cipher_type_test(new_ct, ctype->cipher_type->test_data);
+            status =
+                srtp_cipher_type_test(new_ct, ctype->cipher_type->test_data);
             if (status) {
                 return status;
             }
             new_ctype = ctype;
             break;
-        }else if (new_ct == ctype->cipher_type) {
+        } else if (new_ct == ctype->cipher_type) {
             return srtp_err_status_bad_param;
         }
         ctype = ctype->next;
@@ -345,7 +355,8 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
     /* if not found, put new_ct at the head of the list */
     if (ctype == NULL) {
         /* allocate memory */
-        new_ctype = (srtp_kernel_cipher_type_t*)srtp_crypto_alloc(sizeof(srtp_kernel_cipher_type_t));
+        new_ctype = (srtp_kernel_cipher_type_t *)srtp_crypto_alloc(
+            sizeof(srtp_kernel_cipher_type_t));
         if (new_ctype == NULL) {
             return srtp_err_status_alloc_fail;
         }
@@ -362,17 +373,23 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id)
+srtp_err_status_t srtp_crypto_kernel_load_cipher_type(
+    const srtp_cipher_type_t *new_ct,
+    srtp_cipher_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_cipher_type(new_ct, id, 0);
 }
 
-srtp_err_status_t srtp_replace_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id)
+srtp_err_status_t srtp_replace_cipher_type(const srtp_cipher_type_t *new_ct,
+                                           srtp_cipher_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_cipher_type(new_ct, id, 1);
 }
 
-srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id, int replace)
+srtp_err_status_t srtp_crypto_kernel_do_load_auth_type(
+    const srtp_auth_type_t *new_at,
+    srtp_auth_type_id_t id,
+    int replace)
 {
     srtp_kernel_auth_type_t *atype, *new_atype;
     srtp_err_status_t status;
@@ -405,7 +422,7 @@ srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *
             }
             new_atype = atype;
             break;
-        }else if (new_at == atype->auth_type) {
+        } else if (new_at == atype->auth_type) {
             return srtp_err_status_bad_param;
         }
         atype = atype->next;
@@ -414,7 +431,8 @@ srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *
     /* if not found, put new_at at the head of the list */
     if (atype == NULL) {
         /* allocate memory */
-        new_atype = (srtp_kernel_auth_type_t*)srtp_crypto_alloc(sizeof(srtp_kernel_auth_type_t));
+        new_atype = (srtp_kernel_auth_type_t *)srtp_crypto_alloc(
+            sizeof(srtp_kernel_auth_type_t));
         if (new_atype == NULL) {
             return srtp_err_status_alloc_fail;
         }
@@ -429,21 +447,23 @@ srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *
     new_atype->id = id;
 
     return srtp_err_status_ok;
-
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id)
+srtp_err_status_t srtp_crypto_kernel_load_auth_type(
+    const srtp_auth_type_t *new_at,
+    srtp_auth_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_auth_type(new_at, id, 0);
 }
 
-srtp_err_status_t srtp_replace_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id)
+srtp_err_status_t srtp_replace_auth_type(const srtp_auth_type_t *new_at,
+                                         srtp_auth_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_auth_type(new_at, id, 1);
 }
 
-
-const srtp_cipher_type_t * srtp_crypto_kernel_get_cipher_type (srtp_cipher_type_id_t id)
+const srtp_cipher_type_t *srtp_crypto_kernel_get_cipher_type(
+    srtp_cipher_type_id_t id)
 {
     srtp_kernel_cipher_type_t *ctype;
 
@@ -460,8 +480,10 @@ const srtp_cipher_type_t * srtp_crypto_kernel_get_cipher_type (srtp_cipher_type_
     return NULL;
 }
 
-
-srtp_err_status_t srtp_crypto_kernel_alloc_cipher (srtp_cipher_type_id_t id, srtp_cipher_pointer_t *cp, int key_len, int tag_len)
+srtp_err_status_t srtp_crypto_kernel_alloc_cipher(srtp_cipher_type_id_t id,
+                                                  srtp_cipher_pointer_t *cp,
+                                                  int key_len,
+                                                  int tag_len)
 {
     const srtp_cipher_type_t *ct;
 
@@ -481,9 +503,7 @@ srtp_err_status_t srtp_crypto_kernel_alloc_cipher (srtp_cipher_type_id_t id, srt
     return ((ct)->alloc(cp, key_len, tag_len));
 }
 
-
-
-const srtp_auth_type_t * srtp_crypto_kernel_get_auth_type (srtp_auth_type_id_t id)
+const srtp_auth_type_t *srtp_crypto_kernel_get_auth_type(srtp_auth_type_id_t id)
 {
     srtp_kernel_auth_type_t *atype;
 
@@ -500,7 +520,10 @@ const srtp_auth_type_t * srtp_crypto_kernel_get_auth_type (srtp_auth_type_id_t i
     return NULL;
 }
 
-srtp_err_status_t srtp_crypto_kernel_alloc_auth (srtp_auth_type_id_t id, srtp_auth_pointer_t *ap, int key_len, int tag_len)
+srtp_err_status_t srtp_crypto_kernel_alloc_auth(srtp_auth_type_id_t id,
+                                                srtp_auth_pointer_t *ap,
+                                                int key_len,
+                                                int tag_len)
 {
     const srtp_auth_type_t *at;
 
@@ -520,7 +543,8 @@ srtp_err_status_t srtp_crypto_kernel_alloc_auth (srtp_auth_type_id_t id, srtp_au
     return ((at)->alloc(ap, key_len, tag_len));
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_debug_module (srtp_debug_module_t *new_dm)
+srtp_err_status_t srtp_crypto_kernel_load_debug_module(
+    srtp_debug_module_t *new_dm)
 {
     srtp_kernel_debug_module_t *kdm, *new;
 
@@ -540,7 +564,8 @@ srtp_err_status_t srtp_crypto_kernel_load_debug_module (srtp_debug_module_t *new
 
     /* put new_dm at the head of the list */
     /* allocate memory */
-    new = (srtp_kernel_debug_module_t*)srtp_crypto_alloc(sizeof(srtp_kernel_debug_module_t));
+    new = (srtp_kernel_debug_module_t *)srtp_crypto_alloc(
+        sizeof(srtp_kernel_debug_module_t));
     if (new == NULL) {
         return srtp_err_status_alloc_fail;
     }
@@ -555,7 +580,7 @@ srtp_err_status_t srtp_crypto_kernel_load_debug_module (srtp_debug_module_t *new
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_set_debug_module (const char *name, int on)
+srtp_err_status_t srtp_crypto_kernel_set_debug_module(const char *name, int on)
 {
     srtp_kernel_debug_module_t *kdm;