FS-11816: [Build-System] Update libsrtp to 2.2.0

libs/srtp/crypto/kernel/alloc.c

@@ -1,32 +1,32 @@
 /*
  * alloc.c
  *
- * memory allocation and deallocation 
+ * memory allocation and deallocation
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  */
 /*
- *	
+ *
  * Copyright (c) 2001-2017 Cisco Systems, Inc.
  * All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 
+ *
  *   Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  *   Redistributions in binary form must reproduce the above
  *   copyright notice, this list of conditions and the following
  *   disclaimer in the documentation and/or other materials provided
  *   with the distribution.
- * 
+ *
  *   Neither the name of the Cisco Systems, Inc. nor the names of its
  *   contributors may be used to endorse or promote products derived
  *   from this software without specific prior written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
@@ -43,7 +43,7 @@
  */
 
 #ifdef HAVE_CONFIG_H
-    #include <config.h>
+#include <config.h>
 #endif
 
 #include "alloc.h"
@@ -51,9 +51,9 @@
 
 /* the debug module for memory allocation */
 
-srtp_debug_module_t mod_alloc = {
-  0,                  /* debugging is off by default */
-  "alloc"             /* printable name for module   */
+srtp_debug_module_t srtp_mod_alloc = {
+    0,      /* debugging is off by default */
+    "alloc" /* printable name for module   */
 };
 
 /*
@@ -67,29 +67,35 @@ srtp_debug_module_t mod_alloc = {
 
 #if defined(HAVE_STDLIB_H)
 
-void * srtp_crypto_alloc(size_t size) {
-  void *ptr;
+void *srtp_crypto_alloc(size_t size)
+{
+    void *ptr;
 
-  ptr = malloc(size);
-    
-  if (ptr) {
-    debug_print(mod_alloc, "(location: %p) allocated", ptr);
-  } else {
-    debug_print(mod_alloc, "allocation failed (asked for %d bytes)\n", size);
-  }
+    if (!size) {
+        return NULL;
+    }
 
-  return ptr;
+    ptr = calloc(1, size);
+
+    if (ptr) {
+        debug_print(srtp_mod_alloc, "(location: %p) allocated", ptr);
+    } else {
+        debug_print(srtp_mod_alloc, "allocation failed (asked for %d bytes)\n",
+                    size);
+    }
+
+    return ptr;
 }
 
-void srtp_crypto_free(void *ptr) {
+void srtp_crypto_free(void *ptr)
+{
+    debug_print(srtp_mod_alloc, "(location: %p) freed", ptr);
 
-  debug_print(mod_alloc, "(location: %p) freed", ptr);
-
-  free(ptr);
+    free(ptr);
 }
 
-#else  /* we need to define our own memory allocation routines */
+#else /* we need to define our own memory allocation routines */
 
-#error no memory allocation defined yet 
+#error no memory allocation defined yet
 
 #endif

libs/srtp/crypto/kernel/crypto_kernel.c

@@ -42,60 +42,22 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
-    #include <config.h>
+#include <config.h>
 #endif
 
 #include "alloc.h"
 
 #include "crypto_kernel.h"
+#include "cipher_types.h"
 
 /* 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   */
 };
 
-/*
- * other generic debug modules that can be included in the kernel
- */
-
-extern srtp_debug_module_t srtp_mod_auth;
-extern srtp_debug_module_t srtp_mod_cipher;
-extern srtp_debug_module_t mod_stat;
-extern srtp_debug_module_t mod_alloc;
-
-/*
- * cipher types that can be included in the kernel
- */
-
-extern srtp_cipher_type_t srtp_null_cipher;
-extern srtp_cipher_type_t srtp_aes_icm_128;
-extern srtp_cipher_type_t srtp_aes_icm_256;
-#ifdef OPENSSL
-extern srtp_cipher_type_t srtp_aes_icm_192;
-extern srtp_cipher_type_t srtp_aes_gcm_128_openssl;
-extern srtp_cipher_type_t srtp_aes_gcm_256_openssl;
-#endif
-
-/* debug modules for cipher types */
-extern srtp_debug_module_t srtp_mod_aes_icm;
-#ifdef OPENSSL
-extern srtp_debug_module_t srtp_mod_aes_gcm;
-#endif
-
-/*
- * auth func types that can be included in the kernel
- */
-
-extern srtp_auth_type_t srtp_null_auth;
-extern srtp_auth_type_t srtp_hmac;
-
-/* debug modules for auth types */
-extern srtp_debug_module_t srtp_mod_hmac;
-
 /* crypto_kernel is a global variable, the only one of its datatype */
 
 srtp_crypto_kernel_t crypto_kernel = {
@@ -107,13 +69,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
@@ -140,25 +101,28 @@ srtp_err_status_t srtp_crypto_kernel_init ()
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_debug_module(&mod_stat);
+    status = srtp_crypto_kernel_load_debug_module(&srtp_mod_stat);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_debug_module(&mod_alloc);
+    status = srtp_crypto_kernel_load_debug_module(&srtp_mod_alloc);
     if (status) {
         return status;
     }
 
     /* 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 +131,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 +172,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 +195,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 +213,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 +223,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 +232,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 +242,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 +262,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 +272,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 +302,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 +318,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 +336,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 +385,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 +394,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 +410,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 +443,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 +466,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 +483,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,12 +506,13 @@ 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;
 
     /* defensive coding */
-    if (new_dm == NULL) {
+    if (new_dm == NULL || new_dm->name == NULL) {
         return srtp_err_status_bad_param;
     }
 
@@ -540,7 +527,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 +543,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;
 

libs/srtp/crypto/kernel/err.c

@@ -43,7 +43,7 @@
  */
 
 #ifdef HAVE_CONFIG_H
-    #include <config.h>
+#include <config.h>
 #endif
 
 #include "err.h"
@@ -54,7 +54,7 @@
 
 static FILE *srtp_err_file = NULL;
 
-srtp_err_status_t srtp_err_reporting_init ()
+srtp_err_status_t srtp_err_reporting_init()
 {
 #ifdef ERR_REPORTING_STDOUT
     srtp_err_file = stdout;
@@ -69,15 +69,16 @@ srtp_err_status_t srtp_err_reporting_init ()
     return srtp_err_status_ok;
 }
 
-static srtp_err_report_handler_func_t * srtp_err_report_handler = NULL;
+static srtp_err_report_handler_func_t *srtp_err_report_handler = NULL;
 
-srtp_err_status_t srtp_install_err_report_handler(srtp_err_report_handler_func_t func)
+srtp_err_status_t srtp_install_err_report_handler(
+    srtp_err_report_handler_func_t func)
 {
     srtp_err_report_handler = func;
     return srtp_err_status_ok;
 }
 
-void srtp_err_report (srtp_err_reporting_level_t level, const char *format, ...)
+void srtp_err_report(srtp_err_reporting_level_t level, const char *format, ...)
 {
     va_list args;
     if (srtp_err_file != NULL) {
@@ -91,12 +92,13 @@ void srtp_err_report (srtp_err_reporting_level_t level, const char *format, ...)
         if (vsnprintf(msg, sizeof(msg), format, args) > 0) {
             /* strip trailing \n, callback should not have one */
             size_t l = strlen(msg);
-            if (l && msg[l-1] == '\n') {
-                msg[l-1] = '\0';
+            if (l && msg[l - 1] == '\n') {
+                msg[l - 1] = '\0';
             }
             srtp_err_report_handler(level, msg);
             /*
-             * NOTE, need to be carefull, there is a potential that octet_string_set_to_zero() could
+             * NOTE, need to be carefull, there is a potential that
+             * octet_string_set_to_zero() could
              * call srtp_err_report() in the future, leading to recursion
              */
             octet_string_set_to_zero(msg, sizeof(msg));

libs/srtp/crypto/kernel/key.c

@@ -43,14 +43,15 @@
  */
 
 #ifdef HAVE_CONFIG_H
-    #include <config.h>
+#include <config.h>
 #endif
 
 #include "key.h"
 
 #define soft_limit 0x10000
 
-srtp_err_status_t srtp_key_limit_set (srtp_key_limit_t key, const srtp_xtd_seq_num_t s)
+srtp_err_status_t srtp_key_limit_set(srtp_key_limit_t key,
+                                     const srtp_xtd_seq_num_t s)
 {
 #ifdef NO_64BIT_MATH
     if (high32(s) == 0 && low32(s) < soft_limit) {
@@ -66,7 +67,8 @@ srtp_err_status_t srtp_key_limit_set (srtp_key_limit_t key, const srtp_xtd_seq_n
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_key_limit_clone (srtp_key_limit_t original, srtp_key_limit_t *new_key)
+srtp_err_status_t srtp_key_limit_clone(srtp_key_limit_t original,
+                                       srtp_key_limit_t *new_key)
 {
     if (original == NULL) {
         return srtp_err_status_bad_param;
@@ -75,7 +77,7 @@ srtp_err_status_t srtp_key_limit_clone (srtp_key_limit_t original, srtp_key_limi
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_key_limit_check (const srtp_key_limit_t key)
+srtp_err_status_t srtp_key_limit_check(const srtp_key_limit_t key)
 {
     if (key->state == srtp_key_state_expired) {
         return srtp_err_status_key_expired;
@@ -83,13 +85,14 @@ srtp_err_status_t srtp_key_limit_check (const srtp_key_limit_t key)
     return srtp_err_status_ok;
 }
 
-srtp_key_event_t srtp_key_limit_update (srtp_key_limit_t key)
+srtp_key_event_t srtp_key_limit_update(srtp_key_limit_t key)
 {
 #ifdef NO_64BIT_MATH
     if (low32(key->num_left) == 0) {
         // carry
-        key->num_left = make64(high32(key->num_left) - 1, low32(key->num_left) - 1);
-    }else  {
+        key->num_left =
+            make64(high32(key->num_left) - 1, low32(key->num_left) - 1);
+    } else {
         // no carry
         key->num_left = make64(high32(key->num_left), low32(key->num_left) - 1);
     }
@@ -111,10 +114,9 @@ srtp_key_event_t srtp_key_limit_update (srtp_key_limit_t key)
 #else
     if (key->num_left < 1)
 #endif
-    {   /* we just hit the hard limit */
+    { /* we just hit the hard limit */
         key->state = srtp_key_state_expired;
         return srtp_key_event_hard_limit;
     }
     return srtp_key_event_soft_limit;
 }
-